Commande C++ : #include // a placer au début #include // a placer au début #include // a placer au début si communication avec fichier texte #include // a placer au debut si utilisation setw et autre #include // a placer si utilisation storage using namespace std; // a placer au début (librairie std) //file separation Implementation files (.cc) // contains definitions Header files (.h) // contains declaration (the list of class / functions with variables and fonction) Executable files // programs the computer run Object files (.o) // can be combined to create an executable //in file.h write #ifndef FILE_H #define FILE_H blabla #endif //in test.cc write #include "file.h" // in the testing file #define CATCH_CONFIG_MAIN #include "catch.hpp" //droit d'accès public // éléments accessibles depuis l'extérieur private // élément pas accessibles depuis extérieur protected // élément pas acc depuis extérieur sauf si élément fille (héritage) int main() {....; return 0;} // programme de base, on écrit dedans cout << "Hello World" << endl; // on écrit sur l'écran et passage a la ligne cout << "m'appelle" << flush; // on écrit et on demande a envoyer cout << x << endl; // affiche la valeur de la var x cin >> x; // input de valeur dans x # le buffer fonctionne bizarre souvient t'en cin >> str; // met le premier mot dans str getline(cin, str); // met toute la ligne entrée dans str (ligne séparée par \n) cin.ignore(1000, '\n'); // clean le buffer cin.clear() // clear all flags raised (fail Stream operaƟon failed, eof device has reached the end, bad irrecoverable stream error, good no errors) int x{5}; // variable int double y{3.14}; // variable double char z{'c'}; // variable char string str {"hello"}; // variable string str.size() // retourne la taille de str str.front() // retourne la première lettre de str int const y{7}; // crée une constante, aucun changement de val possible pour elle x >> y; // met le contenu de x dans y setw(x); // va set le nombre minimum de caractères du prochain cout (si pas suffisant, alors rempli avec espace) setfill('-'); // remplace l'espace comme caractère vide par le tiret ici right; // fout les espaces avant le mot au lieu de après (souvent utilisé avec setw()) a == b && c != d a <= b || c > d -a // negation ++a // incrémentation prefix (va incrémenter et renvoyer la nouvelle valeur) a++ // incrémentation postfix (va envoyer la valeur a puis incrémenter) --a // t'as capté a-- // t'as capté if(logical statement){} else if (logical statement){} else {} while(statement){} // boucle while do{}while(logical statement) // boucle do while (au moins une fois dedans) for(logical statement){} // boucle for tu coco static_cast(a) // fait passer a de int a double static_cast(var) // change de type of var dynamic_castt(ptr) // change de type si la variable est du type Cuboid ici (variable du type voulu) ifstream txt{"text.txt"}; // met le contenu de text.txt dans var txt while(txt >> str) {} // lecture de tout le fichier, mot par mot while(txt >> str) {} // lecture de tout le fichier, ligne par ligne int x{1}; // global var { cout << x << endl ; //will print 1 int x{2}; // local var cout << x << endl ; // will print 2 } returnt_type function_name(parameters); // declaration fonction début code (avant main) return_type function_name(parameters) // fonction type { // statements return result;} double add(double a, double b) // exemple fonction { return a+b;} void foo() // fonction ne retournant rien (void) {cout<<"fonction"<> name;} int main() {string my_name; read_name(my_name); cout << my_name << endl;} // some string are expensive to copy, so create a const& could be a good choice void print(string const& message) {cout << message << endl;} int main() {string my_msg{"Long message!"}; print(my_msg);} // deux fonctions peuvent avoir le même nom du moment où elles se différencient qq part int add(int a, int b) {return a + b;} double add(double a,double b) {return a + b;} void ignore(int n = 1024, char stop = '\n') // paramètre par défaut, pas obligé de les préciser {cin.ignore(n, stop);} bool operator<(Person const& p1, Person const& p2) {return p1.first_name < p2.first_name;} int main() {Person p1{"Christoffer", "Holm"}; Person p2{"Fredrik", "Adolfsson"}; if (p1 < p2) // ca marche car look première ligne {cout << p1 << endl;}} ostream& operator<<(ostream& os, Person const& p) {os << p.first_name << " " << p.last_name; return os;} Person p1{"Christoffer Holm"}; // ça marche car première ligne cout << p1 << endl; istream& operator>>(istream& is, Person& p) {is >> p.first_name >> p.last_name; return is;} Person p; int x; cin >> p >> x; #include // module to facilitate the testing phase istringstream iss{"Yes"}; // simulate cin (for test, to don't have to input each time) ostringstream oss{}; // work like cout but in the terminal oss.str() // retrieve the written output Catch.hpp // module to test the code TEST_CASE // to create a test CHECK // check if the statement inside is true CHECK_FALSE // check if the statement inside is false REQUIRE // work like check but stops if this one fails REQUIRE_THROWS // an execption should be "levé" REQUIRE_NOTHROW // no exception needed //class = struct but with fonction like operator in it class Date; // class declaration class Date {} // class definition //this = hidden parameter, to access data, this data class Date {void set_year(int year) {this->year = year;}}; //private variables, to put at the end of the class private: int day; int month; int year; //public variables, to put at the begining of the class public: Date(int d, int m, int y): day{d}, month{m}, year{y} Date(int d, int m, int y) //constructeur definition (after "public" in the class) Date:Date(int d, int m, int y) //constructor definition (outside the class) Personnage::Personnage() : m_vie(100), m_mana(100), m_nomArme("Épée rouillée"), m_degatsArme(10){} // constructeur // const member functions // inner class (class dans d'autre class) outer::inner::fun() // accède a la fonction fun() de la class inner dans la class outer outer::inner i{} // créé une variable i de class inner dans outer //friend create something outside the class but that have access to the private part //pointers int x{5}; int* ptr{&x}; // creation of the ptr variable et typé (int) (pointers) int y{7}; ptr = &y; // creation of the ptr variable (pointers too) cout << ptr ; // affiche l'emplacement de ce que le pointeur pointe cout << *ptr ; // affiche la valeur de ce que le pointeur pointe nullptr // key word to say the pointer pointe nothing int* ptr{new int{5}}; // create a var with no name but an adress given by the pointer delete ptr; // delete the case the pointer points on // node struct Node {int value; Node* next;}; // créé un struct avec une valeur et un pointeur qui va faire la prochaine case Node n2 {2, nullptr}; Node n1 {8, &n2}; // création d'un exemple de 2 cases avec le 1 allant vers 2 cout << (*n1).value; // affiche la valeur du noeud n1 cout << n1->value ; // affiche la valeur du noeud n1 aussi (pareil que préc) // insert class List { public: void remove(); void insert(int value) { Node* tmp{new Node{value}}; tmp->next = first; first = tmp; } private: Node* first{}; }; // remove class List { public : void remove() { Node* tmp = first; first = first->next; delete tmp; } void insert(int value); private : Node* first{}; }; // special member functions // Objet temporaire objet&& //return operator function return this* // sequential storage std::vector v {5, 3, 1, 2}; // creation tableau dynamique v.at(1) = 4; // changement de valeur indice 1 v.push_back(3); // ajout de la valeur 3 à la fin v.front() = 2; // changement de la premiere valeur v.back() = 6; // changement de la dernière valeur v.pop_back(); // suppression de la dernière valeur v[indice] // acceder a une valeur v.at(indice) // check si element existe v.size(); // how many elements // loop through storage (3 ways to do it) vector words {...}; for (int i{0}; i < words.size(); ++i){...} // passe par les indices for (string word : words){} // passe par les valeurs en les copiant dans words for (string const& word : words){} // passe par les valeurs sans les copier, on peut donc les modifier // Inheritance class Base {}; // création classe mère class Derived : public Base{}; // création classe fille // polymorphisme class Moto : public Vehicule //Une Moto EST UN Vehicule { public: Moto( int prix, double vitesseMax) // constructeur juste pour cet objet virtual void affiche() const; // on rajoute virtual pour que ca choissise la bonne version de la méthode virtual ~Moto() = default; // destructeur toujours virtuel si use polymorphisme virtual double current() override; // sert à réécrire par dessus si moto est fonction fille using Vehicule::variable; // on réimporte la variable qui était noté dans la classe mère juste pour rappeler qu'elle est là private: double m_vitesse; //La vitesse maximale de la moto }; virtual int nbrRoues() const = 0; //méthode virtuelle pure (i.e. la classe mère ne renvoi rien mais elle dit que les classes filles ont cette fonction qui renvoie qqch) // exception int main(){ try{} // on met le code la dedans catch (std::exception& e) // on attrape l'exception {cerr << e.what();}} throw std::exception{""}; // balanche une exception //verif type isalpha() // vérifie si caractere dedans est une lettre isdigit() // vérifie si chiffre islower() // vérifie si minuscule isupper() // vérifie si majuscule isspace() // vérifie si espace tolower() // transforme en minuscule toupper() // transforme en majuscule // Containers Sequence : verctor, deque, list, stack, queue, priority_queue // Containers associative : set, multiset, map, multimap // commandes sur container container.size() // renvoie la size container.empty() // renvoie true ou false si container vide ou non container.clear() // vide tout a.swap(b) // échange les contenus des containers // Sequence container // likewise for list, forward_list and deque std::vector v {1, 2, 3}; // we have to specify a size for array std::array a {1, 2, 3}; //vector (sequence) a.push_back() // ajout élément à la fin a.pop_back() // delete dernier élément a.front() // renvoie premier élément a.back() // renvoie dernier élément a.assign() // rempli tout les éléments avec la même valeur // array (comme vector mais taille fixe) // list //forward list //deque a.push_back() // ajout élément à la fin a.pop_back() // delete dernier élément a.front() // renvoie premier élément a.back() // renvoie dernier élément a.assign() // rempli tout les éléments avec la même valeur a.push_front() // rajoute au début a.pop_front() // enlève premier élément //stack (LIFO) a.push() // ajouter element a.top() // consulter dernier element a.pop() // supprimer dernier élément // queue (FIFO) a.push() // ajouter element a.front() // consulter dernier element a.pop() // supprimer dernier élément //Associative containers //map : associates value with a key map a; // declaration key have to be comparable with operator < //set : like map but only store keys, value unique and sorted // multiset / multimap : like set and map but keys doesn't have to be unique //unordered_(multi)map / unordered_(multi)set : keys not sorted and doesn't have to be comparable anymore // Iterators // this works ! int main() {set v {1, 2, 3}; for (int e : v) {cout << e << endl; // works!}} // Better using iterator = std::vector::iterator; for (iterator it{v.begin()}; it != v.end(); ++it) {cout << *it << endl;} tab.erase(tab.begin()); // efface le premier element tab.insert(tab.begin()); // insert un élément juste après //Iterators categories Input : Peut préparer des valeurs déjà existantes dans un conteneur Outpout : peut ajouter des nouvelles valeurs dans un conteneur Forward : can read / overwrite existing value + can step forward in the container + is an input iterator bidirectional : can go forward and backward Random access : can access n'importe quel élément grâce a l'opérateur + & aussi bidirectional iterator //lambda functions [](int n) { return n + 2; } // function that return the number + 2 int x {2}; std::vector v {1, 2, 3}; std::transform(v.begin(), v.end(), v.begin(), [x](int n) { return n + x; }); // fonction template (toujours dans fichier .h) template // declaration type générique T maximum(const T& a,const T& b){blablabla} // création fonction maximum template maximum(cave,dernierEtage) // appel de ma fonction avec des int auto add(T a, U b) // decla d'une fonction avec 2 template et auto en return type