123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407 |
- Commande C++ :
- #include <iostream> // a placer au début
- #include <string> // a placer au début
- #include <fstream> // a placer au début si communication avec fichier texte
- #include <iomanip> // a placer au debut si utilisation setw et autre
- #include <vector> // 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<double>(a) // fait passer a de int a double
- static_cast<another_type>(var) // change de type of var
- dynamic_castt<Cuboid*>(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"<<enld;}
-
- struct Person // création struct, pour contenir plusieurs var
- {string name{};
- int age{};};
- Person p; // déclaration d'une var struct
- p.name = "José"; // pour acceder aux infos du struct
- Person p1{"josé";26} // déclaration directe
-
- string word{"hello"};
- string& greeting{word}; // créé un alias, c'est a dire que si on modifie la valeur de greeting, word change aussi
- string name{"Jean"};
- string const& surname{name}; // créé un alias mais qu'on ne peut pas modifier directement, on peut modifier name par contre
-
- // modifie la valeur de my_name grâce à l'alias
- void read_name(string& name)
- {cout << "Your name: "; cin >> 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 <sstream> // 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<int> 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<string> 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<int> v {1, 2, 3};
- // we have to specify a size for array
- std::array<int, 3> 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<string, int> 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<int> v {1, 2, 3};
- for (int e : v)
- {cout << e << endl; // works!}}
-
- // Better
- using iterator = std::vector<int>::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<int> 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<typename T> // declaration type générique
- T maximum(const T& a,const T& b){blablabla} // création fonction maximum template
- maximum<int>(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
|