1. Présentation générale - I Learn

1. Présentation générale 3
1.1 Historique: 3
1.2 Caractéristiques : 3
1.3 Objectifs atteints : 3
1.4 Remarque 3
1.5 Bibliographie 4

2. Les extensions de C (non objets) 5

2.1 Les commentaires 5
2.2 Conversions explicites 5
2.3 Utilisation des types enum, struct et union 5
2.4 Déclaration des variables 5
2.5 Fonction inline 6
2.6 Paramètres optionnels avec valeur par défaut 6
2.7 Surcharge des noms de fonctions 6
2.8 Opérateurs (Objets) de sortie et d'entrée: > 7
2.9 Opérateurs : new et delete 7
2.10 fonction de gestion d'erreur d'allocation 8
2.11 Adressage par réference & 8
2.12 Les fonctions génériques (template) 9

3. Incompatibilités entre C et C++ 10

3.1 Entête de fonctions 10
3.2 Prototypes de fonctions 10
3.3 fonction sans argument 10
3.4 fonction sans valeur de retour 10
3.5 le type void * 10
3.6 Symbole de type const. 10















Langage C++
































Pierre Bodin

Présentation générale


1 Historique:

C++ a été développé vers 1980 par Bjarne Stroustup (Bell Labs, AT & T )
Travail collectif avec pour objectifs:

Etre le plus compatible possible avec C


2

Le langage C++ se présente presque comme un sur-ensemble du langage C ANSI.
Les programmes C sont compilables par un compilateur C++.


Le langage C++ contient des (améliorations) caractéristiques nouvelles par
rapport au C qui ne sont pas spécifiquement objet.
Le langage C++ offre la possibilité de programmation par objets.
Rien n'impose au programmeur de programmer en utilisant les concepts de la
POO.

3 Objectifs atteints :

C++ conserve les aspects positifs de C:
Portabilité, Concision, Efficacité, Bas niveau de langage
Programmation modulaire,


Déjà un peu réalisé avec le C ANSI



4 Remarque

C++ reste un langage relativement complexe.

5 Bibliographie


Delannoy Claude Programmer en langage C++ (248 F.) Ed.
Eyrolles

Delannoy Claude Apprendre le C++ sous Turbo/Borland C++ (250 F.) Ed.
Eyrolles

Delannoy Claude Exercices en langage C++. Programmation orientée objets Ed.
Eyrolles

Leblanc Gérard Turbo/Borland C++ (236 F.) (technique BIOS .... ) Ed.
Eyrolles

O'Reilley Cd, Oualline Steve La programmation C++ par la pratique (255 F.)
(exemples)

Meyer Jean Jacques Borland C++ TurboC++ 3.0/3.1 pour Windows Ed. Dunod Tech

Weiskamp, Heiney K. L., Flamig B. Object Oriented Programming with Turbo
C++
Ed. Wiley

Borland C++ 3.0 Guide du programmeur Ed Borland

Petzold Charles Programmer sous Windows 3.1 Ed. Microsoft Press.

B Stroustup. Le langage C++ 2ième édition Ed. Addison-Wesley

Lipman S.B L'essentiel du C++ 2ième édition Ed. Addison-Wesley

Meyer B. Conception et programmation par objets pour du logiciel de qualité
Ed. InterEditions

Charbonnel Jacquelin Le langage C, les finesses d'un langage redoutable
Charbonnel Jacquelin Langage C++, les spécifications du standard ANSI/ISO
expliquées (260 F.)
InterEditions (2ième édition).

Clavel G., Mirouze N., Pichon E., Soukal M. Java la synthèse Ed.
InterEditions
Fontaine Alain Bernard La bibliothèque standard du C++ Ed. InterEditions


Les extensions de C (non objets)


1 Les commentaires

|C |C ++ |
|/* commentaire en C */ |// commentaire en C++ et C ANSI |
| | |
| |/* com. toujours acceptable |
| |en C++ */ |

Intérêts :









Quelques conseils sur les commentaires.

2

Nouvelle syntaxe : (le cast est toujours valable)

|C |C ++ |
|int i = 1; |int i = 1; |
|float x = 3.2; |float x = 3.2; |
| | |
|i = (int) x; |i = int(x); x = float(i); |
|x = (float) i; |Point p = Point(1.0, 2.0) ; |
| |(initialisation par l'appel d'une |
| |fonction constructure) |
| | |
| |i = (int) x; // toujours |
| |valable |
| |x = (float) i; |


Mais (char *)ptr; et non pas char *(ptr);





3

Le nom d'une énumération , d'une structure ou d'une union est un type.
|C |C ++ |
|enum E { ...... }; |enum E { ...... }; |
|struct S { ...... }; |struct S { ...... }; |
|union U { ...... }; |union U { ...... }; |
| | |
|enum E e; |E e; |
|struct S s, *ptr; |S s, *ptr; |
|Union U u; |struct S s1; // toujours valable |
| |U u; |
| | |
|Ptr = malloc( sizeof( struct S) );|Ptr = malloc( sizeof( S ) ); |

|C |C ++ |
|typedef enum { False, True } BOOL;|enum BOOL { False, True }; |
| | |
| |BOOL ouvert; |
|BOOL ouvert ; | |

écriture plus simple et plus naturelle




4

On peut déclarer des variables en tout endroit dans une bloc et non plus
uniquement avant la première instruction du bloc.

Dans un bloc, la variable n'est connue qu'à partir de sa définition.
jusqu'à la fin du bloc : la portée d'un identificateur commence à la partie
suivant sa définition jusqu'à la fin du bloc.



int i; // déclaration de variables
i = 2; // instruction
int j; // autre déclaration de variable
j = i;
...
for( int k = 0; k < 5; k++ ) {
...
}
// valeur de k ici ? (dépend des compilateurs !)
}

Possibilité de créer des blocs en tout point à l'intérieur d'un bloc.

5

Fonction expansée (développée) à chaque appel
Taille plus grande, exécution plus rapide, compromis à chercher.




int j = carre( 2 ); // j vaut 4

Ressemble à une macro C mais faire très attention dans la macro (effet de
bord) !

|C |C ++ |
|#define ABS(x) (x)>0 ? (x) : (-x) |inline int abs( int x ) |
| |{ return x>0 ? x : -x ;} |
| | |
|int i, k = -1; |int i, k = -1; |
| | |
|i = ABS( k ) ; // i vaut 1; |I = abs( k ) ; // i vaut 1; |

En C on utilise des macros expansés par le préprocesseur.
Inconvénient : parfois difficile à écrire, pas de contrôle de type, mise au
point difficile.
Attention : mettre des parenthèses dans la macro. exemple : (ABS( a | b )







6


void f ( float, int = 2, char * = " ") ;
int g ( int *ptr = null , char ); // illégal

f ( 1.23, 10, " bonjour "); // appel classique
f ( 1.23, 10 ); // => f ( 1.23, 10, " ");
f ( 1.23 ); // => f ( 1.23, 2, " ");
f ( ) // illégal
f ( 1.23, , " bonjour "); // => illégal
f ( 1.23, " bonjour " ); // => illégal

La définition des valeurs par défaut peut se faire soit dans le prototype
de la fonction, soit dans l'entête de sa définition, mais pas dans les 2 à
la fois. Mettre de préférence dans le prototype.
Les valeurs par défaut sont placées à partir de la fin de la liste des
paramètres.

Si le concepteur de la fonction a défini des valeurs implicites,
l'utilisateur ne peut plus les modifier.





7


Surcharge ou encore surdéfinition : plusieurs fonctions ont le même nom.

Les fonctions doivent être différentiables par leur signature (la nature et
le nombre de leurs paramètres )

int max(int, int );
int max( const int * list );

// mais erreur car même signature et valeur retournée différente
char * cherche( char *);
int cherche( char * );

La résolution d'un appel de fonction surchargée est une opération assez
difficile pour le compilateur













8


Ces opérateurs sont en réalité des opérateurs relevant des possibilités
OBJET du langage.
Ils sont introduits ici pour pouvoir les utiliser tout de suite sans
attendre tous les développements nécessaires (et longs) à leur explication.

#include
#include
#include // pour pouvoir utiliser les flots cin et cout

int main()
{
int n; float x;

// méthode traditionnelle avec printf et scanf
printf( " entrez un entier et un flotant : ");
scanf( "%d %f", &n, &x );
printf( " le produit de %5d par %10.2f est : %10.2f\n", n, x, n * x
);

// méthode C++ avec les flots cin et cout
cout > n >> x ;
cout