Chapitre 3 : Du C au C++ A.U.

: 2008/2009
ENSI – II2

1- Introduction
Données Espace de problème Résultats
Chapitre 3
du C à C++ Objets du
monde
Algorithme du monde réel Objets de
(scénario)
réel l’application

Introduction

Historique de C++ Représentation du pb Interprétation humaine
par le programmeur des résultats

C++ versus C & Java

Types de données - définition / déclaration

Les fonctions
Concepts du

Structuration d’un programme C++ Données
langage de Algorithme informatique
programmation de sortie

Chap.3 : UML 2

Class Nom {
--------
--------
}

Algorithme Algorithme
Objets du du monde réel du logiciel
Système
scénario) Objets du (scénario) Objets du
monde d’exploitation
logiciel langage
réel
Langage
De quoi parle-t-on ? Comment ‘logique’ ? Comment ‘physique’ ?
Analyse Conception Code

Modèle physique

Bibliothèques

Modèle conceptuel Modèle logique Modèle physique

Chap.3 : UML 3 Ch. 4 - Du C au C++ 4

2. Historique C++ 3. C++ versus C

1980 au laboratoire AT&T Bell (Stroustrup)
Principal avantage : compatibilité C/C++
Les classes introduites  pré-compilateur de C


• même syntaxe de base
1985 : 1ère version publique


• code C "propre" directement compilable en C++
1995-1997 : révision standard ANSI


• facilité d'intégration de fichiers C++ et C dans un même
• soit pour améliorer les caractéristiques de la norme ANSI, soit pour
préparer le terrain pour les aspects Objets programme  langage hybride)
(

☺ Disponible sur toutes les plateformes. Il est distribué en
Principal inconvénient : compatibilité C/C++
logiciel : • C++ hérite de certains choix ennuyeux du langage C !
• domaine publique (environnement GNU),
• plusieurs sociétés commerciales (Microsoft, Borland, Zortech, …).

Ch. 4 - Du C au C++ 5 Ch. 4 - Du C au C++ 6

Prénom & Nom de l’étudiant :……………................. 1

 Chapitre 3 : Du C au C++ A.U. : 2008/2009
ENSI – II2

Les commentaires
C++ versus Java

....

Ressemblances /* je suis un super commentaire en C
et je étends sur plusieurs lignes
• syntaxe en partie similaire printf("Gros commentaire"); */
• fonctionnalités objet de même nature ....
// je suis un super commentaire C++ sur une ligne

Différences ....
• gestion mémoire (pas de garbage collecting, etc.)
• héritage multiple
// n'appartient qu'au C++
• redéfinition des opérateurs
• templates et STL
• pas de threads dans le langage (mais bibliothèques ad hoc)
• langage compilé (et ... plus rapide !)

Ch. 4 - Du C au C++ 7 Ch. 4 - Du C au C++ 8

4. Types de données Les conversions de type

C++ introduit le type bool pour palier à cette carence
en C. Il s'accompagne des mot-clés true et false.
bool flag=true;

Définition implicite du type, sans avoir à utiliser
typedef :
enum values {1,2,3,4};
enum couleur { rouge=1, noir = 3, blanc =7};
// Ceci est aussi valable pour : union et struct
Ch. 4 - Du C au C++

En C, lorsqu'on souhaitait réaliser la conversion
d'une expression dans un type donné, on utilisait
la syntaxe suivante :
• (type)expression (version C)

Mais cette approche n'est pas cohérente avec le
formalisme fonctionnel

C'est réparé dans le C++ et la même conversion
s'écrit désormais de la manière suivante :
• type(expression) (version C++)

À noter qu'on peut aussi se sécuriser en faisant un
mixage des deux approches :
• (type)(expression) (version mixte)
9 Ch. 4 - Du C au C++ 10

Délocalisation des déclarations Les constantes

C
Le mot-clé const  remplace la directive du préprocesseur #define

int i=5, itmp; • constante typée
int j=2;
...
• même les pointeurs !
for (itmp=0; itmp<10; itmp++) /* quelques constantes classiques */ /* constantes classiques en C */
{ const int PI=12; #define PI 12

C++
#define MOI "Etudiant II2"
j+=itmp; const char MOI[]="Etudiant II2";
#define MAX 100
} const int MAX=100;
int i=5;
....
...
int j=2;
for (int i=0; i<10; i++) int tab[MAX]; /* tableau statique de 100 entiers */
{ char c;
j+=i; // on est sur le i local const char *p='t'; /* pointeur sur un caractere constant */
} char const *q=&c; /* pointeur constant sur un caractere */
const char const *q=MOI; /* pointeur constant sur un caractere constant */
// i vaut 5 !
....
// j vaut 47 !

i variable de parcours temporaire

Ch. 4 - Du C au C++ 11 Ch. 4 - Du C au C++ 12

Prénom & Nom de l’étudiant :……………................. 2

 Chapitre 3 : Du C au C++ A.U. : 2008/2009
ENSI – II2

La référence (alias) Le passage par référence

On peut désormais définir des variables référence, c'est-à-dire des
L'un des défauts les plus irritants en C réside dans l'impossibilité de
variables que l'on peut identifier à d'autres variables. réaliser un passage de paramètres par référence.

Le C++ palie à cette lacune en introduisant (enfin !) le passage de
paramètre par référence.
int n,m ;
int& i=n ; // i variable référence sur n version C version C++
void Swap (int * a, int * b) void Swap (int & a, int & b)
i=m; { {
int tmp=*a; int tmp=a;
*a=*b; a=b;
// Signifie n=m et *b=tmp; b=tmp;
// non que i devient une référence sur m ! } }
.... ....
int i=2, j=4; int i=2, j=4;
Swap (&i, &j); Swap (i, j);
/* i vaut 4 et j vaut 2 */ // i vaut 4 et j vaut 2
.... ....

Ch. 4 - Du C au C++ 13 Ch. 4 - Du C au C++ 14

Typage et prototypage
La surcharge des fonctions
obligatoire des fonctions
La déclaration des arguments se fait toujours à l’intérieur des parenthèses. Le
Elle permet de déclarer puis définir des fonctions ayant un nom identique
typage des fonctions est obligatoires, et possède un sens fort : on ne peut pas mais une signature différente (reprise de la capacité d’ALGOL).
retourner une valeur si la fonction a été déclarée void, et réciproquement, on doit
Attention toutefois : le type de retour ne fait pas partie de la signature. La
retourner une valeur dans le cas contraire. surcharge doit par conséquent préserver le type de retour, elle ne touche
qu'aux paramètres.
Exemple :
Exemple :
void f(int, char*) ; int f(int gros_entier);
int f(double gros_reel);
void f(int i, char* c) ; int f(const char gros_nom[], bool gros_flag);
int f(int i) { …return ‘une valeur entière’ }; Remarques :
…. La surcharge est une forme faible de polymorphisme.
f(); // f ne peut pas être appelée avec des arguments. • elle est surtout utilisée dans les classes, pour définir plusieurs variantes du
constructeur
…. • la surcharge peut se révéler particulièrement intéressante lorsqu'on souhaite éviter
f(…) ; // f peut être appelée avec un nombre quelconque d’arguments. des conversions de types indésirables lors du passage des paramètres.

Ch. 4 - Du C au C++ 15 Ch. 4 - Du C au C++ 16

Les paramètres avec valeur par Les paramètres anonymes

défaut

C++ procure cette facilité en nous autorisant à fournir une valeur par
C++ permet de déclarer des paramètres anonymes,
défaut aux paramètres.
c'est-à-dire des paramètres dont seul le type est
Il existe cependant une restriction importante dans la mise en œuvre
spécifié dans la signature.


des paramètres par défaut:
• À partir du moment où un paramètre possède une valeur par défaut, tous Exemple:
les paramètre suivant doivent également en posséder une.
int main (int argc, char *argv[ ]) int main (int, char **)
En effet, dans le cas contraire, cela pourrait poser { {
des problèmes pour le compilateur : .... ....
int f(int a=0, int b, int c=0); } }
.... En revanche, l'exemple suivant est valide : version C (nommage obligatoire) version C++ (paramètres
i=f(1, 2, 3); // OK void f(double x, double y=0.0, double z=0.0);
j=f(4); // toujours OK ~ f(0, 4, 0) .... anonymes)
k=f(5, 6); f(a); // OK ~ f(a, 0.0, 0.0)
// argh ! ~ f(5, 6, 0) f(a, b); // OK ~ f(a, b, 0.0)
// ou f(0, 5, 6) ? f(a, b, c); // OK ~ f(a, b, c)
// non respect de la contigüité // respect de la contiguïté

Ch. 4 - Du C au C++ 17 Ch. 4 - Du C au C++ 18

Prénom & Nom de l’étudiant :……………................. 3

 Chapitre 3 : Du C au C++ A.U. : 2008/2009
ENSI – II2

Les fonction inline Structuration d’un programme C++

En C, lorsqu'on souhaite factoriser un morceau de code sans pour

autant créer une fonction, on a la possibilité de définir une macro.
Un programme C++ est constitué :
 macro ≠ fonction (exécutables plus volumineux !) • une fonction main (point d’entrée)

Les macros peuvent entraîner des effets de bords désastreux • de classes réparties dans plusieurs fichiers (.cpp/.h) (à la Java)
lorsqu'elles sont mal définies. D'autre part, il n'y a aucun contrôle sur le • (éventuellement) de fonctions et variables globales (.c/.h)(à la C)
type des arguments.

Chaque fichier peut comprendre :

En C++, l'introduction du mot-clé inline va nous permettre d'éviter le
recours aux macros. • un nombre arbitraire de classes (si ça a un sens ...)
 le compilateur se charge de la convertir en macro
Pas de packages, mais des namespaces

On a la sécurité d'une fonction et la rapidité d'une macro.
#define MAX(a,b) (((a)>=(b))? (a) : (b))
 inline int Max (int a, int b) {return (a>=b) ? a : b);}

Ch. 4 - Du C au C++ 19 Ch. 4 - Du C au C++ 20

Les inclusions des bibliothèques

Définition des méthodes

La manière classique d'inclure les fichiers d'en-tête des Un fichier source constituant la déclaration de la classe (interface);
bibliothèques du C était la suivante :
• #include <stdio.h>
#ifndef ID_classe
#define ID_classe
#include <math.h>
#include <string.h>
class A {

En C++, il n'est plus nécessaire de spécifier l'extension sur les ... // déclaration
fichiers d'en-tête standards du C, mais il faut spécifier que c'est };
un fichier de la librairie C en ajoutant le caractère 'c' devant
#endif
• #include <cstdio>
#include <cmath>
Un fichier source correspondant à sa définition (implémentation).

Lorsqu’il s’agit d’une bibliothèque C++, pas d’extension #include "nomclasse.h"
• #include <iostream>


[type] nomclasse::methode1([type]*)
{ ...}

Ch. 4 - Du C au C++ 21 Ch. 4 - Du C au C++ 22

Les espaces de nommage Exemple : espaces de nommage

En C, il était difficile de faire cohabiter plusieurs versions d'une définition/utilisation du namespace

différenciation par les namespaces
même structure de données. namespace A
namespace Version1 {
 Pour éviter le conflit de noms, on était obligé de modifier les noms { class Pile { ... };
typedef unsigned int B; }
de chaque structure .... namespace Version2 {
} class Pile { ... };
.... }

C++ propose un moyen simple de résoudre ce problème : les ....
A::B i;
espaces de nommage. // une variable de type B
void main () {
• Les espaces de nommage permettent de définir une unité cohérente dans Version1::Pile p1;
laquelle regrouper les déclarations des différents objets (types, constantes, Version2::Pile p2;
variables, fonctions). ....
}
• Les identificateurs présents dans l'espace de nommage possèdent alors une
portée qui leur est spécifique.
spécifier l'espace de nommage par défaut à l'aide du mot-clé using.
using namespace A;
B i;

Ch. 4 - Du C au C++ 23 Ch. 4 - Du C au C++ 24

Prénom & Nom de l’étudiant :……………................. 4