Sharing of my labs carried out during the TDDE18 course at Linköping University
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

toknow.txt 13KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407
  1. Commande C++ :
  2. #include <iostream> // a placer au début
  3. #include <string> // a placer au début
  4. #include <fstream> // a placer au début si communication avec fichier texte
  5. #include <iomanip> // a placer au debut si utilisation setw et autre
  6. #include <vector> // a placer si utilisation storage
  7. using namespace std; // a placer au début (librairie std)
  8. //file separation
  9. Implementation files (.cc) // contains definitions
  10. Header files (.h) // contains declaration (the list of class / functions with variables and fonction)
  11. Executable files // programs the computer run
  12. Object files (.o) // can be combined to create an executable
  13. //in file.h write
  14. #ifndef FILE_H
  15. #define FILE_H
  16. blabla
  17. #endif
  18. //in test.cc write
  19. #include "file.h"
  20. // in the testing file
  21. #define CATCH_CONFIG_MAIN
  22. #include "catch.hpp"
  23. //droit d'accès
  24. public // éléments accessibles depuis l'extérieur
  25. private // élément pas accessibles depuis extérieur
  26. protected // élément pas acc depuis extérieur sauf si élément fille (héritage)
  27. int main() {....; return 0;} // programme de base, on écrit dedans
  28. cout << "Hello World" << endl; // on écrit sur l'écran et passage a la ligne
  29. cout << "m'appelle" << flush; // on écrit et on demande a envoyer
  30. cout << x << endl; // affiche la valeur de la var x
  31. cin >> x; // input de valeur dans x # le buffer fonctionne bizarre souvient t'en
  32. cin >> str; // met le premier mot dans str
  33. getline(cin, str); // met toute la ligne entrée dans str (ligne séparée par \n)
  34. cin.ignore(1000, '\n'); // clean le buffer
  35. cin.clear() // clear all flags raised (fail Stream operaƟon failed, eof device has reached the end, bad irrecoverable stream error, good no errors)
  36. int x{5}; // variable int
  37. double y{3.14}; // variable double
  38. char z{'c'}; // variable char
  39. string str {"hello"}; // variable string
  40. str.size() // retourne la taille de str
  41. str.front() // retourne la première lettre de str
  42. int const y{7}; // crée une constante, aucun changement de val possible pour elle
  43. x >> y; // met le contenu de x dans y
  44. setw(x); // va set le nombre minimum de caractères du prochain cout (si pas suffisant, alors rempli avec espace)
  45. setfill('-'); // remplace l'espace comme caractère vide par le tiret ici
  46. right; // fout les espaces avant le mot au lieu de après (souvent utilisé avec setw())
  47. a == b && c != d
  48. a <= b || c > d
  49. -a // negation
  50. ++a // incrémentation prefix (va incrémenter et renvoyer la nouvelle valeur)
  51. a++ // incrémentation postfix (va envoyer la valeur a puis incrémenter)
  52. --a // t'as capté
  53. a-- // t'as capté
  54. if(logical statement){}
  55. else if (logical statement){}
  56. else {}
  57. while(statement){} // boucle while
  58. do{}while(logical statement) // boucle do while (au moins une fois dedans)
  59. for(logical statement){} // boucle for tu coco
  60. static_cast<double>(a) // fait passer a de int a double
  61. static_cast<another_type>(var) // change de type of var
  62. dynamic_castt<Cuboid*>(ptr) // change de type si la variable est du type Cuboid ici (variable du type voulu)
  63. ifstream txt{"text.txt"}; // met le contenu de text.txt dans var txt
  64. while(txt >> str) {} // lecture de tout le fichier, mot par mot
  65. while(txt >> str) {} // lecture de tout le fichier, ligne par ligne
  66. int x{1}; // global var
  67. {
  68. cout << x << endl ; //will print 1
  69. int x{2}; // local var
  70. cout << x << endl ; // will print 2
  71. }
  72. returnt_type function_name(parameters); // declaration fonction début code (avant main)
  73. return_type function_name(parameters) // fonction type
  74. { // statements
  75. return result;}
  76. double add(double a, double b) // exemple fonction
  77. { return a+b;}
  78. void foo() // fonction ne retournant rien (void)
  79. {cout<<"fonction"<<enld;}
  80. struct Person // création struct, pour contenir plusieurs var
  81. {string name{};
  82. int age{};};
  83. Person p; // déclaration d'une var struct
  84. p.name = "José"; // pour acceder aux infos du struct
  85. Person p1{"josé";26} // déclaration directe
  86. string word{"hello"};
  87. string& greeting{word}; // créé un alias, c'est a dire que si on modifie la valeur de greeting, word change aussi
  88. string name{"Jean"};
  89. string const& surname{name}; // créé un alias mais qu'on ne peut pas modifier directement, on peut modifier name par contre
  90. // modifie la valeur de my_name grâce à l'alias
  91. void read_name(string& name)
  92. {cout << "Your name: "; cin >> name;}
  93. int main()
  94. {string my_name; read_name(my_name); cout << my_name << endl;}
  95. // some string are expensive to copy, so create a const& could be a good choice
  96. void print(string const& message)
  97. {cout << message << endl;}
  98. int main()
  99. {string my_msg{"Long message!"}; print(my_msg);}
  100. // deux fonctions peuvent avoir le même nom du moment où elles se différencient qq part
  101. int add(int a, int b)
  102. {return a + b;}
  103. double add(double a,double b)
  104. {return a + b;}
  105. void ignore(int n = 1024, char stop = '\n') // paramètre par défaut, pas obligé de les préciser
  106. {cin.ignore(n, stop);}
  107. bool operator<(Person const& p1, Person const& p2)
  108. {return p1.first_name < p2.first_name;}
  109. int main()
  110. {Person p1{"Christoffer", "Holm"};
  111. Person p2{"Fredrik", "Adolfsson"};
  112. if (p1 < p2) // ca marche car look première ligne
  113. {cout << p1 << endl;}}
  114. ostream& operator<<(ostream& os, Person const& p)
  115. {os << p.first_name << " " << p.last_name;
  116. return os;}
  117. Person p1{"Christoffer Holm"}; // ça marche car première ligne
  118. cout << p1 << endl;
  119. istream& operator>>(istream& is, Person& p)
  120. {is >> p.first_name >> p.last_name;
  121. return is;}
  122. Person p;
  123. int x;
  124. cin >> p >> x;
  125. #include <sstream> // module to facilitate the testing phase
  126. istringstream iss{"Yes"}; // simulate cin (for test, to don't have to input each time)
  127. ostringstream oss{}; // work like cout but in the terminal
  128. oss.str() // retrieve the written output
  129. Catch.hpp // module to test the code
  130. TEST_CASE // to create a test
  131. CHECK // check if the statement inside is true
  132. CHECK_FALSE // check if the statement inside is false
  133. REQUIRE // work like check but stops if this one fails
  134. REQUIRE_THROWS // an execption should be "levé"
  135. REQUIRE_NOTHROW // no exception needed
  136. //class = struct but with fonction like operator in it
  137. class Date; // class declaration
  138. class Date {} // class definition
  139. //this = hidden parameter, to access data, this
  140. data
  141. class Date {void set_year(int year) {this->year = year;}};
  142. //private variables, to put at the end of the class
  143. private: int day; int month; int year;
  144. //public variables, to put at the begining of the class
  145. public: Date(int d, int m, int y): day{d}, month{m}, year{y}
  146. Date(int d, int m, int y) //constructeur definition (after "public" in the class)
  147. Date:Date(int d, int m, int y) //constructor definition (outside the class)
  148. Personnage::Personnage() : m_vie(100), m_mana(100), m_nomArme("Épée rouillée"), m_degatsArme(10){} // constructeur
  149. // const member functions
  150. // inner class (class dans d'autre class)
  151. outer::inner::fun() // accède a la fonction fun() de la class inner dans la class outer
  152. outer::inner i{} // créé une variable i de class inner dans outer
  153. //friend create something outside the class but that have access to the private part
  154. //pointers
  155. int x{5}; int* ptr{&x}; // creation of the ptr variable et typé (int) (pointers)
  156. int y{7}; ptr = &y; // creation of the ptr variable (pointers too)
  157. cout << ptr ; // affiche l'emplacement de ce que le pointeur pointe
  158. cout << *ptr ; // affiche la valeur de ce que le pointeur pointe
  159. nullptr // key word to say the pointer pointe nothing
  160. int* ptr{new int{5}}; // create a var with no name but an adress given by the pointer
  161. delete ptr; // delete the case the pointer points on
  162. // node
  163. struct Node {int value; Node* next;}; // créé un struct avec une valeur et un pointeur qui va faire la prochaine case
  164. Node n2 {2, nullptr}; Node n1 {8, &n2}; // création d'un exemple de 2 cases avec le 1 allant vers 2
  165. cout << (*n1).value; // affiche la valeur du noeud n1
  166. cout << n1->value ; // affiche la valeur du noeud n1 aussi (pareil que préc)
  167. // insert
  168. class List
  169. {
  170. public:
  171. void remove();
  172. void insert(int value)
  173. {
  174. Node* tmp{new Node{value}};
  175. tmp->next = first;
  176. first = tmp;
  177. }
  178. private:
  179. Node* first{};
  180. };
  181. // remove
  182. class List {
  183. public
  184. :
  185. void remove() {
  186. Node* tmp = first;
  187. first = first->next;
  188. delete tmp;
  189. }
  190. void insert(int value);
  191. private
  192. :
  193. Node* first{};
  194. };
  195. // special member functions
  196. // Objet temporaire
  197. objet&&
  198. //return operator function
  199. return this*
  200. // sequential storage
  201. std::vector<int> v {5, 3, 1, 2}; // creation tableau dynamique
  202. v.at(1) = 4; // changement de valeur indice 1
  203. v.push_back(3); // ajout de la valeur 3 à la fin
  204. v.front() = 2; // changement de la premiere valeur
  205. v.back() = 6; // changement de la dernière valeur
  206. v.pop_back(); // suppression de la dernière valeur
  207. v[indice] // acceder a une valeur
  208. v.at(indice) // check si element existe
  209. v.size(); // how many elements
  210. // loop through storage (3 ways to do it)
  211. vector<string> words {...};
  212. for (int i{0}; i < words.size(); ++i){...} // passe par les indices
  213. for (string word : words){} // passe par les valeurs en les copiant dans words
  214. for (string const& word : words){} // passe par les valeurs sans les copier, on peut donc les modifier
  215. // Inheritance
  216. class Base {}; // création classe mère
  217. class Derived : public Base{}; // création classe fille
  218. // polymorphisme
  219. class Moto : public Vehicule //Une Moto EST UN Vehicule
  220. { public:
  221. Moto( int prix, double vitesseMax) // constructeur juste pour cet objet
  222. virtual void affiche() const; // on rajoute virtual pour que ca choissise la bonne version de la méthode
  223. virtual ~Moto() = default; // destructeur toujours virtuel si use polymorphisme
  224. virtual double current() override; // sert à réécrire par dessus si moto est fonction fille
  225. using Vehicule::variable; // on réimporte la variable qui était noté dans la classe mère juste pour rappeler qu'elle est là
  226. private:
  227. double m_vitesse; //La vitesse maximale de la moto
  228. };
  229. 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)
  230. // exception
  231. int main(){
  232. try{} // on met le code la dedans
  233. catch (std::exception& e) // on attrape l'exception
  234. {cerr << e.what();}}
  235. throw std::exception{""}; // balanche une exception
  236. //verif type
  237. isalpha() // vérifie si caractere dedans est une lettre
  238. isdigit() // vérifie si chiffre
  239. islower() // vérifie si minuscule
  240. isupper() // vérifie si majuscule
  241. isspace() // vérifie si espace
  242. tolower() // transforme en minuscule
  243. toupper() // transforme en majuscule
  244. // Containers Sequence : verctor, deque, list, stack, queue, priority_queue
  245. // Containers associative : set, multiset, map, multimap
  246. // commandes sur container
  247. container.size() // renvoie la size
  248. container.empty() // renvoie true ou false si container vide ou non
  249. container.clear() // vide tout
  250. a.swap(b) // échange les contenus des containers
  251. // Sequence container
  252. // likewise for list, forward_list and deque
  253. std::vector<int> v {1, 2, 3};
  254. // we have to specify a size for array
  255. std::array<int, 3> a {1, 2, 3};
  256. //vector (sequence)
  257. a.push_back() // ajout élément à la fin
  258. a.pop_back() // delete dernier élément
  259. a.front() // renvoie premier élément
  260. a.back() // renvoie dernier élément
  261. a.assign() // rempli tout les éléments avec la même valeur
  262. // array (comme vector mais taille fixe)
  263. // list
  264. //forward list
  265. //deque
  266. a.push_back() // ajout élément à la fin
  267. a.pop_back() // delete dernier élément
  268. a.front() // renvoie premier élément
  269. a.back() // renvoie dernier élément
  270. a.assign() // rempli tout les éléments avec la même valeur
  271. a.push_front() // rajoute au début
  272. a.pop_front() // enlève premier élément
  273. //stack (LIFO)
  274. a.push() // ajouter element
  275. a.top() // consulter dernier element
  276. a.pop() // supprimer dernier élément
  277. // queue (FIFO)
  278. a.push() // ajouter element
  279. a.front() // consulter dernier element
  280. a.pop() // supprimer dernier élément
  281. //Associative containers
  282. //map : associates value with a key
  283. map<string, int> a; // declaration
  284. key have to be comparable with operator <
  285. //set : like map but only store keys, value unique and sorted
  286. // multiset / multimap : like set and map but keys doesn't have to be unique
  287. //unordered_(multi)map / unordered_(multi)set : keys not sorted and doesn't have to be comparable anymore
  288. // Iterators
  289. // this works !
  290. int main()
  291. {set<int> v {1, 2, 3};
  292. for (int e : v)
  293. {cout << e << endl; // works!}}
  294. // Better
  295. using iterator = std::vector<int>::iterator;
  296. for (iterator it{v.begin()}; it != v.end(); ++it)
  297. {cout << *it << endl;}
  298. tab.erase(tab.begin()); // efface le premier element
  299. tab.insert(tab.begin()); // insert un élément juste après
  300. //Iterators categories
  301. Input : Peut préparer des valeurs déjà existantes dans un conteneur
  302. Outpout : peut ajouter des nouvelles valeurs dans un conteneur
  303. Forward : can read / overwrite existing value + can step forward in the container + is an input iterator
  304. bidirectional : can go forward and backward
  305. Random access : can access n'importe quel élément grâce a l'opérateur + & aussi bidirectional iterator
  306. //lambda functions
  307. [](int n) { return n + 2; } // function that return the number + 2
  308. int x {2};
  309. std::vector<int> v {1, 2, 3};
  310. std::transform(v.begin(), v.end(), v.begin(), [x](int n) { return n + x; });
  311. // fonction template (toujours dans fichier .h)
  312. template<typename T> // declaration type générique
  313. T maximum(const T& a,const T& b){blablabla} // création fonction maximum template
  314. maximum<int>(cave,dernierEtage) // appel de ma fonction avec des int
  315. auto add(T a, U b) // decla d'une fonction avec 2 template et auto en return type