Vous êtes sur la page 1sur 52

Formation C++

Hello World !
#include <iostream>
/* Commentaire
sur plusieurs lignes */
int main()
{
//Affiche hello world
std::cout << "Hello World !
<< std:endl;
}

Nouveauts de syntaxe en
C++

Surcharge de fonctions, doprateurs


Rfrences
Namespace (non abord)
Fonctions templates (non abord)

Surcharge de fonction
void f(int i) {}
int f(double i) {}
void f(int a,int b) {}
// ERREUR :
// Diffre uniquement par
// le type de retour
double f(int i) {}

Attention aux ambiguts


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 paramtres si proche lun de
lautre !

Oprateurs
Mathmatiques : +, -, *, /, %, ++, -Logiques : &&, ||, !, ==, !=, <, >, <=, >=
Donnes : *, &, ->
Binaire : &, |, ^, ~, <<, >>
Assignation : =, *=, /=, %=, +=, -=, <<=, >>=,
&=, |=, ^=
Tous surchargeables.

Rfrences

Permettent de passer la variable plutt que la


copie.
Evite la recopie de la variable (gain en
rapidit pour de grosses structures).
Permet de simplifier lcritures de fonctions
qui crivent dans une variable.

Rfrence
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

Quest ce quun objet ?


Un type qui regroupe des informations
(membres), et qui offre des moyens de les
traiter (grce des mthodes).
Exemple : objet joueur
Membres :
points de vie
envie de manger
tat (mort ?)

Mthodes :
Attaqu par
Mange

Comment dfinir un objet en


C++
class CJoueur
{
public:
void AttaqueDe(CJoueur& J)
{
Vie -= J.Vie; EnvieManger += 10;
Mort = ((Vie<=0)||(EnvieManger>=100));
}
void Mange() {EnvieManger=0;}
int Vie, EnvieManger; bool Mort;
};

Structure des fichiers dun


projet C++
Header
(.h)

Code
(.cpp)

Objet (.o)

Link

Compilation
Executable
Header
(.h)

Code
(.cpp)

Objet (.o)

Les erreurs

Compilation

Linkage

Syntaxe (erreurs)
Warnings
Fonctions et variables dclares, non
implmentes

Excution

Segfault

Organisation des fichiers


Joueur.h :

Joueur.cpp :

void CJoueur::AttaqueDe(CJoueur& J)
class CJoueur
{
{
Vie -= J.Vie;
public:
EnvieManger += 10;
void AttaqueDe(CJoueur& J);
Mort = ((Vie<=0)||
void Mange();
(EnvieManger>=100));
int Vie, EnvieManger;
}
bool Mort;
};
void CJoueur::Mange()
{ EnvieManger=0; }

Pr compilateur
Joueur.h :
#ifndef JOUEUR_H
#define JOUEUR_H
Class CJoueur
{/* */ };
#endif

Joueur.cpp :
#include Joueur.h
void CJoueur::AttaqueDe(CJoueur& J)

Utilisation de lobjet
CJoueur J;

J.Mort=false;
J.Vie=100;
J.Mange();

CJoueur* p=&J;
(*p).Vie=100;
p->Vie=100;
p->Mange();

Constructeur destructeur

Initialisation des donnes : on veut qu la


cration de la variable notre joueur soit vivant
sans avoir besoin de le dire !

Constructeur : fonction appele la cration


de lobjet (pour linitialisation)
Destructeur : fonction appele la
destruction de lobjet

Constructeur destructeur
class CJoueur
{
public:
CJoueur()
{
Vie=100; EnvieManger=0;
Mort=false;
}
~CJoueur() { }
};

new et delete, cration


dynamique
malloc et free (du C)dobjets
ne peuvent tre utiliss car on a
besoin dappeler le constructeur et le destructeur de
lobjet
new T; retourne un pointeur vers une zone de donne
alloue par lOS pour stocker un objet de type T.
delete p; informe lOS que la mmoire pralablement
alloue par un new nest plus utile.

Toujours autant de new que de delete !


(rgle sans aucune exception !)

Membres privs, publics

Cacher des membres et des proprits


lextrieur
Assurer que les donnes ne seront pas
modifies par lextrieur
Indiquer lutilisateur les membres et
mthodes dont il aura besoin
Conseil : mettre les membres en priv, avec
au besoin des mthodes Get-Set

Membres privs, publics


class CJoueur
{
public:
CJoueur();
~CJoueur();
void AttaqueDe(CJoueur& J);
void Mange();
bool IsDead();
private:
int Vie, EnvieManger;
bool Mort;
};

Drivation

Crer un nouvel objet, plus spcifique,


partir dun objet de base
CJoueur -> CJoueurHumain, CJoueurZerg,
CJoueurProtoss
(CJoueur&)CJoueurHumain
(CJoueurHumain&)CJoueur

Drivation
class CJoueurZerg
: public CJoueur
{
public:
void SayGrrrgg();
};

CJoueurZerg Zergling;
CJoueur J;
Zergling.Mange();
J.AttaqueDe(Zergling);
Zergling.SayGrrrgg();
CJoueur* p=&Zergling;
p->SayGrrrgg(); //Error

Fonctions virtuelles
CJoueurHumain, CJoueurProtoss et
CJoueurZerg ne mangent pas de la mme
faon. Pourtant on veut que tout CJoueur
puisse manger.

Fonctions virtuelles
class CJoueur
{
public:
virtual void Mange()
{
EnvieManger=0;
}
};

class CJoueurZerg
:public CJoueur
{
public:
void Mange()
{
SayGrrrgg();
CJoueur::Mange();
}
};

Fonctions virtuelles
CJoueurZerg Over;
CJoueur J;
CJoueur* P=&Over;
J.Mange();
Over.Mange();
P->Mange();

Fonctions virtuelles pures

On ne sait pas dfinir CJoueur::Mange, on


veut que les classes drives soient
contraintes dimplmenter Mange()
class CJoueur
{
public:
virtual void Mange()=0;
};

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

Fonctions virtuelles pures


class CJoueurHumain
:public CJoueur {};

CJoueur J; //Erreur
CJoueurHumain J; //Erreur

class CCapitaine
:public CJoueurHumain
{
public:
void Mange()
{ /* */ }
};

CCapitaine Capitaine;
CJoueur* P=&Capitaine;
P->Mange(); //OK

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];
};

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;
}

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;
}

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); }

Analyse dune opration


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);

La STL

Standard Template Library


Bibliothque standard (elle fait partie de la
norme C++) qui offre des types de variables
et des fonctions utiles
Toutes les noms sont prcdes de std::

std::string, std::vector, std::list, std::sort

std::string (<string>)

Chane de caractres

std::string MonNom=Vincent;
MonNom.size()==7;
MonNom+= Lascaux;
MonNom==Vincent Lascaux;
MonNom[0]==V; MonNom[3]==c;

std::vector (<vector>)

Container standard : tableau (acces rapide au n


lment (O(1)), insertion lente (O(n)) )

std::vector<int> 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);

std::list (<list>)

Une liste chane (acces lent au n lment


(O(n)), insertion rapide (O(1)) )

std::list<std::string> Liste;
Liste.push_back(CNedra);
Liste.push_back(rulez);
Liste.push_front(See how );
//Liste = [See how, CNedra, rulez]

Itrateurs

Permet de parcourir un container


Unifie la syntaxe (tous les containers se
parcourent de la mme faon, que ce soient
tableau, liste, arbre ou autre)
Sutilise comme un pointeur (le container
pointe sur un objet du container).

Itrateurs
int Somme=0;
for(std::vector<int>::iterator it=Tableau.begin(); it!
=Tableau.end();it++)
Somme+=*it;
int Somme=0;
for(std::list<int>::iterator it=Liste.begin(); it!=Liste.end();it++)
Somme+=*it;

Les avantages de la STL

Ne pas rinventer la roue


Eviter des bugs
(memory leaks : la STL ne bug pas)
Se simplifier la vie
Oprateurs usuels (=, ==, <, >)
Efficacit

Dcriture du code
Du code

Tutoriaux
Thinking in C++
STL : aide de tout bon compilo,
tutoriaux sur le net, MSDN

Google est ton ami

Un peu de C

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;
}

Quelques exemples
#include <iostream>
int main()
{
std::cout << Hello World\n;
return 0;
}

Types entiers :
char, int, short, long

//Retourne le double de x
int Double(int x)
{
return 2*x;
}

Evite dutiliser le prfixe


std:: avec la ligne
using namespace std;

Types rels :
float, double

Pointeurs
Un type de variable stockant ladresse dune
zone en mmoire
Une valeur particulire : NULL
int a;
int* p;
p=&a;
*p=2; //a==2
a=3; //*p==3

Surtout utile pour les


structures classiques
(listes chanes, arbres
binaires)

Contrle du flux

Condition
if else
Boucles do-while, while
Boucle for

Condition
Le type dune condition est bool, il peut prendre les
valeurs true ou false. Les nombres entiers
peuvent tre teste :
0 false, autre nombre true
<, <=, >, >=, ==, !=
&&, ||, !
A==3 && B==2 A==((3 && B)==2)
(A==3) && (B==2)

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;
}

Boucles do-while et while


int Age;
do
{
cout<<"Quel est votre age ?<<endl;
cin >> Age;
}while(Age<=0);
while(OnmEcoute())
{ Dit_un_mot(); }

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;}

Transtypage (cast)
Changer le type dune 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.)

const

Problme des rfrences : on ne sait plus si


largument sera ou non modifi
const permet dindiquer que largument ne
pourra tre modifi
Erreur la compilation si une fonction modifie
un argument const (par une affectation, ou
lappel dune mthode non const)