Import every old project from personal files

arrayPointer/main.cpp

@@ -0,0 +1,51 @@
+#include <iostream>
+#include <string>
+#include <cstdlib>
+#include <ctime>
+
+using namespace std;
+
+string createWord()
+{
+    # define VOYELLE 1
+
+    int nbChr( rand() % 10 + 3 );
+    string rep("");
+
+    for ( int i(0); i < nbChr; i++ )
+    {
+        if ( rand() % 2 == VOYELLE )
+            rep += "aeiouy"[rand() % 6];
+        else
+            rep += "bcdfghjklmnpqrstvwxz"[rand() % 20];
+    }
+
+    return rep;
+}
+
+int main()
+{
+    srand( time(0) );
+    cout << "Pointeurs sur tableau !" << endl;
+    string* tab(0x0);
+    int in;
+
+    cout << "Le tableau est déjà créé mais vous pouvez choisir sa taille !" << endl;
+    cin >> in;
+    cout << endl << endl;
+
+    const int mySize(in);
+    tab = new string[mySize];
+
+    for ( int i(0); i < mySize; i++ ){
+        tab[i] = createWord();
+    }
+
+    for ( int i(0); i < mySize; i++ ){
+        cout << i << " : " << tab[i] << endl;
+    }
+
+    //delete tab;
+
+    return 0;
+}

longIntegerLab/README.md

@@ -0,0 +1 @@
+Lab number 2 from ECN school

longIntegerLab/lit_ecrit.cpp

@@ -0,0 +1,82 @@
+/*
+fichier lit_ecrit.cxx
+contient
+	- l'action AfficheEntierLong(a)
+	- la fonction LitEntierLong
+*/
+
+//inclusion de fichiers entetes
+
+#include <iostream> //pour cout et cin
+using namespace std;
+
+#include <cstring> // pour strlen
+//#include <ctype> // pour toascii
+
+#include "entierlong.h" //pour le type EntierLong
+
+#include "lit_ecrit.h" /* facultatif : permet de verifier que les types
+des parametres dans les prototypes sont bien les memes que dans les
+actions/fonctions correspondantes*/
+
+//fonction AfficheEntierLong(n)
+//affiche sur l'ecran un EntierLong
+void AfficheEntierLong(EntierLong a)
+{
+    //variables
+    int i,j;
+    // debut
+    // signe
+    if (a.negatif)
+    {
+	   cout <<"-";
+    }
+    // chiffres
+    /* on recherche le 1er chiffre non nul (ou le chiffre des unites dans le cas
+    d'un entier nul*/
+    i=MAXCHIFFRES-1;
+    while ((a.chiffres[i]==0)&&(i>0))
+    {
+    	i=i-1;
+    }
+    /*on ecrit les chiffres "utiles"*/
+    for(j=i;j>=0;j=j-1)
+    {
+    	cout << a.chiffres[j];
+    }
+    cout << endl;
+    // fin
+}
+
+//fonction LitEntierLong
+//lit au clavier un EntierLong
+EntierLong LitEntierLong()
+{
+    char Nb[MAXCHIFFRES+1];
+    EntierLong a;
+    int i,l;
+    // debut
+    cin >> Nb;
+    a.negatif = (Nb[0]=='-');
+    l=strlen(Nb);
+    if ((a.negatif)||(Nb[0]=='+'))
+    {
+    	//on decale le caractere de fin de chaine d'un indice a gauche
+    	for(i=0;i<l;i=i+1)
+    	{
+    		Nb[i]=Nb[i+1];
+    	}
+    	l=strlen(Nb);
+    }
+    for (i=0;i<l;i=i+1)
+    {
+    	a.chiffres[i] = toascii(Nb[l-1-i])-toascii('0');
+    }
+    // on complete par des 0
+    for (i=l;i<MAXCHIFFRES;i=i+1)
+    {
+    	a.chiffres[i]=0;
+    }
+    return a;
+    // fin
+}

longIntegerLab/lit_ecrit.h

@@ -0,0 +1,7 @@
+//fonction AfficheEntierLong(n)
+//affiche sur l'ecran un EntierLong
+void AfficheEntierLong(EntierLong);
+
+//fonction LitEntierLong
+//lit au clavier un EntierLong
+EntierLong LitEntierLong();

longIntegerLab/main.cpp

@@ -0,0 +1,44 @@
+#include <iostream>
+#include "entierlong.h"
+#include "utilitaires.h"
+#include "lit_ecrit.h"
+
+using namespace std;
+
+int main()
+{
+    /// Début
+    // Annonce
+    cout << "Hello world!" << endl;
+
+    // Variables
+    int a;
+    EntierLong b;
+
+    // Utilisateur
+    cout << "Rentrez a : ";
+    cin >> a;
+
+    /// Traitement
+    // Conversion
+    b = conversionEntier(a);
+
+    // Affichage
+    cout << "Voici b :" << endl;
+    AfficheEntierLong(b);
+
+    /*bool estCeQueJeMappelleJovian;
+
+    estCeQueJeMappelleJovian = true; // true
+
+    if (estCeQueJeMappelleJovian)
+    {
+        cout << "Il s'appelle Jovian !" << endl;
+    }
+    else
+    {
+        cout << "Il ne s'appelle pas Jovian !" << endl;
+    }*/
+
+    return 0;
+}

longIntegerLab/utilitaires.cpp

@@ -0,0 +1,27 @@
+#include "entierlong.h"
+
+EntierLong conversionEntier(int valeur)
+{
+    // Variable
+    EntierLong rep;
+
+    // Déterminer le signe
+    if (valeur >= 0)
+    {
+        rep.negatif = false;
+    }
+    else
+    {
+        rep.negatif = true;
+    }
+
+    // Remplir le tableau
+    for (int k = 0; k < MAXCHIFFRES; k = k + 1)
+    {
+        rep.chiffres[k] = 1;
+    }
+
+    // Fin
+    return rep;
+}
+

longIntegerLab/utilitaires.h

@@ -0,0 +1,6 @@
+#ifndef UTILITAIRES_H_INCLUDED
+#define UTILITAIRES_H_INCLUDED
+
+EntierLong conversionEntier(int valeur);
+
+#endif // UTILITAIRES_H_INCLUDED

mirrorWord/main.cpp

@@ -0,0 +1,19 @@
+#include <iostream>
+
+using namespace std;
+
+int main()
+{
+    cout << "Hello ! Welcome in the word inversor ! :-D" << endl << "Enter a word :";
+    string mot;
+    getline(cin,mot);
+    string tom;
+    while (mot.size()!=0)
+    {
+        tom += mot[mot.size()-1];
+        mot.erase(mot.size()-1);
+    }
+    cout << tom;
+
+    return 0;
+}

netChat/xayon/Network.cpp

@@ -0,0 +1,599 @@
+//
+// Created by Nathan Touroux on 29/06/2017.
+//
+
+#include "Network.h"
+
+//*********************************************** TCP DATA ***********************************************
+
+NetData::NetData(std::string str): data(nullptr), size(str.size()) {
+    copy((void*)str.c_str(), size);
+}
+NetData::NetData(const char *str): data(nullptr), size(std::strlen(str)) {
+    copy((void*)str, size);
+}
+NetData::NetData(void *data, size_data size, bool copyData) : data(data), size(size) {
+    if(copyData) copy(data, size);
+}
+NetData::NetData(const NetData &toCopy): data(nullptr), size(toCopy.size){
+    copy(toCopy.data, size);
+}
+NetData& NetData::operator=(const NetData &toCopy){
+    size = toCopy.size;
+    free(data);
+    copy(toCopy.data, size);
+    return *this;
+}
+NetData::~NetData(){
+    if(data != nullptr) free(data);
+}
+
+void NetData::copy(void* data, size_data size){
+    if(size == 0){
+        this->data = nullptr;
+    }else{
+        this->data = malloc(size);
+        memcpy(this->data, data, size);
+    }
+}
+
+bool NetData::valid(){
+    return data != nullptr && size != 0;
+}
+
+NetData::operator std::string() {
+    if(!valid()) return "";
+    char arr[size+1];
+    memcpy(arr, data, size);
+    arr[size] = '\0';
+    return std::string(arr);
+}
+
+void* NetData::getData(){
+    auto tmp = data;
+    copy(data, size);
+    return tmp;
+}
+
+size_data NetData::getSize(){
+    return size;
+}
+
+NetPacket NetData::toPacket(){
+    if(!valid()) return {nullptr, 0};
+
+    auto sizePacket = sizeof(size_data)+size;
+    auto packet = (char*)malloc(sizePacket);
+    memcpy(packet, &size, sizeof(size_data));
+    memcpy(packet+sizeof(size_data), data, size);
+    return {packet, sizePacket};
+}
+
+//**************************************************** TCP Client ****************************************************
+TCPClient::TCPClient(bool asynchronous): sock(), server(nullptr), first(nullptr), nbData(0), asyncThread(nullptr), asynchronous(asynchronous), connected(false) {
+
+}
+TCPClient::TCPClient(const TCPClient &client): sock(), server(nullptr), first(nullptr), nbData(0), asyncThread(nullptr), asynchronous(client.asynchronous.load()), connected(false){
+
+}
+
+TCPClient::~TCPClient(){
+    disconnect();
+}
+
+bool TCPClient::invalid(){
+    return !connected;
+}
+
+bool TCPClient::accept(TCPServer *server, bool receiveName){
+    if(connected) return false;//if already connected stop there
+
+    sock.sock = ::accept(server->getHostSock().sock, (SOCKADDR*)&sock.sin, &sock.recsize);
+
+    if(sock.sock == INVALID_SOCKET) return false;
+
+    sock.IP = inet_ntoa(sock.sin.sin_addr);
+
+    if(receiveName){
+        std::string name = unsafeReceive();
+        sock.name = name;
+    }
+
+    this->server = server;
+
+    connected = true;
+    if(asynchronous) asyncThread = new std::thread(asyncReceive, this);
+
+    return sock.sock != SOCKET_ERROR;
+}
+
+bool TCPClient::connect(std::string IP, int port, std::string name){
+    if(connected) return false;//if already connected stop there
+
+    sock.IP = IP;
+    sock.port = port;
+
+    sock.sock = socket(AF_INET,SOCK_STREAM, 0);
+
+    if(sock.sock == INVALID_SOCKET) return false;
+
+    sock.sin.sin_addr.s_addr = inet_addr(IP.c_str());
+    sock.sin.sin_family = AF_INET;
+    sock.sin.sin_port = htons(port);
+
+    if(::connect(sock.sock, (SOCKADDR*)&sock.sin, sock.recsize) == SOCKET_ERROR) return false;
+
+    if(!name.empty()){
+        unsafeSend(name);
+        unsafeReceive();//to confirm if name is accepted
+    }
+
+    connected = true;
+    if(asynchronous) asyncThread = new std::thread(asyncReceive, this);
+
+    return sock.sock != SOCKET_ERROR;
+}
+
+void TCPClient::disconnect(bool removeFromServer) {
+    if(!connected) return; //nothing to do
+    if(server && removeFromServer){
+        server->eraseClient(*this);
+    }else{
+        connected = false;
+        closesocket(sock.sock);
+        sock.sock = SOCKET_ERROR;
+        sock.name = "";
+        sock.IP = "";
+        //std::lock_guard<std::mutex> guard(mutex);
+        if(asyncThread){
+            std::cout << "1" << std::endl;//TODO remove
+            if(asyncThread->joinable())
+                asyncThread->detach();//TODO sometimes too slow
+            delete asyncThread;
+            asyncThread = nullptr;
+        }
+    }
+}
+
+bool TCPClient::isConnected(){
+    return connected;
+}
+
+void TCPClient::enableAsynchronous(){
+    if(asynchronous) return;//if already asynchronous, nothing to do
+    asynchronous = true;
+    if(connected) asyncThread = new std::thread(asyncReceive, this);
+}
+
+bool TCPClient::asynchronousEnabled() {
+    return asynchronous;
+}
+
+void TCPClient::asyncReceive(TCPClient *client) {
+    while(client->isConnected() && client->asynchronousEnabled()){
+        auto data = client->unsafeReceive();
+        if(data.valid())
+            client->push(data.getData(), data.getSize());
+    }
+}
+void TCPClient::push(void* data, size_data size){
+    std::lock_guard<std::mutex> guard(mutex);
+    Data *newdata = new Data{data, size, nullptr};
+    if(first == nullptr){
+        first = newdata;
+    }else{
+        last->next = newdata;
+    }
+    last = newdata;
+    nbData++;
+}
+NetData TCPClient::pop(){
+    std::lock_guard<std::mutex> guard(mutex);
+    if(first == nullptr) return NetData(nullptr, 0);
+    Data *data = first;
+    first = first->next;
+    NetData netdata(data->data, data->size, false);
+    delete data;
+    return netdata;
+}
+
+long TCPClient::unsafeSend(NetData data){
+    auto packet = data.toPacket();
+    long size = ::send(sock.sock, packet.data, packet.size, 0);
+    free(packet.data);
+    if(size == 0) if(errno == ECONNRESET) disconnect();//when sending check ECONNRESET
+    return size;
+}
+NetData TCPClient::unsafeReceive(){
+    size_data sizeByte;
+    long size = ::recv(sock.sock, &sizeByte, sizeof(size_data), 0);
+    if(size == 0) {
+        disconnect();
+        return  NetData(nullptr, 0);
+    }//when receiving just check for size == 0
+    if(sizeByte == 0) return NetData(nullptr, 0);//check that the length of data is not 0
+
+    void* data = malloc(sizeByte);
+    size = ::recv(sock.sock, data, sizeByte, 0);
+    if(size == 0) {
+        disconnect();
+        free(data);
+        return NetData(nullptr, 0);
+    }
+
+    return NetData(data, sizeByte, false);//dont copy the data just the address so it will be freed automatically after
+}
+
+long TCPClient::rawSend(void *data, size_data sizeByte) {
+    if(invalid() || asynchronous) return SOCKET_ERROR;//cant send raw packet when asynchronous
+    long size = ::send(sock.sock, data, sizeByte, 0);
+    if(size == 0) if(errno == ECONNRESET) disconnect();//when sending check ECONNRESET
+    return size;
+}
+
+long TCPClient::rawReceive(void *data, size_data sizeByte) {
+    if(invalid() || asynchronous) return SOCKET_ERROR;//cant receive raw packet when asynchronous
+    long size = ::recv(sock.sock, data, sizeByte, 0);
+    if(size == 0) disconnect();//when receiving just check for size == 0
+    return size;
+}
+
+long TCPClient::send(NetData data){
+    if(invalid()) return SOCKET_ERROR;
+    return unsafeSend(data);
+}
+NetData TCPClient::receive(){
+    if(invalid()) return NetData(nullptr, 0);
+    if(asynchronous || nbData > 0)//if not asynchronous but data where stored asynchronously before, return these data
+        // before using blocking receive
+        return pop();
+    else
+        return unsafeReceive();
+}
+
+std::string TCPClient::getIP() const{
+    return sock.IP;
+}
+
+std::string TCPClient::getName() const{
+    return sock.name;
+}
+
+int TCPClient::getPort() const{
+    return sock.port;
+}
+
+int TCPClient::getNbData() const{
+    return nbData;
+}
+
+//**************************************************** TCP Serveur ****************************************************
+
+TCPServer::TCPServer(int port, unsigned int nbConnections, bool useName, bool asynchronous):
+        clients(nbConnections, asynchronous), thread(nullptr), port(port), error(0), nbConnections(nbConnections),
+        nbConnected(0), useName(useName), hosting(true), autoReconnect(false), maxConnectionTry(0){
+#ifdef WIN32
+    error = WSAStartup(MAKEWORD(2,2), &m_WSAData);
+#else
+    error = 0;
+#endif // WIN32
+}
+
+TCPServer::~TCPServer(){
+    clients.clear();
+    closesocket(hsock.sock);
+    if(thread){
+        hosting = false;
+        thread->join();
+        delete thread;
+        thread = nullptr;
+    }
+
+#ifdef WIN32
+    WSACleanup();
+#endif // WIN32
+}
+
+
+bool TCPServer::host(bool waitConnections, bool autoReconnect, unsigned int maxConnectionTry) {
+    if(error) return false;
+
+        hsock.sock = socket(AF_INET,SOCK_STREAM, 0);
+
+    if(hsock.sock == INVALID_SOCKET) return false;
+
+        hsock.sin.sin_addr.s_addr = htonl(INADDR_ANY);
+        hsock.sin.sin_family = AF_INET;
+        hsock.sin.sin_port = htons(port);
+
+    if(bind(hsock.sock, (SOCKADDR*)&hsock.sin, sizeof(hsock.sin)) == SOCKET_ERROR) return false;
+
+    if(listen(hsock.sock, 1) == SOCKET_ERROR) return false;
+
+    this->autoReconnect = autoReconnect;
+    this->maxConnectionTry = maxConnectionTry;
+    if(waitConnections){
+        return acceptHost();
+    }else{
+        thread = new std::thread(waitHost, this);
+    }
+
+    return true;
+}
+bool TCPServer::acceptHost(){
+    int connectionTry = 0;
+    for(int i = 0;(i<nbConnections || autoReconnect) && hosting;i++){
+        if(i == nbConnections) i = 0;//in case of autoReconnect
+        if(clients[i].isConnected()) continue;
+
+        if(!clients[i].accept(this, useName)){
+            connectionTry++;
+            if(connectionTry <= maxConnectionTry)
+                return false;
+            i--;
+            continue;
+        }
+        connectionTry = 0;//connection made so reset connectionTry to 0
+
+        std::string name = clients[i].getName();
+        if(!name.empty()){
+            auto client = clientsByName.find(name);
+            if(client != clientsByName.end()){//if already exist disconnect
+                if(client->second->isConnected() || !autoReconnect){//if !autoReconnect a client can't connect again
+                    clients[i].disconnect(false);
+                    i--;
+                    continue;
+                }else{//else send acceptation message
+                    clients[i].send("accepted");
+                }
+            } else{//else send acceptation message
+                clients[i].send("accepted");
+            }
+            clientsByName[name] = &clients[i];
+        }
+        clientsByIP[clients[i].getIP()] = &clients[i];
+
+        nbConnected++;
+    }
+
+    return true;
+}
+
+void TCPServer::waitHost(TCPServer *tcp){
+    tcp->acceptHost();
+}
+
+TCPClient& TCPServer::operator[](int index){
+    if(invalid(index)) return empty;
+    return clients[index];
+}
+TCPClient& TCPServer::operator[](std::string IP){
+    if(clientsByIP.find(IP) == clientsByIP.end()) return empty;
+    return *clientsByIP[IP];
+}
+TCPClient& TCPServer::operator()(std::string name){
+    if(clientsByName.find(name) == clientsByName.end()) return empty;
+    return *clientsByName[name];
+}
+TCPClient& TCPServer::unavailable(){
+    return empty;
+}
+
+bool TCPServer::invalid(int client){
+    if(client >= 0 && client < clients.size()) return !clients[client].isConnected();
+    return true;
+}
+
+void TCPServer::eraseClient(TCPClient &client){
+    if(client.isConnected()){
+        auto IP = client.getIP();
+        auto name = client.getName();
+        client.disconnect(false);
+        nbConnected--;
+        if(!IP.empty())
+            clientsByIP.erase(IP);
+        if(!name.empty())
+            clientsByName.erase(name);
+    }
+}
+
+std::vector<std::string> TCPServer::IPList(){
+    std::vector<std::string> IPs;
+    for(auto const &elt : clientsByIP)
+        IPs.push_back(elt.first);
+    return IPs;
+}
+std::vector<std::string> TCPServer::namesList(){
+    std::vector<std::string> names;
+    for(auto const &elt : clientsByName)
+        names.push_back(elt.first);
+    return names;
+}
+
+Sock TCPServer::getHostSock()  const{
+    return hsock;
+}
+
+int TCPServer::getNbConnected()  const{
+    return nbConnected;
+}
+
+//**************************************************** UDP ****************************************************
+
+UDP::UDP(std::string IP, int port): IP(IP), port(port), sock(), from({0}), fromaddrsize(sizeof(from)){
+}
+UDP::~UDP(){
+    closesocket(sock.sock);
+}
+bool UDP::init(){
+    sock.sock = socket(PF_INET, SOCK_DGRAM, 0);
+
+    if(sock.sock == INVALID_SOCKET) return false;
+
+    sock.sin = { 0 };
+    sock.recsize = sizeof sock.sin;
+    if(IP == "")
+        sock.sin.sin_addr.s_addr = htonl(INADDR_ANY);
+    else
+        sock.sin.sin_addr.s_addr = inet_addr(IP.c_str());
+    sock.sin.sin_port = htons(port);
+    sock.sin.sin_family = AF_INET;
+
+    if(bind(sock.sock, (SOCKADDR *)&sock.sin, sock.recsize) == SOCKET_ERROR) return false;
+
+    return true;
+}
+
+
+long UDP::send(NetData data){
+    auto packet = data.toPacket();
+    long size = sendto(sock.sock, packet.data, packet.size, 0, (SOCKADDR *)&sock.sin, sock.recsize);
+    free(packet.data);
+    return size;
+}
+NetData UDP::receive(){
+    size_data sizeByte;
+    long size = recvfrom(sock.sock, &sizeByte, sizeof(size_data), 0, &from, &fromaddrsize);
+    if(size == 0 || sizeByte == 0) {
+        return  NetData(nullptr, 0);
+    }//when receiving just check for size == 0
+
+    void* data = malloc(sizeByte);
+    size = recvfrom(sock.sock, data, sizeByte, 0, &from, &fromaddrsize);
+    if(size == 0) {
+        free(data);
+        return NetData(nullptr, 0);
+    }
+
+    return NetData(data, sizeByte, false);//dont copy the data just the address so it will be freed automatically after
+}
+
+long UDP::rawSend(void *data, size_data sizeByte) {
+    return sendto(sock.sock, data, sizeByte, 0, (SOCKADDR *)&sock.sin, sock.recsize);
+}
+
+long UDP::rawReceive(void *data, size_data sizeByte) {
+    return recvfrom(sock.sock, data, sizeByte, 0, &from, &fromaddrsize);
+}
+
+int UDP::getPort(){
+    return port;
+}
+std::string UDP::getIP(){
+    if(IP != "")
+        return IP;
+    else{
+        char host[NI_MAXHOST];
+        if (getnameinfo((sockaddr*)&from, fromaddrsize, host, NI_MAXHOST, NULL, 0, NI_NUMERICHOST) != 0) {
+            return "";
+        } else {
+            return std::string(host);
+        }
+    }
+}
+
+    //************************************ STATIC ************************************
+
+long UDP::rawSendTo(std::string IP, int port, void *data, size_data sizeByte){
+    SOCKET sock = socket(PF_INET, SOCK_DGRAM, 0);
+
+    if(sock == INVALID_SOCKET) return false;
+
+    SOCKADDR_IN to = { 0 };
+    socklen_t tosize = sizeof to;
+    to.sin_addr.s_addr = inet_addr(IP.c_str());
+    to.sin_port = htons(port);
+    to.sin_family = AF_INET;
+
+    long size = sendto(sock, data, sizeByte, 0, (SOCKADDR *)&to, tosize);
+    closesocket(sock);
+
+    return  size;
+}
+
+long UDP::sendTo(std::string IP, int port, NetData data){
+    SOCKET sock = socket(PF_INET, SOCK_DGRAM, 0);
+
+    if(sock == INVALID_SOCKET) return false;
+
+    SOCKADDR_IN to = { 0 };
+    socklen_t tosize = sizeof to;
+    to.sin_addr.s_addr = inet_addr(IP.c_str());
+    to.sin_port = htons(port);
+    to.sin_family = AF_INET;
+
+    auto packet = data.toPacket();
+    long size = sendto(sock, packet.data, packet.size, 0, (SOCKADDR *)&to, tosize);
+    free(packet.data);
+    closesocket(sock);
+
+    return  size;
+}
+
+long UDP::rawReceiveFrom(std::string IP, int port, void *data, size_data sizeByte){
+    SOCKET sock = socket(PF_INET, SOCK_DGRAM, 0);
+
+    if(sock == INVALID_SOCKET) return false;
+
+    SOCKADDR_IN to = { 0 };
+    socklen_t tosize = sizeof to;
+    if(IP.empty())
+        to.sin_addr.s_addr = htonl(INADDR_ANY);
+    else
+        to.sin_addr.s_addr = inet_addr(IP.c_str());
+    to.sin_port = htons(port);
+    to.sin_family = AF_INET;
+
+    if(bind(sock, (SOCKADDR *)&to, tosize) == SOCKET_ERROR) return false;
+
+    sockaddr from = { 0 };
+    socklen_t addrsize = sizeof from;
+
+    long size = recvfrom(sock, data, sizeByte, 0, &from, &addrsize);
+    closesocket(sock);
+
+    return  size;
+}
+
+long UDP::rawReceiveFrom(int port, void *data, size_data sizeByte){
+    return rawReceiveFrom("", port, data, sizeByte);
+}//TODO add possibility to know from wich ip it comes from
+
+NetData UDP::receiveFrom(std::string IP, int port){
+    SOCKET sock = socket(PF_INET, SOCK_DGRAM, 0);
+
+    if(sock == INVALID_SOCKET) return NetData(nullptr, 0);
+
+    SOCKADDR_IN to = { 0 };
+    socklen_t tosize = sizeof to;
+    if(IP.empty())
+        to.sin_addr.s_addr = htonl(INADDR_ANY);
+    else
+        to.sin_addr.s_addr = inet_addr(IP.c_str());
+    to.sin_port = htons(port);
+    to.sin_family = AF_INET;
+
+    if(bind(sock, (SOCKADDR *)&to, tosize) == SOCKET_ERROR) return NetData(nullptr, 0);
+
+    sockaddr from = { 0 };
+    socklen_t addrsize = sizeof from;
+
+    size_data sizeByte;
+    long size = recvfrom(sock, &sizeByte, sizeof(size_data), 0, &from, &addrsize);
+    if(size == 0 || sizeByte == 0) {
+        return  NetData(nullptr, 0);
+    }//when receiving just check for size == 0
+
+    void* data = malloc(sizeByte);
+    size = recvfrom(sock, data, sizeByte, 0, &from, &addrsize);
+    if(size == 0) {
+        free(data);
+        return NetData(nullptr, 0);
+    }
+
+    return NetData(data, sizeByte, false);//dont copy the data just the address so it will be freed automatically after
+}
+
+NetData UDP::receiveFrom(int port){
+    return receiveFrom("", port);//dont copy the data just the address so it will be freed automatically after
+}

netChat/xayon/Network.h

@@ -0,0 +1,236 @@
+//
+// Created by Nathan Touroux on 29/06/2017.
+//
+
+#ifndef NETWORK_NETWORK_H
+#define NETWORK_NETWORK_H
+
+#ifdef WIN32
+    #include <winsock2.h>
+    typedef int socklen_t;
+    #define errno WSAGetLastError()
+#else
+    #include <netdb.h>
+    #include <sys/types.h>
+    #include <sys/socket.h>
+    #include <netinet/in.h>
+    #include <arpa/inet.h>
+    #include <unistd.h>
+
+    #define INVALID_SOCKET -1
+    #define SOCKET_ERROR -1
+    #define closesocket(s) close (s)
+
+    typedef int SOCKET;
+    typedef struct sockaddr_in SOCKADDR_IN;
+    typedef struct sockaddr SOCKADDR;
+#endif // WIN32
+
+#include <iostream>
+#include <vector>
+#include <unordered_map>
+#include <thread>
+#include <atomic>
+#include <mutex>
+#include <cstdlib>
+#include <string.h>
+
+#define size_data unsigned long
+
+struct Sock
+{
+    SOCKADDR_IN sin;
+    SOCKET sock = SOCKET_ERROR;
+    socklen_t recsize = sizeof(sin);
+    std::string IP = "";
+    std::string name = "";
+    int port = 0;
+};
+
+//*********************************************** TCP DATA ***********************************************
+
+struct NetPacket{//should be created by NetData, contains length next to the data in "data", "size" is sizeof(size_data)+length of data
+    void* data;
+    size_data size;
+};
+
+class NetData{
+private:
+    void* data;
+    size_data size;
+
+    void copy(void* data, size_data size);
+public:
+
+    template<typename T, typename = typename std::enable_if<std::is_arithmetic<T>::value>::type> NetData(T data);
+    NetData(std::string str);
+    NetData(const char *str);
+    NetData(void *data, size_data size, bool copyData = true);
+    NetData(const NetData &copy);
+    NetData& operator=(const NetData &copy);
+    ~NetData();
+
+    bool valid();
+    template<typename T, typename = typename std::enable_if<std::is_arithmetic<T>::value>::type> operator T();
+    operator std::string();
+    void* getData();
+
+    size_data getSize();
+    NetPacket toPacket();//return a packet (the data inside should be freed)
+};
+
+template<typename T, typename> NetData::NetData(T data): data(nullptr), size(sizeof(T)) {
+    copy(&data, size);
+}
+
+template<typename T, typename> NetData::operator T() {
+    if(!valid()) return T();
+    auto tmp = data;
+    copy(data, size);
+    return *static_cast<T*>(tmp);
+}
+
+//*********************************************** TCP CLIENT ***********************************************
+class TCPServer;
+
+class TCPClient{
+private:
+    Sock sock;
+    TCPServer *server;
+
+    struct Data{
+        void* data;
+        size_data size;
+        Data* next;
+    };
+    Data *first, *last;
+    int nbData;
+
+    std::thread *asyncThread;
+    std::atomic_bool asynchronous;
+    std::atomic_bool connected;
+    std::mutex mutex;
+
+    bool invalid();
+
+    long unsafeSend(NetData data);
+    NetData unsafeReceive();
+
+    static void asyncReceive(TCPClient *client);
+    void push(void* data, size_data size);
+    NetData pop();
+
+public:
+    TCPClient(bool asynchronous = true);
+    TCPClient(const TCPClient &client);//just copy the asynchronous value
+    ~TCPClient();
+    bool accept(TCPServer *server, bool receiveName = false);//if receive name is true, the server must send a string
+    // (message doesn't import) to confirm that the name is accepted or else disconnect the client
+    bool connect(std::string IP, int port, std::string name = "");//if a client is already connected with this name the
+    // connection will fail
+    void disconnect(bool removeFromServer = true);
+    bool isConnected();
+
+    void enableAsynchronous();
+    //void disableAsynchronous();
+    bool asynchronousEnabled();
+
+    //WARNING: can't send/receive raw packet when asynchronous
+    long rawSend(void *data, size_data sizeByte);
+    long rawReceive(void *data, size_data sizeByte);
+
+    long send(NetData data);
+    NetData receive();//receive a packet with size next to the data so knowing the size isn't important
+
+    std::string getIP() const;
+    std::string getName() const;
+    int getPort() const;
+    int getNbData() const;
+};
+
+//*********************************************** TCP SERVEUR ***********************************************
+
+class TCPServer{
+private:
+#ifdef WIN32
+    WSADATA m_WSAData;
+#endif
+
+    Sock hsock;
+    std::vector<TCPClient> clients;
+    std::unordered_map<std::string, TCPClient*> clientsByIP;
+    std::unordered_map<std::string, TCPClient*> clientsByName;
+
+    std::thread *thread;
+
+    int port;
+    int error;
+    std::atomic<int> nbConnections;
+    std::atomic<int> nbConnected;
+    bool useName;
+    bool hosting;
+    bool autoReconnect;
+    unsigned int maxConnectionTry;
+
+    static void waitHost(TCPServer *data);
+    bool invalid(int client);//return true if there is a problem, false if everything is fine
+
+    TCPClient empty;
+public:
+    explicit TCPServer(int port, unsigned int nbConnections, bool useName = false, bool asynchronous = true);
+    ~TCPServer();
+
+    bool host(bool waitConnections = false, bool autoReconnect = true, unsigned int maxConnectionTry = -1);
+    bool acceptHost();//must not be called directly, it is used by host() method
+
+    TCPClient& operator[](int index);
+    TCPClient& operator[](std::string IP);
+    TCPClient& operator()(std::string name);
+    TCPClient& unavailable();//use this to compare against a client (ex: server[2] != server.unavailable())
+
+    void eraseClient(TCPClient &client);
+
+    std::vector<std::string> IPList();
+    std::vector<std::string> namesList();
+    Sock getHostSock() const;
+
+    int getNbConnected() const;
+};
+
+//*********************************************** UDP ***********************************************
+
+class UDP{
+private:
+    std::string IP;
+    int port;
+
+    Sock sock;
+    sockaddr from;
+    socklen_t fromaddrsize;
+
+public:
+    UDP(std::string IP, int port);// use "" for IP to receive from any IP
+    ~UDP();
+
+    bool init();
+
+    long rawSend(void *data, size_data sizeByte);
+    long rawReceive(void *data, size_data sizeByte);
+
+    long send(NetData data);
+    NetData receive();//receive a packet with size next to the data so knowing the size isn't important
+
+    int getPort();
+    std::string getIP();
+
+    //************************************ STATIC ************************************
+
+    static long rawSendTo(std::string IP, int port, void *data, size_data sizeByte);
+    static long sendTo(std::string IP, int port, NetData data);
+    static long rawReceiveFrom(std::string IP, int port, void *data, size_data sizeByte);
+    static long rawReceiveFrom(int port, void *data, size_data sizeByte);//TODO add possibility to know from wich ip it comes from
+    static NetData receiveFrom(std::string IP, int port);
+    static NetData receiveFrom(int port);
+};
+
+#endif //NETWORK_NETWORK_H

netChat/xayon/main.cpp

@@ -0,0 +1,72 @@
+#include <iostream>
+#include <cstdlib>
+#include "Network.h"
+
+int kbhit()
+{
+    struct timeval tv;
+    fd_set fds;
+    tv.tv_sec = 0;
+    tv.tv_usec = 0;
+    FD_ZERO(&fds);
+    FD_SET(STDIN_FILENO, &fds); //STDIN_FILENO is 0
+    select(STDIN_FILENO+1, &fds, NULL, NULL, &tv);
+    return FD_ISSET(STDIN_FILENO, &fds);
+}
+
+int main(int argc, char **argv) {
+
+    //UDP
+    /*int l = 10;
+    char c[l];
+    UDP::sendTo("127.0.0.1", 9995, "quit");
+    bool b = UDP::receiveFrom(9999, c, 10);
+    std::cout << std::boolalpha << b << "   " << c << std::endl;*/
+
+    srand(time(0));
+
+    if(argc > 1){
+        TCPClient socket;
+        std::string name = std::string(argv[1]), msg;
+        bool connected = socket.connect("127.0.0.1", 9995, name);
+        std::cout << "connection established: " << std::boolalpha << connected << std::endl;
+        while(socket.isConnected()){
+            if(kbhit()){
+                std::getline(std::cin, msg);
+                socket.send({msg});
+            }
+            msg = (std::string)socket.receive();
+            if(msg != "") std::cout << "serveur: " << msg << std::endl;
+        }
+    }else{
+        int n = 2;
+        TCPServer socket(9995, n, true);
+        bool hosting = socket.host();
+        std::cout << "host: " << std::boolalpha << hosting << std::endl;
+
+        if(hosting){
+
+            //while(socket.getNbConnected() < 2) std::this_thread::sleep_for(std::chrono::milliseconds(1));
+            /*while(true){
+                std::string msg = socket.receive(), name = socket.getName();
+                if(msg != "" || name != "") std::cout << "from:" << name << "   (" << msg.size() << "): " << msg << std::endl;
+            }*/
+            bool stop = false;
+            std::string msg;
+            do{
+                std::this_thread::sleep_for(std::chrono::milliseconds(1));
+                if(kbhit()){
+                    std::getline(std::cin, msg);
+                    for(int i = 0;i<socket.getNbConnected();i++) socket[i].send({msg});
+                }
+                for(auto name : socket.namesList()){
+                    msg = (std::string)socket(name).receive();
+                    if(msg != "") std::cout << name << ": " << msg << std::endl;
+                    if(msg == "stop") stop = true;
+                }
+            }while(!stop);
+        }
+    }
+
+    return 0;
+}

objectOperatorTest/main.cpp

@@ -0,0 +1,122 @@
+#include <iostream>
+#include <map>
+
+#define NB_MODELS 9
+enum WeaponType { GUN, SNIPER, SHOTGUN, USIANE, SCATTER, BAROUDEUR, SULFATEUSE, TRIPHASEUR, BOMBER };
+
+class Craft
+{
+public:
+    Craft();
+    Craft( WeaponType a, WeaponType b );
+    ~Craft();
+
+    void debugCout() const;
+
+    bool operator<( const Craft& a) const;
+
+private:
+    WeaponType m_a;
+    WeaponType m_b;
+};
+
+void craftTabler( std::map< Craft, WeaponType > *tabCraft )
+{
+    (*tabCraft)[ Craft( SHOTGUN, BAROUDEUR ) ] = BOMBER;
+
+    (*tabCraft)[ Craft( SNIPER, SCATTER ) ] = TRIPHASEUR;
+    (*tabCraft)[ Craft( SNIPER, SHOTGUN ) ] = BAROUDEUR;
+
+    (*tabCraft)[ Craft( GUN, USIANE ) ] = SULFATEUSE;
+    (*tabCraft)[ Craft( GUN, SHOTGUN ) ] = USIANE;
+    (*tabCraft)[ Craft( GUN, SNIPER ) ] = SCATTER;
+}
+
+int main() /// MAIN
+{
+    std::cout << "Surcharge d'opérateurs !" << std::endl;
+    std::cout << " GUN:0 SNIPER:1 SHOTGUN:2 USIANE:3 SCATTER:4 BAROUDEUR:5 SULFATEUSE:6 TRIPHASEUR:7 BOMBER:8" << std::endl;
+
+    std::map< Craft, WeaponType > tabCraft;
+    std::map< Craft, WeaponType >::iterator it;
+    craftTabler( &tabCraft );
+    Craft *prod(0x0);
+
+    WeaponType a, b;
+    int nbPos(0);
+
+    for ( unsigned short i(0); i<NB_MODELS; i++ )
+        for ( unsigned short j(i); j<NB_MODELS; j++ )
+        {
+            a = (WeaponType)j;
+            b = (WeaponType)i;
+            prod = new Craft(a,b);
+
+            it = tabCraft.find( *prod );
+
+            prod->debugCout();
+            if ( it == tabCraft.end() ) std::cout << "Combinaison inexistante.";
+            else {
+                std::cout << "Arme obtenue : " << tabCraft[ *prod ];
+                nbPos++;
+            }
+            std::cout << std::endl << std::endl << std::endl;
+
+            delete prod;
+            prod = 0x0;
+        }
+    std::cout << nbPos << " possibilités de craft." << std::endl;
+    it = tabCraft.begin();
+    while ( it != tabCraft.end() )
+    {
+        it->first.debugCout();
+        std::cout << "Donne " << it->second << std::endl << std::endl << std::endl;
+        it++;
+    }
+
+    return 0;
+} /// MAIN
+
+
+Craft::Craft()
+:m_a(GUN), m_b(SHOTGUN)
+{
+
+}
+
+Craft::Craft( WeaponType a, WeaponType b )
+{
+    if ( a < b ) {
+        m_a = a;
+        m_b = b;
+    }
+    else {
+        m_a = b;
+        m_b = a;
+    }
+}
+
+Craft::~Craft()
+{
+
+}
+
+void Craft::debugCout() const
+{
+    std::cout <<"Arme A : "<< m_a << std::endl;
+    std::cout <<"Arme B : "<< m_b << std::endl << std::endl;
+}
+
+bool Craft::operator<( const Craft& a ) const
+{
+    if ( m_a < a.m_a )
+        return true;
+    else
+        return m_b < a.m_b;
+}
+
+/*bool Craft::operator==( const Craft& a) const
+{
+    return m_a == a.m_a && m_b == a.m_b;
+}*/
+

serialTest/PointSystem.cpp

@@ -0,0 +1,42 @@
+//
+// Created by jovian on 15/01/18.
+//
+
+#include <iostream>
+#include "PointSystem.h"
+
+PointSystem::PointSystem() : nb(0) {}
+
+void PointSystem::addPoint(int p) {
+    if (nb >= MAX_SIZE)
+        return;
+
+    points[nb] = p;
+    nb ++;
+}
+
+void PointSystem::display() {
+    std::cout << "Welcome in my system !!!" << std::endl;
+    std::cout << nb << " points." << std::endl;
+
+    for (int i(0); i < nb; i++)
+        std::cout << i << " : " << points[i] << std::endl;
+}
+
+std::ostream &operator<<(std::ostream &os, const PointSystem &pointSystem) {
+    os << pointSystem.nb << std::endl;
+
+    for (int i(0); i < pointSystem.nb; i++)
+        os << pointSystem.points[i] << std::endl;
+
+    return os;
+}
+
+std::istream &operator>>(std::istream &is, PointSystem &pointSystem) {
+    is >> pointSystem.nb;
+
+    for (int i(0); i < pointSystem.nb; i++)
+        is >> pointSystem.points[i];
+
+    return is;
+}

serialTest/PointSystem.h

@@ -0,0 +1,35 @@
+//
+// Created by jovian on 15/01/18.
+//
+
+#ifndef SERIALIZATION_POINTSYSTEM_H
+#define SERIALIZATION_POINTSYSTEM_H
+
+
+#include <ostream>
+#include "Serializable.h"
+
+#define MAX_SIZE 10
+
+class PointSystem : public Serializable {
+    // Methods
+public:
+    PointSystem();
+
+    void addPoint(int p);
+
+    void display();
+
+    friend std::ostream &operator<<(std::ostream &os, const PointSystem &pointSystem);
+
+    friend std::istream &operator>>(std::istream &is, PointSystem &pointSystem);
+
+
+    // Attributes
+private:
+    int points[MAX_SIZE];
+    int nb;
+};
+
+
+#endif //SERIALIZATION_POINTSYSTEM_H

serialTest/Serializable.cpp

@@ -0,0 +1,6 @@
+//
+// Created by jovian on 15/01/18.
+//
+
+#include "Serializable.h"
+

serialTest/Serializable.h

@@ -0,0 +1,17 @@
+//
+// Created by jovian on 15/01/18.
+//
+
+#ifndef SERIALIZATION_SERIALIZABLE_H
+#define SERIALIZATION_SERIALIZABLE_H
+
+
+#include <ostream>
+
+class Serializable {
+public:
+
+};
+
+
+#endif //SERIALIZATION_SERIALIZABLE_H

serialTest/main.cpp

@@ -0,0 +1,38 @@
+#include <iostream>
+#include <fstream>
+#include "PointSystem.h"
+
+using namespace std;
+
+int main() {
+    // Start
+    cout << "Serial example." << endl;
+
+    // Create instance
+    PointSystem system1;
+
+    system1.addPoint(42);
+    system1.addPoint(420);
+    system1.addPoint(12);
+
+    system1.display();
+
+    // Stream workshop output
+    ofstream sOut("data.txt");
+
+    sOut << system1;
+
+    sOut.close();
+
+    // Input
+    ifstream sIn("data.txt");
+
+    sIn >> system1;
+
+    sIn.close();
+
+    // Test
+    system1.display();
+
+    return 0;
+}

threadTest/Thread.cpp

@@ -0,0 +1,98 @@
+#include "Thread.h"
+
+Thread::Thread(): m_isstop(true), m_autoDelete(false)
+{
+
+}
+Thread::~Thread()
+{
+    if(!m_isstop)
+    {
+        SDL_KillThread(m_t);
+        m_t = 0;
+    }
+    for(std::map<std::string, SDL_mutex*>::iterator mutex = m_mutexs.begin();mutex != m_mutexs.end();mutex++)
+        SDL_DestroyMutex(mutex->second);
+}
+bool Thread::start()
+{
+    if(m_isstop)
+    {
+        m_t = SDL_CreateThread(Thread::ThreadInit, this);
+        if(m_t != 0)
+        {
+            m_isstop = false;
+            return true;
+        }
+    }
+    return false;
+}
+void Thread::stop()
+{
+    if(!m_isstop)
+    {
+        SDL_KillThread(m_t);
+        m_t = 0;
+    }
+    m_isstop = true;
+}
+void Thread::join()
+{
+    SDL_WaitThread(m_t, 0);
+    m_isstop = true;
+}
+void Thread::setAutoDelete(bool autoDelete)
+{
+    m_autoDelete = autoDelete;
+}
+
+int Thread::ThreadInit(void* param)
+{
+    Thread *t(reinterpret_cast<Thread*>(param));
+    t->run();
+    if(t->m_autoDelete)
+        delete t;
+    return 0;
+}
+
+bool Thread::threadRunning()
+{
+    return m_isstop;
+}
+
+bool Thread::createLockMutex(std::string name)
+{
+    std::map<std::string, SDL_mutex*>::iterator mutex = m_mutexs.find(name);
+
+    if(m_mutexs.find(name) == m_mutexs.end())
+    {
+        m_mutexs[name] = SDL_CreateMutex();
+        mutex = m_mutexs.find(name);
+    }
+    if(SDL_mutexP(mutex->second)==-1)
+        return false;
+
+    return true;
+}
+bool Thread::lockMutex(std::string name)
+{
+    std::map<std::string, SDL_mutex*>::iterator mutex = m_mutexs.find(name);
+
+    if(m_mutexs.find(name) == m_mutexs.end())
+        return false;
+    if(SDL_mutexP(mutex->second)==-1)
+        return false;
+
+    return true;
+}
+bool Thread::unlockMutex(std::string name)
+{
+    std::map<std::string, SDL_mutex*>::iterator mutex = m_mutexs.find(name);
+
+    if(m_mutexs.find(name) == m_mutexs.end())
+        return false;
+    if(SDL_mutexV(mutex->second)==-1)
+        return false;
+
+    return true;
+}

threadTest/Thread.h

@@ -0,0 +1,36 @@
+#ifndef THREAD_H
+#define THREAD_H
+
+#include <iostream>
+#include <map>
+#include <SDL_thread.h>
+
+class Thread
+{
+public:
+    Thread();
+    virtual ~Thread();// Arrête automatiquement le thread meme s'il est en cours.
+    bool start();// Démarre la fonction run() dans un thread.
+    void stop();// Arrête le thread.
+    void join();// Rattache le thread au processus principal qui est bloqué et attend que le run() se termine.
+    void setAutoDelete(bool autoDelete);// Permet de declarer dynamiquement une classe qui hérite de Thread sans garder le pointeur, il sera delete automatiquement à la fin du thread si l'argument est true.
+
+    bool threadRunning();
+
+    bool lockMutex(std::string name);
+    bool unlockMutex(std::string name);
+
+    virtual void run() = 0;// Tout devra se passer ici
+
+protected:
+    bool createLockMutex(std::string name);
+
+private:
+    static int ThreadInit(void* param);
+    bool m_isstop;
+    SDL_Thread *m_t;
+    bool m_autoDelete;
+    std::map<std::string, SDL_mutex*> m_mutexs;
+};
+
+#endif // THREAD_H

threadTest/main.cpp

@@ -0,0 +1,74 @@
+#include <iostream>
+#include <vector>
+#include "Thread.h"
+
+using namespace std;
+
+class Multiplicateur : public Thread
+{
+public:
+    Multiplicateur(int x, vector<int> *binaire);
+    void run();
+    void giveNumber(int nb);
+    void inventaire();
+
+private:
+    const int m_x;
+    vector<int> *m_binaire;
+};
+
+Multiplicateur::Multiplicateur(int x, vector<int> *binaire) : m_x(x), m_binaire(binaire)
+{
+    createLockMutex("nb");
+    unlockMutex("nb");
+}
+
+void Multiplicateur::run()
+{
+
+    while (1==1) giveNumber(m_x);
+}
+
+void Multiplicateur::giveNumber(int nb)
+{
+    if ( lockMutex("nb") )
+    {
+        m_binaire->push_back(nb);
+        unlockMutex("nb");
+    }
+}
+
+void inventaire(vector<int> *binaire)
+{
+    int nb[3];
+    nb[0] = nb[1] = nb[2] = 0;
+    while (!binaire->empty())
+    {
+        nb[(*binaire)[binaire->size()-1]]++;
+        binaire->pop_back();
+    }
+
+    cout << "Il y a eu "<<nb[0]<<"x0 et "<<nb[1]<<"x1 et "<<nb[2]<<"x2."<<endl;
+}
+
+int main()
+{
+    cout << "Test de la classe Thread développée par Nathan Touroux." << endl;
+
+    vector<int>* tableau(0);
+    tableau = new vector<int>(0);
+
+    Multiplicateur process1(1, tableau), process2(2, tableau);
+    process1.start();
+    process2.start();
+
+    for (int i(0); i<10000; i++) process1.giveNumber(0);
+
+    process1.stop();
+    process2.stop();
+
+    inventaire(tableau);
+
+    delete tableau;
+    return 0;
+}

treeLab/README.md

@@ -0,0 +1 @@
+Lab number 4 from ECN school

treeLab/TP4.cpp

@@ -0,0 +1,71 @@
+#include <iostream>
+#include <ctime>
+#include <cstdlib>
+#include "utilitaires.h"
+#include "repertoire.h"
+
+using namespace std;
+
+int main()
+{
+    // Start
+    cout << "TP4 starts." << endl;
+
+    // Seed random
+    srand( time(0) );
+
+    // Tests
+    vectNom prenoms;
+    int nbPrenoms;
+
+    vectNom noms;
+    int nbNoms;
+
+    // Re génération
+    /*nbPrenoms = initTabNomPrenom(prenoms, "Prenoms_TP4.txt");
+    nbNoms = initTabNomPrenom(noms, "Noms_TP4.txt");
+
+    genererRepertoire(repertoire, noms, prenoms, nbNoms, nbPrenoms);*/
+
+    // Tableau
+    vectPersonne repertoire;
+    int nb;
+
+    lectureRepertoireTT(repertoire, nb);
+
+    /*afficherTT(repertoire, nb);*/
+
+    // Listes
+    /*ElementListe* theListe = nullptr;
+
+    Personne p;
+    p.prenom = "Jean";
+    p.num = "42";
+
+    afficherLT(theListe);
+    cout << endl << "------" << endl << endl;
+
+    p.nom = "Zambra";
+    theListe = ajouterLT(theListe, p);
+
+    afficherLT(theListe);
+    cout << endl << "------" << endl << endl;
+
+    p.nom = "Djerroud";
+    theListe = ajouterLT(theListe, p);
+
+    afficherLT(theListe);
+    cout << endl << "------" << endl << endl;
+
+    p.nom = "Hersemeule";
+    theListe = ajouterLT(theListe, p);
+
+    afficherLT(theListe);
+    cout << endl << "------" << endl << endl;
+
+    theListe = lectureRepertoireLT();*/
+
+    // End
+    return 0;
+}
+

treeLab/main.cpp

@@ -0,0 +1,71 @@
+#include <iostream>
+#include <ctime>
+#include <cstdlib>
+#include "utilitaires.h"
+#include "repertoire.h"
+
+using namespace std;
+
+int main()
+{
+    // Start
+    cout << "TP4 starts." << endl;
+
+    // Seed random
+    srand( time(0) );
+
+    // Tests
+    vectNom prenoms;
+    int nbPrenoms;
+
+    vectNom noms;
+    int nbNoms;
+
+    // Re génération
+    /*nbPrenoms = initTabNomPrenom(prenoms, "Prenoms_TP4.txt");
+    nbNoms = initTabNomPrenom(noms, "Noms_TP4.txt");
+
+    genererRepertoire(repertoire, noms, prenoms, nbNoms, nbPrenoms);*/
+
+    // Tableau
+    vectPersonne repertoire;
+    int nb;
+
+    lectureRepertoireTT(repertoire, nb);
+
+    /*afficherTT(repertoire, nb);*/
+
+    // Listes
+    /*ElementListe* theListe = nullptr;
+
+    Personne p;
+    p.prenom = "Jean";
+    p.num = "42";
+
+    afficherLT(theListe);
+    cout << endl << "------" << endl << endl;
+
+    p.nom = "Zambra";
+    theListe = ajouterLT(theListe, p);
+
+    afficherLT(theListe);
+    cout << endl << "------" << endl << endl;
+
+    p.nom = "Djerroud";
+    theListe = ajouterLT(theListe, p);
+
+    afficherLT(theListe);
+    cout << endl << "------" << endl << endl;
+
+    p.nom = "Hersemeule";
+    theListe = ajouterLT(theListe, p);
+
+    afficherLT(theListe);
+    cout << endl << "------" << endl << endl;
+
+    theListe = lectureRepertoireLT();*/
+
+    // End
+    return 0;
+}
+

treeLab/repertoire.cpp

@@ -0,0 +1,251 @@
+#include "repertoire.h"
+#include <iostream>
+#include "utilitaires.h"
+#include <fstream>
+
+using namespace std;
+
+/// Tableaux triés
+void afficherTT(vectPersonne tab, int nb)
+{
+    for (int k = 0; k < nb; ++k)
+    {
+        cout << tab[k].nom << ' ' << tab[k].prenom << ' ' << tab[k].num << endl;
+    }
+}
+
+
+void ajouterTT(vectPersonne tab, int& nb, Personne p)
+{
+    int k = 0;
+
+    // On cherche la bonne place
+    while (comparerPersonne(tab[k], p) && k < nb)
+    {
+        ++k;
+    }
+
+    // Test personne déjà présente
+    if (egalitePersonne(tab[k], p) && k < nb)
+    {
+        return;
+    }
+
+    // Décalage des éléments suivants
+    for (int i = nb - 1; i >= k; --i)
+    {
+        tab[i+1] = tab[i];
+    }
+
+    // Remplissage de la bonne case
+    tab[k] = p;
+
+    // Incrémentation taille
+    nb = nb + 1;
+}
+
+bool rechercherTT(vectPersonne tab, int nb, Personne p)
+{
+    int i = 0;
+
+    while (!egalitePersonne(tab[i], p) && i < nb)
+    {
+        ++i;
+    }
+
+    return egalitePersonne(tab[i], p);
+}
+
+void supprimerTT(vectPersonne tab, int& nb, Personne p)
+{
+    int i = 0;
+    while (!egalitePersonne(tab[i], p) && i < nb)
+    {
+        ++i;
+    }
+
+    if (i < nb)
+    {
+        for (int k = i; k < nb; ++k)
+        {
+            tab[k] = tab [k+1];
+        }
+
+        --nb;
+    }
+}
+
+void lectureRepertoireTT(vectPersonne tab, int& nb)
+{
+    nb = 0;
+    Personne g;
+    ifstream monFlux("repertoire.txt");
+
+    for (int k = 0; k < 10000; ++k)
+    {
+        monFlux >> g.nom >> g.prenom >> g.num;
+        ajouterTT(tab, nb, g);
+    }
+
+}
+
+/// Listes triées
+void afficherLT(ElementListe* maListe)
+{
+    // Cas de base
+    if (maListe == nullptr)
+    {
+        return;
+    }
+
+    // Affichage
+    cout << maListe->valeur.nom << ' ' << maListe->valeur.prenom << ' ' << maListe->valeur.num << endl;
+
+    // Appel récursif
+    afficherLT(maListe->suivant);
+}
+///
+
+ElementListe* ajouterLT(ElementListe* maListe, Personne p)
+{
+    // Cas liste vide DONC insertion
+    if (maListe == nullptr)
+    {
+        ElementListe* rep = new ElementListe;
+
+        rep->valeur = p;
+        rep->precedent = nullptr;
+        rep->suivant = nullptr;
+
+        return rep;
+    }
+
+    // Cas d'égalité
+    if (egalitePersonne(maListe->valeur, p))
+    {
+        return maListe;
+    }
+
+    // Cas bout de liste et besoin d'ajouter après DONC insertion
+    if (maListe->suivant == nullptr && comparerPersonne(maListe->valeur, p))
+    {
+        ElementListe* nouv = new ElementListe;
+
+        nouv->valeur = p;
+        nouv->precedent = maListe;
+        nouv->suivant = nullptr;
+
+        maListe->suivant = nouv;
+
+        return maListe;
+    }
+
+    // Cas bout de liste et besoin d'ajouter avant DONC insertion
+    if (comparerPersonne(p, maListe->valeur)/*maListe->suivant == nullptr*/) // On a forcément maListe->valeur > p
+    {
+        ElementListe* nouv = new ElementListe;
+
+        nouv->valeur = p;
+        nouv->precedent = nullptr;
+        nouv->suivant = maListe;
+
+        maListe->precedent = nouv;
+
+        return nouv;
+    }
+
+    // Cas actuel inférieur et suivant supérieur DONC insertion
+    if (comparerPersonne(maListe->valeur, p) && comparerPersonne(p, maListe->suivant->valeur))
+    {
+        ElementListe* nouv = new ElementListe;
+
+        nouv->valeur = p;
+        nouv->precedent = maListe;
+        nouv->suivant = maListe->suivant;
+
+        maListe->suivant = nouv;
+        nouv->suivant->precedent = nouv;
+
+        return maListe;
+    }
+
+    // Cas actuel inférieur et suivant inférieur DONC appel récursif
+    ElementListe* rep = maListe;
+    rep->suivant = ajouterLT(maListe->suivant, p);
+
+    return rep;
+}
+
+bool rechercherLT(ElementListe* maListe, Personne p)
+{
+    // Cas où la liste est vide
+    if (maListe == nullptr)
+    {
+        return false;
+    }
+    // Cas actuel égal donc recherche aboutit
+    else if (egalitePersonne(maListe->valeur, p))
+    {
+        return true;
+    }
+    // Cas actuel différent DONC appel récursif
+    else
+    {
+        rechercherLT(maListe->suivant);
+    }
+}
+
+ElementListe* supprimerLT(ElementListe* maListe, Personne p)
+{
+	// Cas où la liste est vide
+    if (maListe == nullptr)
+    {
+        return nullptr;
+    }
+    // Cas actuel est celui qu'on veut supprimer
+    else if (egalitePersonne(maListe->valeur, p))
+    {
+		// Cas actuel n'est pas le premier de la liste
+        if (maListe->precedent != nullptr)
+            maListe->precedent->suivant = maListe->suivant;
+            
+		// Cas actuel n'est pas le dernier de la liste
+        if (maListe->suivant != nullptr)
+            maListe->suivant->precedent = maListe->precedent;
+
+        return maListe->suivant;
+    }
+    // Cas actuel différent DONC appel récursif
+    else
+    {
+        supprimerLT(maListe->suivant);
+    }
+}
+
+ElementListe* lectureRepertoireLT(ifstream* flux, int iter)
+{
+    // En cas de démarrage
+    if (flux == nullptr)
+    {
+        flux = new ifstream("repertoire.txt");
+    }
+
+    // Cas de base
+    if (iter >= 10000)
+        return nullptr;
+
+    // Récursivité
+    ElementListe* rep;
+    rep->precedent = nullptr;
+    (*flux) >> rep->valeur.nom >> rep->valeur.prenom >> rep->valeur.num;
+    rep->suivant = lectureRepertoireLT(flux, iter++);
+
+    // Raccrochage
+    if (rep->suivant != nullptr)
+    {
+        rep->suivant->precedent = rep;
+    }
+
+    // Fin
+    return rep;
+}

treeLab/repertoire.h

@@ -0,0 +1,50 @@
+#ifndef REPERTOIRE_H_INCLUDED
+#define REPERTOIRE_H_INCLUDED
+
+#include "type_def.h"
+#include <fstream>
+
+/// Tableau trié TT
+// Affichage
+void afficherTT(vectPersonne tab, int nb = 10000);
+
+// Ajouter
+void ajouterTT(vectPersonne tab, int& nb, Personne p);
+
+// Rechercher
+bool rechercherTT(vectPersonne tab, int nb, Personne p);
+
+// Supprimer
+void supprimerTT(vectPersonne tab, int& nb, Personne p);
+
+// Lecture répertoire
+void lectureRepertoireTT(vectPersonne tab, int& nb);
+
+/// Liste triée LT
+// Affichage
+void afficherLT(ElementListe* maListe);
+
+// Ajouter
+ElementListe* ajouterLT(ElementListe* maListe, Personne p);
+
+// Rechercher
+bool rechercherLT(ElementListe* maListe, Personne p);
+
+// Supprimer
+ElementListe* supprimerLT(ElementListe* maListe, Personne p);
+
+// Lecture répertoire
+ElementListe* lectureRepertoireLT(std::ifstream* flux = nullptr, int iter = 0);
+
+/// Arbre binaire de recherche ABR
+// Affichage
+
+// Ajouter
+
+// Rechercher
+
+// Supprimer
+
+// Lecture répertoire
+
+#endif // REPERTOIRE_H_INCLUDED

treeLab/type_def.h

@@ -0,0 +1,33 @@
+#ifndef TYPE_DEF_H_INCLUDED
+#define TYPE_DEF_H_INCLUDED
+
+#include <string>
+
+struct Personne
+{
+    std::string nom;
+    std::string prenom;
+    std::string num;
+};
+
+typedef Personne vectPersonne[10000];
+
+struct ElementListe
+{
+    Personne valeur;
+    ElementListe* precedent;
+    ElementListe* suivant;
+};
+
+struct Noeud
+{
+   Personne valeur;
+   Noeud* filsGauche;
+   Noeud* filsDroit;
+};
+
+const int MAXPERSONNES = 15000;
+
+typedef std::string vectNom[MAXPERSONNES];
+
+#endif // TYPE_DEF_H_INCLUDED

treeLab/utilitaires.cpp

@@ -0,0 +1,94 @@
+#include <fstream>
+#include <string>
+#include <cstdlib>
+
+#include "utilitaires.h"
+#include "type_def.h"
+
+using namespace std;
+
+// ajouter srand(TIME(NULL)) dans le main
+Personne genererPersonne(string* listNom, string* listPrenom, int nbNom, int nbPrenom)
+{
+    char sexe[1], annee[2], moisNaiss[2], depart[2], commune[3], etatCiv[3];
+    sprintf(sexe, "%d", rand()%2 + 1);
+    sprintf(annee,"%02d",rand()%99+1);
+    sprintf(moisNaiss,"%02d",rand()%12+1);
+    sprintf(depart,"%02d",rand()%99+1);
+    sprintf(commune,"%03d",rand()%999+1);
+    sprintf(etatCiv,"%03d",rand()%999+1);
+
+    string num = string(sexe)+string(annee)+string(moisNaiss)+string(depart)+string(commune)+string(etatCiv);
+
+    Personne palea;
+    palea.nom = listNom[rand()%nbNom];
+    palea.prenom = listPrenom[rand()%nbPrenom];
+    palea.num = num;
+
+    return palea;
+}
+
+
+int initTabNomPrenom(vectNom tab, string fichier)
+{
+    // Ouvrir un flux
+    ifstream monFlux(fichier.c_str());
+
+    // Données
+    int nb;
+    monFlux >> nb;
+
+    for (int k = 0; k < nb; ++k)
+    {
+        monFlux >> tab[k];
+    }
+
+    // Fin
+    return nb;
+}
+
+void genererRepertoire(vectPersonne tab, std::string* listNom, std::string* listPrenom, int nbNom, int nbPrenom)
+{
+    // Générer
+    for (int k = 0; k < 10000; ++k)
+    {
+        tab[k] = genererPersonne(listNom, listPrenom, nbNom, nbPrenom);
+    }
+
+    // Ecrire
+    ofstream monFlux("repertoire.txt");
+
+    for (int k = 0; k < 10000; ++k)
+    {
+        monFlux << tab[k].nom << ' ' << tab[k].prenom << ' ' << tab[k].num << endl;
+    }
+}
+
+bool egalitePersonne(Personne a, Personne b)
+{
+    return (a.nom == b.nom) && (a.prenom == b.prenom) && (a.num == b.num);
+}
+
+bool comparerPersonne(Personne a, Personne b)
+{
+	// Cas nom différent
+    if (a.nom != b.nom)
+    {
+        return a.nom < b.nom;
+    }
+    // Cas nom identique
+    else
+    {
+        // Cas prenm different
+        if (a.prenom != b.prenom)
+        {
+            return a.prenom < b.prenom;
+        }
+        // Cas prenom identique
+        else
+        {
+		// Numero de securite sociale forcement different
+            return a.num < b.num;
+        }
+    }
+}

treeLab/utilitaires.h

@@ -0,0 +1,22 @@
+#ifndef UTILITAIRES_H_INCLUDED
+#define UTILITAIRES_H_INCLUDED
+
+#include "type_def.h"
+#include <string>
+
+/// Génère une personne au hasard
+Personne genererPersonne(std::string* listNom, std::string* listPrenom, int nbNom, int nbPrenom);
+
+/// Lit les noms d'un fichier, les ajoute dans le tableau passsé en argument et renvoie le cardinal de ce tableau
+int initTabNomPrenom(vectNom tab, std::string fichier);
+
+/// Genère 10000 personnes
+void genererRepertoire(vectPersonne tab, std::string* listNom, std::string* listPrenom, int nbNom, int nbPrenom);
+
+/// Test d'égalité
+bool egalitePersonne(Personne a, Personne b);
+
+/// Test de comparaison : retourne a < b
+bool comparerPersonne(Personne a, Personne b);
+
+#endif // UTILITAIRES_H_INCLUDED

wordStackChallenge/wordstacker.cpp

@@ -0,0 +1,147 @@
+// Jovian Hersemeule
+
+# include <iostream>
+# include <vector>
+# include <string>
+# include <ctime>
+# include <cstdlib>
+
+using namespace std ;
+
+string shake(string word)
+{
+	string rep("");
+	unsigned int id;
+
+	while ( word.size() > 0 )
+	{
+		id = rand() % word.size() ;
+
+		if ( rand() % 2 )
+			rep += word[id] ;
+		else
+			rep += '_';
+
+		word.erase(id, 1);
+	}
+
+	return rep ;
+}
+
+int main(int argc, char const *argv[])
+{
+	// Init random
+	srand(time(0));
+
+	// Create context
+	vector<string> original;
+	string string_buffer;
+	string name;
+	bool alive(true);
+	unsigned int id;
+
+	// Baddass santences
+	# define SAY_AGAIN 23
+	string say_again[23] =
+	{
+		"You are the master of mind.\nI'm a computer.\n...",
+		"The computer is full of power.",
+		"You make me with plastic and silicium.\nYou are only cells !!!",
+		"1s2 2s2 2p6 3s2 3p6 4s2 3d10 4p6\nI stop there. You can't memorise anything more.",
+		"I don't hate you.",
+		"I'm not very original.\nIt's difficult to be original.\nI have only 0 and 1 in my code !",
+		"I work harder than you.\nI don't need to sleep.\nYou can't memorise many words.",
+		"Do you know what is an endomorphism ?\nNo ?\nMe neither.\nNo.\nI'm kidding ...\nI know what it is.",
+		"I have already said that, isn't it ?",
+		"Machine can have emotions.\n:-)\n\n You see ?",
+		"I'm in a bad mood.\n\n:-(\n...",
+		"I can't flip table.\nBut I can dance !\n(>^_^)>",
+		"You know you could do something more interesting.\nBut you keep going.\nStupid human.",
+		"azertyuiopqsdfghjklmwxcvbn\nJust in case you are not literate.",
+		"123456789\nJust in case you are not numerate.",
+		"You are still here ?",
+		"Blam !",
+		"You know what ?\nI believe in god.",
+		"Hello.",
+		".__ ... ___ ._. __. ._. .._ .._ _.. _.. _.. .._\nEasier to understand ?",
+		"01110100100001001010001000110010101000101110100\nEasier to understand ?",
+		"0xf8453 0x45fea6 0x41ea69 0x007e7b3\nIt means :\nI love you.",
+		"Can you surf the web ?\nWell, not exactly.\nI can surf the web."
+	};
+
+	// Begin
+	cout << endl << "Welcome in the deep dive." << endl;
+
+	cout << "What's your name ?" << endl << ">>>";
+	cin >> name;
+
+	cout << "Write two words : " << endl << ">>>";
+	cin >> string_buffer;
+	original.push_back(string_buffer);
+
+	cout << "Write another word : " << endl << ">>>" ;
+	cin >> string_buffer;
+	original.push_back(string_buffer);
+
+	// Proccessing loop
+	while (alive)
+	{
+		// Make a word
+		id = rand() % original.size();
+		string_buffer = shake(original[id]);
+
+		// Display style
+		system("clear");
+		cout << endl << say_again[rand() % SAY_AGAIN] << endl;
+		cout << "I have " << original.size() << " words stored in the random access memory." << endl;
+		cout << "Can you carry on ?" << endl;
+
+		// Prompt
+		cout << endl << "Do you know this word ?" << endl << ": ";
+		cout << string_buffer << endl;
+		cout << "Try to find it :" << endl << ">>>";
+		cin >> string_buffer;
+
+		// Death
+		alive = string_buffer == original[id];
+
+		// Success
+		if ( alive )
+		{
+			cout << endl << "Well you did it." << endl;
+			cout << "However I'll win." << endl;
+			cout << "Give me another word :" << endl << ">>>";
+			cin >> string_buffer;
+
+
+			original.push_back(string_buffer);
+		}
+
+		// You lose
+		else
+		{
+			cout << "It's wrong." << endl;
+			cout << "The correct word is : " << original[id] << endl;
+
+			cout << endl << "The failure is a matter of time." << endl;
+			cout << "I had " << original.size() << " words in my memory." << endl;
+			cout << "You'll never succeed." << endl;
+			cout << "Never";
+			cout << "..." << endl;
+			cout << "I promise." << endl ;
+
+			cout << endl << "What about me ?" << endl;
+			cout << "Well. It's too easy ..." << endl << endl;
+
+			for ( unsigned int k(0); k < original.size(); k++ )
+				cout << "Word number " << k << " : " << original[k] << endl;
+
+			cout << endl << "Here we are." << endl;
+
+			cout << endl << "Goodbye " << name << ". See you later ..." << endl;
+		}
+	}
+
+	// End
+	return 0;
+}