Welcome to the myWiki wiki! Table of contents :

Plusieurs fichiers

Tableaux

Objets

Classes

on crée un dossier avec le CMakeLists.txt adapté au nom de notre projet, on crée un dossier Build, et un fichier cpp vierge. Cmake fait le reste !

Dans le auxiliaire.h on met :

• #pragma once
• la définition des constantes et des structures
• on appelle les fonctions du auxiliaire.cpp (avec les types)

Dans le auxiliaire.cpp on met :

• les #include “ ce que l’on veut
• #include auxiliaire.h -using namespace blabla; -les fonctions

Dans le principal on met :

• include “ce que l’on veut“

• #include “auxiliaire.h“
• using namespace

Réinitialiser le random : srand(time(NULL));

Au moment de créer le tableau t de taille n (variable) on écrit : int* t= new int[n]; // (ou l’équivalent pour un autre type que int) Lorsque le tableau doit mourir (en fin de fonction généralement), on écrit la ligne : delete[] t;

int M[10][10]; On est obligé de préciser les dimensions du tableau 2D paramètre d’une fonction. Il est donc globalement plus intéressant de rester en 1D et de faire des tableaux de tableaux 1D.

##Objets Il s’agit de ranger les fonctions dans les objets qui sont comme des structures mais avec des fonctions membres en plus.

Dans le header struct obj {
 int x; // champ x
 int f (); // méthode f () int g(int y); // méthode g()};

Pour permettre à plusieurs objets d’avoir les mêmes noms de méthodes, on préfixe leur définition par le nom de l’objet suivi de "::" int obj1::g(int y) { // méthode g() de obj1 (définition) ... return . . . }

Dans ses méthodes, un objet accède directement à ses champs et à ses autres méthodes, c’est-à-dire sans rien mettre devant ! int obj1::f() { // méthode f() de obj1 (définition)
 int i=g(3); // méthode g() de l’objet dont la méthode f() est en train de s’exécuter
 int j=x+i; // champ x de l’objet dont la méthode f() est en train de s’exécuter return j ;}

Dans le cpp

Opérateurs: nt void obj::fonction1 int operator+(objA . A, objB B){… }

##Classes Comme un objet mais une partie des données est privé l’autre est public donc pour pouvoir l’utiliser il faut mettre public : Constructeur : Un constructeur est une méthode dont le nom est le nom de la classe elle- même. Il ne retourne rien mais son type de retour n’est pas void : il n’a pas de type de retour. Il est impossible d’appeler un constructeur sur un objet déjà créé a. On crée un constructeur avec obj::constructeur

vector : (c’est comme un tableau) on commence par #include puis pour déclarer un vecteur v : vector v; (c’est un tableau vide) on peut même écrire : vector <vector> v1; v.pushback(3); // rajoute l’élément « 3 » à la fin du tableau si on veut sortir le 1er élément : cout << v[0]; pour remplir : v[3]=1; à condition d’avoir pushbacké assez cout << v.size(); vector vf(200);

pair (pas besoin de include) pair<int,float> p; // crée une paire de deux éléments de types au choix p.first=0; p.second=50; p = make_pair(0 , 50); pair<pair<int,int>,int> ;

Liste: l’intérêt est qu’on peut faire des insertions et suppressions ce n’est pas très rapide pour accéder à un élément car l’ordi parcourt toutes les cases avant cependant, les insertions et suppressions ne demandent presque aucun effort à l’ordi list lst; lst.push_back(5); // rajoute « 5 » à la fin de la liste lst.push_front(4); // rajoute « 4 » au début list :: iterator it ; it = lst.begin(); //place l’itérateur sur la première case it++; // case suivante it—; // case précédente l’itérateur peut aussi se placer dans une positions particulière : la fin de la liste (après la dernière case) cout<< *it ; valeur de la case marquée par it lst.end est le nom de la fin de liste (c’est la plus grande valeur que peut prendre l’itérateur)