Cours avec exercices corrigés pour débuter en C++

Programme :

•Historique du langage

•Typologie des langages informatiques, comparaison avec Matlab, JAVA

•Mots-clés et opérateurs du C++ : les ajouts au C

•Types de base C et ajouts du C++

•Les « littéraux » en C et C++

•Le type bool en C++

•Les identifieurs (symboles) en C/C++

•Comparaison entre les notions de « définition » et de « déclaration »

•La définition des variables, leur portée, la résolution de leur portée

•Le préprocesseur C/C++, l’organisation modulaire des fichiers

•La définition et déclaration des tableaux, des constantes et des chaînes de caractères

•Les opérateurs logiques et mathématiques

•Les structures de contrôle (if, while, for, do, switch)

•Les énumérations

•La conversion des types en C, et en C++

•Fonctions et procédures en C et C++

•En C++ : fonction « en ligne », arguments par défaut et surcharge des noms de fonctions

•Les pointeurs, indirection, lien avec les tableaux, leur « arithmétique »

•Les types complexes (struct, union). Les alias de types

•Les références

•Le passage des arguments en C, en C++. Les valeurs de retour des fonctions

•Allocation dynamique de la mémoire et sa gestion

Le langage C++ : historique (1)

D’après « Langage C++, le standard ANSI/ISO expliqué, J. Charbonnel, Dunod, 1997 » :

En 1980, le langage C est le plus utilisé dans le monde. Il allie flexibilité, efficacité, disponibilité et portabilité.

Un étudiant de l’Université de Cambridge, Bjarne Stroustrup décide d’incorporer la notion de classes au C. Il s’agit d’abord d’un préprocesseur utilisé en amont du compilateur : C with classes. ^[1]

Le nouveau langage incorpore des influences positives venant de Simula, Pascal, Modula- 2, Ada, Smalltalk, Algol.

En 1983, Stroustrup décide d’implémenter une version à l’aide des technologies traditionnelles des compilateurs. Il s’appelle Cfront, il génère du C pour obtenir un maximum de portabilité, mais ce n’est pas un préprocesseur. ^[2]

Page 2

Notes :

[1]  : un préprocesseur génère du code source (texte) à partir du code source (texte) de l’utilisateur. Le langage C/C++ dispose d’un préprocesseur très puissant (c’est lui qui comprend les directives #include, #define, #if, etc.).

[2]  : le processus d’obtention des exécutables est alors :

               code source C++   =>   préprocesseur C   =>   Cfront   =>   compilateur C =>   exécutable

Le langage C++ : historique (2)

La première version officielle du langage est publiée par les laboratoires Bell Labs d’AT&T en 1986, elle est numérotée 1.0. ^[1]

Elle est suivie des versions 1.1 et 1.2.

La version 2.0 sort en juin 1989, elle apporte l’héritage multiple, les classes abstraites, les méthodes statiques, les méthodes constantes.

La version 2.1 corrige certains bugs. La version 3.0 ajoute la notion de templates et la version 4.0 la gestion des exceptions. ^[2]

A partir de cette date, le nombre d’utilisateurs explose. Plusieurs sociétés proposent des compilateurs C++. L’implémentation libre G++ de GNU apparaît.

Page 3

Notes :

[1]  : Bjarne Stroustrup, The C++ programming language, 1986 – Addison-Wesley.

[2]  : M.A. Ellis et Bjarne Stroustrup, The annotated C++ Reference Manual, 1990 – Addison-Wesley

Le langage C++ : historique (3)

Dès 1988, il apparaît nécessaire de normaliser le langage.

Avec l’appui de HP, AT&T, DEC et IBM, Bjarne Stroustrup s’y attelle. La première réunion du comité de normalisation a lieu en décembre 1989 à Washington.

En 1998, le travail est terminé et approuvé :

« ISO/IEC International Standard 14882 – Programming language C++, 1998 »

En 2003, une nouvelle version de la norme :

« ISO/IEC International Standard 14882 – Programming language C++, 2003 »

Page 4

Recensement des utilisateurs dans le monde :

1979  : 1

1980  : 16

1981  : 38

1983 : 85

1985 : 500

1987 : 4 000

1989 : 50 000

1991 : 400 000

Par la suite, le décompte devient impossible (en 1992, Borland fait état de 500 000 compilateurs en service).

Typologie des langages informatiques (1)

                                                     Figé                     Dynamique

Page 5

Explication :

La grande différence entre les langages compilés et les langages interprétés vient de la capacité ou non à étendre le code durant l’exécution du programme. Le principe d’ajouter du code durant l’exécution n’est pas difficile à comprendre : il suffit de penser à une fonction qui crée d’autres fonctions quand on l’exécute.

Typologie des langages : typage

On peut aussi distinguer les langages selon leur façon de gérer le typage des variables :

Typage statique

Les types sont fixés à la compilation.

Déclaration de toutes les variables et de leur type avant leur utilisation.

Typage dynamique

Un langage dans lequel les types sont découverts à l’exécution.

Détermination du type d’une variable la première fois qu’on lui assigne une valeur.

Page 6

Précisions :

En règle générale : les langages interprétés sont à typage dynamique, alors que les langages compilés sont à typage statique.

Typologie des langages informatiques (2)

Page 7

Précisions :

-Fortran (jusqu’à F77) : pas d’allocation dynamique

-Lisp et Smalltalk sont des langages interprétés, tout est dynamique et du code peut générer du code

-Matlab et Python sont aussi interprétés, mais il n’est pas standard de rajouter du code durant l’exécution (définition de fonctions « lambda » en Python)

-Fortran 90, C et C++ sont des langages compilés où l’allocation dynamique est possible

-En Java, l’allocation dynamique est la règle générale, sauf pour les types de base

L’exemple de Matlab (1)

Au lancement du programme, l’espace mémoire est vide :

Page 8

L’exemple de Matlab (2)

Puis on peut ajouter des variables, elles sont allouées dynamiquement et l’espace de travail se remplit :

On peut détruire des variables avec la commande « clear ».

Page 9

L’exemple de Matlab (3)

On peut créer un fichier qui contient le code d’une nouvelle fonction et l’utiliser immédiatement :

Page 10

Un extrait de la documentation MATLAB :

What Happens When You Call a Function

When you call a function M-file from either the command line or from within another M-file, MATLAB parses the function into pseudocode and stores it in memory. This prevents MATLAB from having to reparse a function each time you call it during a session. The pseudocode remains in memory until you clear it using the clear function, or until you quit MATLAB.

L’exemple de Matlab (4)

On peut écrire une fonction qui fabrique cette nouvelle fonction, mais MATLAB n’est pas un pur langage interprété et on ne peut utiliser tout de suite la nouvelle fonction :

Précision :

Comme le montre la trace, il faut appeler deux fois la fonction « create_function ». Le premier appel retourne une erreur, mais crée le fichier « essai.m », ce qui permet au deuxième appel de fonctionner.

Dans le même ordre d’idées, il ne semble pas possible de créer une fonction en utilisant la console de commande (on obtient un message du genre « ??? Strings passed to EVAL cannot contain function declarations »).

Typologie des langages : passage des paramètres

Une chose importante à connaître est le mode utilisé par chaque langage pour passer les paramètres aux fonctions et procédures.

Passage par valeur

La fonction ne connaît pas la variable de départ, seulement sa valeur.

La variable ne peut être modifiée par la fonction/procédure.

Comment alors écrire une fonction qui modifie des variables ? ^[1]

Passage par référence

La variable peut être modifiée par la fonction/procédure.

Comment alors distinguer entre celles qui modifient la variable et les autres ? ^[2]

Page 12

Précisions :

Une « procédure » est une fonction qui ne retourne pas de valeur. Certains langages font cette distinction, mais pas le C/C++.

[1]   réponse du C/C++ : en passant la valeur de l’adresse de la variable (c’est-à-dire ce que l’on appelle un pointeur).

[2]   réponse du C/C++ : en utilisant le mot-clé const pour signifier que la référence ne sera pas modifiée par la fonction.

Passage des paramètres : MATLAB

MATLAB utilise le passage par valeur :

Page 13

Un extrait de la documentation MATLAB :

How MATLAB Passes Function Arguments

From the programmer's perspective, MATLAB appears to pass all function arguments by value. Actually, however, MATLAB passes by value only those arguments that a function modifies. If a function does not alter an argument but simply uses it in a computation, MATLAB passes the argument by reference to optimize memory use.

Passage des paramètres : langage C

Le C utilise aussi le passage par valeur :

#include <stdio.h>

void f(double y) { y = 2 * y;

} void g(double *y) {

*y = 2 * *y;

} void main()

{ double x = 5;

printf("Valeur de x = %g\n", x);

f(x);

printf("Valeur de x = %g\n", x);

g(&x);

printf("Valeur de x = %g\n", x);

}

Page 14

Explications :

-     La première fonction « f » reçoit la valeur de la variable, elle copie cette valeur dans une variable qui est locale à la fonction « f ». C’est cette valeur locale qui est multipliée par 2. Cela ne sert à rien, car la portée de cette variable est locale, justement.

-     La deuxième fonction « g », reçoit aussi une valeur, mais c’est une adresse. La fonction utilise l’opérateur « * » qui signifie « la variable se trouvant à cette adresse » pour travailler sur la variable et modifier efficacement la valeur.

Nous verrons que la passage par référence du C++ simplifie grandement les choses.

Exemple : Exple_01_passageC

Passage des paramètres : JAVA

En JAVA, ça dépend. Les types de base sont passés par valeurs :

public class passage

{ static void f(double y) {

y = 2 * y;

}

public static void main(String[] args) { double x = 5.0;

.println("Valeur de x " + x);

f(x);

.println("Valeur de x " + x); }

};

Mais tous les autres types sont passés en référence.

Page 15

Précisions :

Il existe en JAVA la notion de « classes d’enveloppe des types de base » ou wrappers.

Par exemple « Double » est la classe enveloppe du type primitif « double ». Quoiqu’il en soit, après 2h de recherche, je n’ai pas trouvé comment réaliser une fonction qui modifie la valeur d’une variable simple.

Si quelqu’un veut bien chercher …

Passage des paramètres : récapitulation

Page 16

Conclusion :

Le C++ permet à l’utilisateur de choisir entre le passage par valeur et le passage par référence. Choix que ne permet aucun autre langage de la liste.

Le langage C++ : récapitulation

Le langage C++ est un langage compilé :

? le code est figé et ne peut être étendu durant l’exécution

          ? en contre-   partie, gain énorme en performances

Les données peuvent être statiques ou allouées dynamiquement selon les choix du programmeur :

? statiques : gain de performance

? allouées dynamiquement : gain de place mémoire

Le langage C++ permet au programmeur de choisir entre le passage par valeur ou le passage par référence.

Page 17

Précisions :

De tous les langages, le C++ offre le plus de possibilités au programmeur. A part les contraintes liées à tout langage compilé, il n’impose aucun choix préconçu.

C/C++ : premier programme (1)

// Une fonction

// aimable en C++#include <iostream>

void main()

{ std::cout << "Hello" << std::endl;

}

-  créer deux projets Exple_02_mainC et Exple_03_mainCPP

-  ces projets comprennent chacun un programme principal

-  « main.c » pour le code C

-  « » pour le code C++

C/C++ : premier programme (2)

Tout ce qui était possible en C, l'est aussi en C++ :

/* les commentaires a la mode C */

#include <iostream>

#include <cstdio>                // les librairies C

int main()

{ std::cout << "Hello" << std::endl;

printf ("Hello bis\n");    // les instructions Creturn0;

}

Page 19

Exercice :

- poursuivre le code des exemples Exple_02_mainC et Exple_03_mainCPP en créant un nouveau projet : Exple_04_mainCPP2

C : mots-clés

Le langage C dispose de 33 mot-clés :

while

Auxquels on ajoute :

•  des opérateurs unaires :   – ~   !   * &   sizeof +   ++   ––

•  des opérateurs binaires :   .  ->  * /  %   +   – <<  >>  <  >  

<= >=   ==   !=   &   |   ^   &&   ||

•  des « ponctuations » :     [ ]   ( )   { }   ,   :   =   ;   ...   #

Page 20

C++ : nouveaux mots-clés

Le C++ introduit 41 nouveaux mot-clés qui s’ajoutent aux 33 du langage C :

xor_eq(^=)

=> Incompatibilités inévitables avec le langage C

char *friend = "Jeremie" ; // illegalvoid delete(void *ptr); // illegalint new;     // illegal

Page 21

Sur l’exemple de la planche, voici les erreurs produites par VisualC++ 6.0 :

warning C4518: 'friend ' : storage-class or type specifier(s) unexpected here; ignored error C2059: syntax error : '=' warning C4091: '' : ignored on left of 'void' when no variable is declared error C2143: syntax error : missing ';' before 'delete' error C2143: syntax error : missing ';' before 'delete' warning C4091: '' : ignored on left of 'int' when no variable is declared error C2143: syntax error : missing ';' before 'new' error C2143: syntax error : missing ';' before 'new'

D’où l’intérêt d’un bon éditeur (avec au minimum coloration syntaxique) pour faire apparaître ces motsclés.

Les mots-clés du langage C : asm auto break case char const continue default do double else enum extern float for goto if int long register return short signed sizeof static struct switch typedef union unsigned void volatile while

Exemple : Exple_05_motscles

C/C++ : opérateurs (1)

Page 22

Précisions :

•  L’opérateur :: permet de lever les ambiguïtés entre des variables de même nom

•  Le choix de l’opérateur de sélection dépend de l’entité à laquelle il s’applique

•  Il existe des opérateurs d’incrémentation et de décrémentation préfixés

C/C++ : opérateurs (2)

Page 23

Précisions :

•  Les opérateurs new et delete ont une grande importance en C++

•  Les opérateurs * et & sont inverses l’un de l’autre

•  L’opérateur de négation unaire est différent de l’opérateur de négation binaire

C/C++ : opérateurs (3)

Page 24

Précisions :

•  L’opérateur sizeof retourne une valeur du type size_t

•  L’opérateur typeid retourne une valeur du type const type_info&

•  Ne pas confondre la multiplication * et l’opérateur d’indirection *

C/C++ : opérateurs (4)

Page 25

Précisions :

• Les opérateurs < et > retournent un booléen (bool)

C/C++ : opérateurs (5)

Page 26

Précisions :

•  Les opérateurs de comparaison retournent un booléen (bool)

•  Ne pas confondre les opérateurs logiques et ceux qui travaillent sur des champs de bits

C/C++ : opérateurs (6)

Page 27

Précisions :

• L’opérateur conditionnel ternaire permet d’écrire des expressions plus concises qu’avec if-else

C/C++ : opérateurs (7)

Page 28

Précisions :

•  L’opérateur virgule sert à évaluer deux ou plusieurs expressions, là où une seule est autorisée

•  Il ne faut pas le confondre avec le signe de ponctuation virgule

Exercice : trouver les N erreurs de ce programme (Exple_06_Nerreurs) struct MaStruct

{

MaStruct *this;    // pointeur sur moi-même

MaStruct *friend;  // pointeur sur le suivant

};

typedef MaStruct* try; void using(MaStruct* s)  // fonction récursive

{ using(s->this); using(s->friend);

} void inline(MaStruct* new)  // Affichage

{

MaStruct *public = new; cout << "INLINE\n" << public;

}

C : types de base

Types de base : char, int, float, double

+ des modificateurs optionnels : long, short, unsigned, signed

long n = 999999L;

Page 29

Important :

En C, on met toutes les déclarations de variables au début des fonctions. On ne peut mélanger déclarations et affectations dans n’importe quel ordre comme dans l’exemple ci-dessus. En C++, c’est possible, les variables peuvent être déclarées n’importe où dans le code.

Précisions :

Par défaut, une constante :

-  entière : est de type « int »

-  réelle : est de type « double » (ainsi l’instruction « x1 = 0.45; » avec x1 nombre réel simple précision peut occasionner un warning '=' : truncation from 'const double' to 'float‘).

Les lettres « L », « U » et « F » permettent de préciser le caractère « long », « unsigned » ou « float » d’une constante..

A ces types de base, le C++ ajoute deux autres types de base : « bool » et « wchar_t ».

Il est bien évident, que (contrairement au Fortran) les noms des variables et des constantes sont complétement libres. Certaines lettres ne sont pas considérées par défaut comme entiers ou réels !

La différence entre signés et non signés tient à la plage de valeur que peuvent représenter des variables de ce type. Par exemple un entier signé 16 bits peut représenter des nombres entre -32768 et +32767, alors que non signé la plage de valeur est de 0 à 65535.

Exemple : Exple_07_typesbaseC

C++ : types de base

Précisions :

Nous verrons le type « bool » en détail plus loin.

En ce qui concerne le type « wchar_t », il s’agit d’une représentation des caractères généralement sur 16 bits ce qui permet d’utiliser le codage Unicode des caractères à la place du codage ASCII (8 bits). Ce codage étendu est nécessaire pour représenter des alphabets non latins et envisager ce que l’on appelle l’internationalisation des programmes.

Il faut utiliser la lettre « L » en préfixe pour spécifier qu’un caractère est étendu (= wide) :

wchar_t  w1 = 'x'; wchar_t  w2 = '\t'; wchar_t  w3 = L'yz';  wchar_t  w4 = L'\x77\x34'; 

Exemple : Exple_08_typesbaseCPP

Note importante :

Le C et le C++ n’ont pas de type de base pour représenter les chaînes de caractères (comme en JAVA le type « string »). Les chaînes de caractères sont représentées par des tableaux de caractères. Il existe cependant dans la librairie standard de C++ une classe std::string, mais il ne s’agit pas d’un type de base, faisant partie du noyau du langage.

C/C++ : implémentation des types de base

La norme ne fixe pas l’implémentation des types de base par les compilateurs, contrairement à JAVA. Il peut donc exister des différences entre les compilateurs.

Ce que la norme impose :

•  la taille de char, unsigned char et signed char est de 1 octet

•  la taille de wchar_t (signed / unsigned) est supérieure ou égale à celle de char

•  la taille de  short int (signed / unsigned) est supérieure ou égale à celle de char

•  la taille de int (signed / unsigned) est supérieure ou égale à celle de short int

•  la taille de long int (signed / unsigned) est supérieure ou égale à celle de int

•  la taille de double est supérieure ou égale à celle de float

•  la taille de long double est supérieure ou égale à celle de double

Page 31

Précisions :

En principe, le type « int » est de la taille du type natif du processeur utilisé, 32 bits par exemple sur une architecture 32 bits.

Exercice :

-  créer un projet Exple_09_sizeof

-  dans le programme principal, utiliser la méthode « sizeof » qui retourne la taille d’une variable (d’un objet ou d’un type) pour afficher la taille de plusieurs types de base. Par exemple :

std::cout << sizeof(int) << std::endl;

Reporter ici les tailles :

signed int =

C/C++ : littéraux caractères

Les littéraux caractères se notent avec des guillemets simples (« quote » en anglais). Eventuellement précédés de « L » pour les caractères longs :

char    c1 = 'a';

wchar_t c2 = L'b';

Les caractères inaccessibles au clavier peuvent être fournis grâce à leur code en base 16 (précédé de \x) ou en base 8 (simplement précédé de \) :

char c1 = 'a';

char c2 = L'a';toutes représentationschar c3 = '\141';du caractère‘a’char c4 = '\x61';

Il existe un certain nombre de séquences d’échappement reconnues par le langage C/C++ :

\’ \"   \?   \\

\a   \b \f   \n   \r   \t   \v

Page 32

Liste des séquences d’échappement :

Pour représenter les guillemets simples (’) et le backslash (\), la séquence d’échappement correspondante est obligatoire  (\’) et (\\) respectivement.

Exercice (facultatif) :

-  créer un projet Exple_10_litteraux

-  s’exercer à définir quelques exemples de littéraux caractères et les afficher avec std::cout <<

C/C++ : littéraux entiers

Les littéraux entiers sont des nombres, sans exposant, ni virgule.

•  en base décimale (10), les nombres entiers ne peuvent commencer par « 0 »

•  en base octale (8), ils doivent commencer par « 0 »

•  en base hexadécimale (16), ils doivent commencer par « 0x » ou « 0X »

•  les nombres peuvent être précédés d’un opérateur unaire (« - » ou « + »)

unsigned int a1 = 67;

toutes représentations

unsigned int a2 = 0103; du nombre‘67’

unsigned int a3 = 0x43;

Rappel : les suffixes « U » et « L », en minuscules ou majuscules, seuls ou ensembles peuvent être employés pour préciser si l’entier est non signé ou s’il est long.

Page 33

Exemples :

Quelques exemples variés de constantes entières :

long h1 = 12345678L; long h2 = 12345678l; unsigned long h3 = 12345678U; unsigned long h4 = 12345678u; unsigned long h5 = 12345678UL; unsigned long h6 = 12345678ul; unsigned long h7 = 12345678LU; unsigned long h8 = 12345678lu;

Exercice (facultatif) :

-  poursuivre le projet précédent Exple_10_litteraux

-  s’exercer à définir quelques exemples de littéraux entiers et les afficher avec std::cout <<

C/C++ : littéraux réels

Les littéraux flottants sont des nombres réels avec un exposant et/ou une virgule. Les nombres peuvent être précédés d’un signe, opérateur unaire (« - » ou « + ») :

float x1, x2; float x3 = 0.1F;

double y; long double z;

x1 =  0.45; x2 = -3.5e12F; y  =  0.45; z  =  0.99e-2L; 

Rappel : les suffixes « F » et « L », en minuscules ou majuscules, permettent de préciser respectivement que la constante est simple précision (« float ») ou quadruple precision (« long double »). S’il n’y a aucun suffixe, il s’agit d’une constante double précision (« double »).

Page 34

Exercice (facultatif) :

-  poursuivre le projet précédent Exple_10_litteraux

-  s’exercer à définir quelques exemples de littéraux réels et les afficher avec std::cout <<

C/C++ : littéraux chaînes de caractères

En C et C++, les littéraux chaînes de caractères sont définis comme des tableaux de n caractères du type « const char ».

En C et C++, les chaînes de caractères se terminent par le caractère zéro (\0) qui compte dans le nombre de caractères. C’est ce que l’on appelle les chaines de caractères « null terminated » par opposition aux chaînes de la classe string de la librairie standard C++ que nous verrons plus tard.

const char s1[5] = "abcd";   // OKconst char s2[5] = "abcde";  // error: array bounds overflow s1[0] = 'R'; // error: l-value specifies // const object

char s3[5] = "abcd";         // OK s3[0] = 'R'; // OK

Page 35

Précisions :

Il ne faut pas confondre les littéraux, les constantes et les variables :

-  littéraux : "abcd" ou 'R'

-  constantes : const int I, const char S[5] - variables : int I, char S[5]

Exercice (facultatif) :

-  poursuivre le projet précédent Exple_10_litteraux

-  s’exercer à définir quelques exemples de littéraux chaînes et les afficher avec std::cout <<

C++ : le type boolbool

Contrairement à C, le langage C++ dispose d'un type booléen, le type bool, dont les valeurs sont true et false. Les conditions du if, while, do, for et de l'expression conditionnelle ? : sont des expressions de type bool. Les opérateurs relationnels et logiques travaillent sur ce nouveau type.

int i, j, k; bool b;

b = (i>j); // Bien k = (j>i);  // A éviter

while (b)    // Bien

{

// ...

...

Page 36

Précisions :

En C, le type booléen n’existe pas. On représente les valeurs « vrai » et « faux » par des entiers. Le zéro signifie « faux » et n’importe quel nombre différent de zéro signifie « vrai ».

Le C++ définit deux « littéraux » booléens : true et false.

Exercice :

- en le compilant, regardez ce que produit le code suivant (Exple_10_litteraux) :

bool b1 = 0; bool b2 = 4; bool b3 = false; bool b4 = true; std::cout << b1 << "\t" << b2 << "\t"

<< b3 << "\t" << b4 << std::endl;

C/C++ : les identifieurs

Les identifieurs ou symboles permettent de nommer :

-  des classes (class), des structures (struct) ou des unions (union)

-  des variables, des constantes, ou des instances de classe

-  des types énumérés (enum)

-  des attributs de classes

-  des fonctions ou des méthodes de classes

-  des alias de types (typedef)

-  des labels (goto), des macros (#define)  ou des paramètres de macros

Un symbole C/C++ est formé d’une suite de lettres (a-z A-Z), de chiffres (0-9) ou de soulignés (underscore_). Le premier caractère d’un symbole est obligatoirement une lettre ou un souligné :

int H1B4_8;

float __abc_1_2; char  x1x2x3;

Page 37

Notes :

-  le C/C++ est sensible à la casse minuscules/majuscules des caractères (filename et FileName sont deux symboles différents).

-  les symboles ne peuvent être des mots-clés du langage (int et float par exemple)

-  il est déconseillé d’utiliser des symboles commençant par deux soulignés (__) ou un souligné suivi d’une lettre majuscule (cf. la norme C++).

Ce que dit la norme C++ :

17.4.3.1.2 Global names

Certain sets of names and function signatures are always reserved to the implementation:

— Each name that contains a double underscore (_ _) or begins with an underscore followed by an uppercase letter (2.11) is reserved to the implementation for any use.

— Each name that begins with an underscore is reserved to the implementation for use as a name in the global namespace.

Exemple : Exple_11_symboles

C/C++ : définitions et déclarations (1)

Définir une variable, une classe ou une fonction c’est lui donner un type, des attributs ou un corps de fonction. La définition est unique.

Tous les symboles utilisés pour compiler un fichier doivent être déclarés. La déclaration peut consister à définir le symbole en question ou à rappeler des symboles ailleurs.

// CI-DESSOUS, DES DEFINITIONS, SAUF UNE DECLARATIONint a; // definit aextern const int b = 1;      // definit bint f(int x) { return x+a; } // definit f et definit xstruct S { int a; int b; };  // definit S, S::a, et S::b

struct T // definit T

{ int t; // definit l'attribut d'instance T::tstatic int a; // declare l'attribut de classe T::a T(): t(0) { }   // definit un constructeur de T