Télécharger la présentation
La présentation est en train de télécharger. S'il vous plaît, attendez
Publié parFernand Levy Modifié depuis plus de 10 années
1
Formation C++
2
Hello World ! #include /* Commentaire sur plusieurs lignes */ int main() { //Affiche hello world std::cout << "Hello World !“ << std:endl; }
3
Nouveautés de syntaxe en C++ Surcharge de fonctions, d’opérateurs Références Namespace (non abordé) Fonctions templates (non abordé)
4
Surcharge de fonction void f(int i) {} int f(double i) {} void f(int a,int b) {} // ERREUR : // Diffère uniquement par // le type de retour double f(int i) {}
5
Attention aux ambiguïtés void f(int a, double b) {} void f(double a, int b) {} int a,b; f(a,b); // ?? f((double)a,b); //ok Le mieux est encore de ne pas écrire deux fonctions aux paramètres si proche l’un de l’autre !
6
Opérateurs Mathématiques : +, -, *, /, %, ++, -- Logiques : &&, ||, !, ==, !=,, = Données : *, &, -> Binaire : &, |, ^, ~, > Assignation : =, *=, /=, %=, +=, -=, >=, &=, |=, ^= Tous surchargeables.
7
Références Permettent de passer la variable plutôt que la copie. Evite la recopie de la variable (gain en rapidité pour de grosses structures). Permet de simplifier l’écritures de fonctions qui écrivent dans une variable.
8
Référence void Double(int x) { x*=2; } int a=2; Double(a); //a==2 void Double(int& x) {x*=2; } Double(a); //a==4 void Double(int* x) {*x*=2; } Double(&a);//a==4
9
Qu’est ce qu’un objet ? Un type qui regroupe des informations (membres), et qui offre des moyens de les traiter (grâce à des méthodes). Exemple : objet joueur Membres : points de vie envie de manger état (mort ?) Méthodes : Attaqué par Mange
10
Comment définir un objet en C++ class CJoueur { public: void AttaqueDe(CJoueur& J) { Vie -= J.Vie; EnvieManger += 10; Mort = ((Vie =100)); } void Mange() {EnvieManger=0;} int Vie, EnvieManger; bool Mort; };
11
Structure des fichiers d’un projet C++ Header (.h) Code (.cpp) Objet (.o) Executable Compilation Link
12
Les erreurs Compilation Syntaxe (erreurs) Warnings Linkage Fonctions et variables déclarées, non implémentées Exécution Segfault
13
Organisation des fichiers Joueur.h : class CJoueur { public: void AttaqueDe(CJoueur& J); void Mange(); int Vie, EnvieManger; bool Mort; }; Joueur.cpp : void CJoueur::AttaqueDe(CJoueur& J) { Vie -= J.Vie; EnvieManger += 10; Mort = ((Vie =100)); } void CJoueur::Mange() { EnvieManger=0; }
14
Pré compilateur Joueur.h : #ifndef JOUEUR_H #define JOUEUR_H Class CJoueur {/* … */ }; #endif Joueur.cpp : #include “Joueur.h” void CJoueur::AttaqueDe(CJoueur& J) …
15
Utilisation de l’objet CJoueur J; J.Mort=false ; J.Vie=100; J.Mange(); CJoueur* p=&J; (*p).Vie=100; p->Vie=100; p->Mange();
16
Constructeur – destructeur Initialisation des données : on veut qu’à la création de la variable notre joueur soit vivant sans avoir besoin de le dire ! Constructeur : fonction appelée à la création de l’objet (pour l’initialisation) Destructeur : fonction appelée à la destruction de l’objet
17
Constructeur – destructeur class CJoueur { public: CJoueur() { Vie=100; EnvieManger=0; Mort=false; } ~CJoueur() { } };
18
new et delete, création dynamique d’objets malloc et free (du C) ne peuvent être utilisés car on a besoin d’appeler le constructeur et le destructeur de l’objet new T; retourne un pointeur vers une zone de donnée allouée par l’OS pour stocker un objet de type T. delete p; informe l’OS que la mémoire préalablement allouée par un new n’est plus utile. Toujours autant de new que de delete ! (règle sans aucune exception !)
19
Membres privés, publics Cacher des membres et des propriétés à l’extérieur Assurer que les données ne seront pas modifiées par l’extérieur Indiquer à l’utilisateur les membres et méthodes dont il aura besoin Conseil : mettre les membres en privé, avec au besoin des méthodes Get-Set
20
Membres privés, publics class CJoueur { public: CJoueur(); ~CJoueur(); void AttaqueDe(CJoueur& J); void Mange(); bool IsDead(); private: int Vie, EnvieManger; bool Mort; };
21
Dérivation Créer un nouvel objet, plus spécifique, à partir d’un objet de base CJoueur -> CJoueurHumain, CJoueurZerg, CJoueurProtoss (CJoueur&)CJoueurHumain (CJoueurHumain&)CJoueur
22
Dérivation class CJoueurZerg : public CJoueur { public: void SayGrrrgg(); }; CJoueurZerg Zergling; CJoueur J; Zergling.Mange(); J.AttaqueDe(Zergling); Zergling.SayGrrrgg(); CJoueur* p=&Zergling; p->SayGrrrgg();//Error
23
Fonctions virtuelles CJoueurHumain, CJoueurProtoss et CJoueurZerg ne mangent pas de la même façon. Pourtant on veut que tout CJoueur puisse manger.
24
Fonctions virtuelles class CJoueur { public: virtual void Mange() { EnvieManger=0; } }; class CJoueurZerg :public CJoueur { public: void Mange() { SayGrrrgg(); CJoueur::Mange(); } };
25
Fonctions virtuelles CJoueurZerg Over; CJoueur J; CJoueur* P=&Over; J.Mange(); Over.Mange(); P->Mange();
26
Fonctions virtuelles pures On ne sait pas définir CJoueur::Mange, on veut que les classes dérivées soient contraintes d’implémenter Mange() class CJoueur { public: virtual void Mange()=0; };
27
Fonctions virtuelles pures class CJoueurZerg :public CJoueur { public: void Mange() { SayGrrrgg(); EnvieManger=0; } }; CJoueurZerg Hydra; Hydra.Mange(); CJoueur J;//Erreur CJoueur* P=&Hydra; P->Mange(); //OK
28
Fonctions virtuelles pures class CJoueurHumain :public CJoueur {}; class CCapitaine :public CJoueurHumain { public: void Mange() { /* … */ } }; CJoueur J; //Erreur CJoueurHumain J; //Erreur CCapitaine Capitaine; CJoueur* P=&Capitaine; P->Mange(); //OK
29
class CMatrix { public: CMatrix() {} CMatrix(const CMatrix& m); double& operator()(int i,int j) {return Datas[i][j];} CMatrix& operator=(CMatrix& m); CMatrix& operator*=(double d); CMatrix& operator+=(CNmatrix& m); CMatrix operator+(CMatrix& m); CMatrix operator-(); friend CMatrix operator*(double r,CMatrix& m); private: double Datas[3][3]; };
30
CMatrix::CMatrix(const CMatrix& m) { *this=m; } CMatrix& CMatrix::operator=(CMatrix& m); { for(int i=0;i<3;++i) for(int j=0;j<3;++j) (*this)(i,j)=m(i,j); return *this; }
31
CMatrix& CMatrix::operator*=(double d) { for(int i=0;i<3;++i) for(int j=0;j<3;++j) (*this)(i,j)*=d; return *this; } CMatrix CMatrix::operator*(double r,CMatrix& m) { CNmatrix R(m); return R*=r; }
32
CMatrix& CMatrix::operator+=(CNmatrix& m) { for(int i=0;i<3;++i) for(int j=0;j<3;++j) (*this)(i,j)+=m(i,j); return *this; } CMatrix CMatrix::operator+(CMatrix& m) { CMatrix R(*this); return R+=m; } CMatrix CMatrix::operator-() { return -1*(*this); }
33
Analyse d’une opération CMatrix a,b,c; //Initialisation de a et b… c=2*a+b; c.operator=(operator*(2,a).operator+(b)); CMatrix d=c; CMatrix d(c);
34
La STL Standard Template Library Bibliothèque standard (elle fait partie de la norme C++) qui offre des types de variables et des fonctions utiles Toutes les noms sont précédées de std:: std::string, std::vector, std::list, std::sort…
35
std::string ( ) Chaîne de caractères std::string MonNom=“Vincent”; MonNom.size()==7; MonNom+=“ Lascaux”; MonNom==“Vincent Lascaux”; MonNom[0]==‘V’; MonNom[3]==‘c’;
36
std::vector ( ) Container standard : tableau (acces rapide au n° élément (O(1)), insertion lente (O(n)) ) std::vector Tableau; Tableau.resize(20); Tableau[0]=12; Tableau[1]=42; for(int i=2;i<20;i++) Tableau[i]=i*i; Tableau.reserve(40); for(int i=0;i<20;++i) Tableau.push_back(12);
37
std::list ( ) Une liste chaînée (acces lent au n° élément (O(n)), insertion rapide (O(1)) ) std::list Liste; Liste.push_back(“CNedra“); Liste.push_back(“rulez”); Liste.push_front(“See how “); //Liste = [“See how”, “CNedra”, “rulez”]
38
Itérateurs Permet de parcourir un container Unifie la syntaxe (tous les containers se parcourent de la même façon, que ce soient tableau, liste, arbre ou autre) S’utilise comme un pointeur (le container pointe sur un objet du container).
39
Itérateurs int Somme=0; for(std::vector ::iterator it=Tableau.begin(); it!=Tableau.end();it++) Somme+=*it; int Somme=0; for(std::list ::iterator it=Liste.begin(); it!=Liste.end();it++) Somme+=*it;
40
Les avantages de la STL Ne pas réinventer la roue Eviter des bugs (memory leaks… : la STL ne bug pas) Se simplifier la vie Opérateurs usuels (=, ==, …) Efficacité D’écriture du code Du code
41
Tutoriaux Thinking in C++ STL : aide de tout bon compilo, tutoriaux sur le net, MSDN Google est ton ami
42
Un peu de C
43
Les variables int a; int a,b; int a=2; int a=2, b=3; int Puissance4(int x) { int carre; carre=x*x; return carre*carre; }
44
Quelques exemples //Retourne le double de x int Double(int x) { return 2*x; } Types entiers : char, int, short, long Types réels : float, double Evite d’utiliser le préfixe std:: avec la ligne using namespace std; #include int main() { std::cout << “Hello World\n”; return 0; }
45
Pointeurs Un type de variable stockant l’adresse d’une zone en mémoire Une valeur particulière : NULL int a; int* p; p=&a; *p=2; //a==2 a=3; //*p==3 Surtout utile pour les structures classiques (listes chaînées, arbres binaires…)
46
Contrôle du flux Condition if – else Boucles do-while, while Boucle for
47
Condition Le type d’une condition est bool, il peut prendre les valeurs true ou false. Les nombres entiers peuvent être testée : 0 false, autre nombre true, >=, ==, != &&, ||, ! A==3 && B==2 A==((3 && B)==2) (A==3) && (B==2)
48
if - else int sign(int x) { if(x<0) { return -1; } else { return 1; } int sign(int x) { if(x<0) return -1; else return 1; }
49
Boucles do-while et while int Age; do { cout<<"Quel est votre age ?“<<endl; cin >> Age; }while(Age<=0); while(OnmEcoute()) {Dit_un_mot(); }
50
Boucle for int i; for(i=0;i<10;i++) { cout << “10 fois”; } for(int i=0;i<10;i++) cout << “10 fois”; for(Init; Condition; Step) { Code } Init; while(Condition) {Code; Step;}
51
Transtypage (cast) Changer le type d’une expression double a; (int)a; int a; (double)a; Transtypage implicite double Carre(double a) {return a*a;} Carre(2); //Carre((double)2), Carre(2.)
52
const Problème des références : on ne sait plus si l’argument sera ou non modifié const permet d’indiquer que l’argument ne pourra être modifié Erreur à la compilation si une fonction modifie un argument const (par une affectation, ou l’appel d’une méthode non const)
Présentations similaires
© 2024 SlidePlayer.fr Inc.
All rights reserved.