Université 7 Novembre à Carthage

Institut National des Sciences Appliquées et de Technologie

Atelier C++
C++
Proposé par :
Mme Selma BATTI ATTIA
batti_selma@yahoo.fr

Section:
RT2
RT2
Année universitaire:
2009//2010
2009
Plan

Présentation de la syntaxe du C++

Principe de base de la POO

Héritage

Généricité

Atelier C++ 2
Syntaxe du C++
Les nouvelles possibilités
Différence entre C et C++

C++ : langage hybride.

C et C++ :

Même compilateur

Même syntaxe
 + de nouvelles possibilités

Atelier C++ 4
Espace de nommage

Définition d’un espace de nommage :
namespace finance {
double var(int i, double j);
int NMC;
}
namespace math {
double var(int i, double j);
int NMC;
double abs(double f);
}

Utilisation de l’espace de nommage :

using namespace finance;
int main() {
finance::var(2, 3.);
math::var(4, 6.0);
var(2, 3.); // équivalent à finance::var(2,3.);
}

Atelier C++ 5
Les entrées / sorties

Possibilité d’utiliser les E/S du C (printf,
scanf, puts, gets, putc, getch….),

Mais aussi : les E/S du <iostream.h>

Sortie : cout

Entrée : cin
 Pas de formatage des données

Exemple :
cout << "Donnez l’élément n° " << i << " : " << endl;
cin >> A;

Atelier C++ 6
 Conversion des paramètres

Conversion des types de paramètres lors de
l’appel d’une fonction :

Exemple :
void main() {
#include<iostream.h>
int i=10, j=6 ;
float r=2.345, p ;
float puissance (float x, int n) {
p=puissance(r,j) ; //puissance (2.345,6)
float res=1 ;
//pas de conversion
for(int i=1 ;i<=n ;i++)
p=puissance(j,i) ; //puissance(6.0, 10)
r*=x ;
//j -> réel
return r ;
p=puissance(j,r) ; //puissance(6.0, 2)
}
//j ->réel ,r ->entier
p=puissance(2,4) ; //puissance (2.0,4)
p=puissance(2.5,4.3) ; //puissance(2.5,4)
}

Atelier C++ 7
 Les arguments par défaut
void f1(int n=3) {
void main() {
//par défaut
char a=’z’ ;
//le paramètre n vaut 3 si jamais
//il est omis lors de l’appel à f1
int i=2 ;
… flaot j=5.6 ;
… f1(i) ; //f1(2), le paramètre n vaut 2,
} //la valeur par défaut est ignorée
f1() ; // n prend la valeur par défaut 3, f1(3)
void f2(int n, float x=2.34) { f2(i, j) ; //f2(2, 5.6) ; 2.34 est ignorée
… f2(i) ; //f2(2, 2.34)
… f2() ; //interdit
} f3(a, i, j) ; //f3(‘z’, 2, 5.6)
f3(a, i) ; //f3(‘z’, 2, 2.34)
void f3(char c, int n=3, float x=2.34) { f3(a) ; //f3(‘z’, 3, 2.34)
… f3() ; // non
} }

Les paramètres ayant une valeur par défaut doivent être

placés en fin de liste
Atelier C++ 8
 Surcharge des noms des fonctions
void test (int n=0, float x=2.3) {
void f(int x, int y) { //fct n°1
… …
} }
void test (float x=4.5, int n=1) {
void f(int x, char y) { //fct n°2
… …
} }
void main() {
void f(int x, int y, int z) { int i=5 ; float r=6.7 ;
… test(i,r) ; //fct n°1 n=5,x=6.7
} test(r,i) ; // fct n°2 x=6.7,n=5
test(i) ; // fct n°1 n=5,x=2.3 (par défaut)
void main() { test(r) ; // fct n°2 x=4.5,n=1(par défaut)
test() ; //appel ambiguë, rejeté par le comp.
f(1,2) ; //appel de f(int, int)
test(i,i) ; //appel ambiguë
f(1,’b’) ; //appel de f(int, char) //rejeté par le compilateur
f(1,2,3) ; //appel de f(int, int, int) test(r,r) ; //appel ambiguë
} //rejeté par le compilateur
}

Atelier C++ 9
Allocation dynamique

Pour allouer ou libérer de la mémoire
dynamiquement, l’équivalent en C++ des
fonctions malloc et free, sont les opérateurs
new et delete.

Exemple :
Pour un tableau d’entiers :
int *tab=new int [5] ; //alloue un tableau de 5 entiers
delete [] tab ; //libère la mémoire allouée
//pour le tableau

Atelier C++ 10
Notion de référence

Exemple :
int v=10 ;
int i ;
int *p=&v ; //p est un pointeur sur v
int &r=v ; //r est une référence sur v
*p=12 ; //v=12, r=12 (r et v occupent
//la même adresse mémoire)
i=r ; //i=12

Atelier C++ 11
 Passage de paramètres
void permut_v(int a, int b) void permut_a(int *a, int *b) void permut_r(int &a, int &b)
{ { {
int x=a ; int x=*a ; int x=a ;
a=b; *a=*b; a=b;
b=x; *b=x; b=x;
} } }

void main() { void main() { void main() {

int i=5,j=3 ; int i=5,j=3 ; int i=5,j=3 ;
permut_v(i,j) ;
cout << " i:"<<i<<endl; permut_a(&i,&j) ; permut_r(i,j) ;
cout << " j:"<<j<<endl; cout << " i:"<<i<<endl; cout << " i:"<<i<<endl;
} cout << " j:"<<j<<endl; cout << " j:"<<j<<endl;
} }

// Résultat : // Résultat : // Résultat :

// i : 5 // i : 3 // i : 3
// j : 3 // j : 5 // j : 5

Atelier C++ 12
Les constantes
const i=10 ;
int *p1=&i ; //erreur car la valeur de i peut être modifiée
//à travers le pointeur p1,
//on pourrait par exemple
//écrire *p1=100 !!
//ce qui modifierait la valeur de i
const int *p2=&i ; //oui, pour déclarer un pointeur
//sur une constante, il faut que le pointeur
//soit de type const int *
*p2=100 ; //erreur car p2 est un pointeur constant
int j=20 ;
p2=&j ; //oui
j= 30 ; //erreur
const int *const p3 =&i; //p3 pointe sur un entier constant mais il est
//lui-même un pointeur constant !!
p3=&i ; //erreur, car p3 ne peut pas être modifié

Atelier C++ 13
Les variables statiques
int g=0; //g est une variable globale

void incrementation (){

int a=0; //variable locale à cette fonction
static int s=0; //variable locale statique
a++;
s++;
g++;
}

void main() {
incrementation(); //a=1, s=1, g=1
incrementation(); //a=1, s=2, g=2
g++; //g=3
a++; //erreur
s++; //erreur
}

Atelier C++ 14