Programmez avec le langage C++

50 heures
Difficile

Licence

Ce cours est visible gratuitement en ligne.

Ce cours existe en livre papier.

Vous pouvez obtenir un certificat de réussite à l'issue de ce cours.

Vous pouvez être accompagné et mentoré par un professeur particulier par visioconférence sur ce cours.

J'ai tout compris !

Mis à jour le 19/02/2019

Annexes

Connectez-vous ou inscrivez-vous gratuitement pour bénéficier de toutes les fonctionnalités de ce cours !

Ces annexes contiennent quelques informations utiles pour vous aider à comprendre des codes sources que vous aurez trouvés au hasard du web et qui contiendraient des éléments du C++ pas abordés dans le cours.

Liste des opérateurs du C++

Cette annexe contient la liste des opérateurs du langage C++. Les opérateurs les plus courants ont été vus dans le cours mais il arrive que l'on ait besoin d'autres opérations ou que l'on tombe sur un code source mystérieux au hasard du web. Cette liste complète est là pour vous aider dans ces cas. Il ne sert à rien de l'apprendre par cœur. ;)
Je vous invite à vous en servir comme référence pour avoir le bon prototype lors de la surcharge de vos opérateurs.

Nom	Symbole	Syntaxe	Priorité	Associativité	Prototype	Existe en C ?
Résolution de portée	`::`	`A::x`	16	Pas associatif	Non surchargeable	Non
Appel de fonction	`()`	`f()` `f(123)`	15	L-R	`R C::operator()(...)`	Oui
Accès à un élément de tableau	`[]`	`tab[0]`	15	L-R	`R& C::operator[](A const&)` `R const& C::operator[](A const&) const`	Oui
Accès à membre	`.`	`A.x`	15	L-R	Non surchargeable	Oui
Accès à membre via un pointeur	`->`	`A->x`	15	L-R	`R C::operator->()`	Oui
Identification de type	`typeid`	`typeid(A)` `typeid A`	15	L-R	Non surchargeable	Non
Incrémentation suffixée	`++`	`x++`	15	L-R	`R C::operator++(int)` `R operator++(C&, int)`	Oui
Décrémentation suffixée	`--`	`x--`	15	L-R	`R C::operator--(int)` `R operator--(C&, int)`	Oui
Déréférencement	`*`	`*ptr`	14	R-L	`R C::operator()` `R& operator(C&)`	Oui
Adresse de	`&`	`&x`	14	R-L	`R C::operator&()` `R& operator&(C&)`	Oui
NON logique	`!`	`!x`	14	R-L	`bool C::operator!()` `bool operator!(C const&)`	Oui
NON bit à bit	`~`	`~x`	14	R-L	`bool C::operator~()` `bool operator~(C const&)`	Oui
Taille en mémoire	`sizeof`	`sizeof(x)` `sizeof x`	14	R-L	Non surchargeable	Oui
Plus unaire	`+`	`+x`	14	R-L	`R C::operator+() const` `R operator+(C const&)`	Oui
Moins unaire	`-`	`-x`	14	R-L	`R C::operator-() const` `R operator-(C const&)`	Oui
Incrémentation préfixée	`++`	`++x`	14	R-L	`R& C::operator++()` `R& operator++(C&)`	Oui
Décrémentation préfixée	`--`	`--x`	14	R-L	`R& C::operator--()` `R& operator--(C&)`	Oui
Allocation dynamique	`new`	`new int`	14	R-L	`void* C::operator new(size_t)`	Non
Allocation dynamique de tableau	`new[]`	`new int[4]`	14	R-L	`void* C::operator new[](size_t)`	Non
Libération	`delete`	`delete ptr`	14	R-L	`void C::operator delete(void*)`	Non
Libération de tableau	`delete[]`	`delete[] ptr`	14	R-L	`void C::operator delete[](void*)`	Non
Déréférencement d'un pointeur membre	`.*`	`A.*x`	13	L-R	Non surchargeable	Non
Déréférencement d'un pointeur membre accédé via un pointeur	`->*`	`A->*x`	13	L-R	`R C::operator ->(R)` `R operator ->(C,R)`	Non
Multiplication	`*`	`x*y`	12	L-R	`C C::operator(C const&) const` `C operator(C const&, C const&)`	Oui
Division	`/`	`x/y`	12	L-R	`C C::operator/(C const&) const` `C operator/(C const&, C const&)`	Oui
Modulo	`%`	`x%y`	12	L-R	`C C::operator%(C const&) const` `C operator%(C const&, C const&)`	Oui
Addition	`+`	`x+y`	11	L-R	`C C::operator+(C const&) const` `C operator+(C const&, C const&)`	Oui
Soustraction	`-`	`x-y`	11	L-R	`C C::operator-(C const&) const` `C operator-(C const&, C const&)`	Oui
Décalage de bit vers la gauche	`<<`	`x<<2`	10	L-R	`C C::operator<<(C const&) const` `C operator<<(C const&, C const&)`	Oui
Décalage de bit vers la droite	`>>`	`x>>2`	10	L-R	`C C::operator>>(C const&) const` `C operator>>(C const&, C const&)`	Oui
Strictement inférieur à	`<`	`x<2`	9	L-R	`bool C::operator<(C const&) const` `bool operator<(C const&, C const&)`	Oui
Inférieur à	`<=`	`x<=2`	9	L-R	`bool C::operator<=(C const&) const` `bool operator<=(C const&, C const&)`	Oui
Strictement supérieur à	`>`	`x>2`	9	L-R	`bool C::operator>(C const&) const` `bool operator>(C const&, C const&)`	Oui
Supérieur à	`>=`	`x>=2`	9	L-R	`bool C::operator>=(C const&) const` `bool operator>=(C const&, C const&)`	Oui
Est égal à	`==`	`x==2`	8	L-R	`bool C::operator==(C const&) const` `bool operator==(C const&, C const&)`	Oui
Est différent de	`!=`	`x!=2`	8	L-R	`bool C::operator!=(C const&) const` `bool operator!=(C const&, C const&)`	Oui
ET bit à bit	`&`	`x&y`	7	L-R	`bool C::operator&(C const&) const` `bool operator&(C const&, C const&)`	Oui
OU exclusif (XOR) bit à bit	`^`	`x^y`	6	L-R	`bool C::operator^(C const&) const` `bool operator^(C const&, C const&)`	Oui
OU bit à bit	`\|`	`x\|y`	5	L-R	`bool C::operator\|(C const&) const` `bool operator\|(C const&, C const&)`	Oui
ET logique	`&&`	`x&&y`	4	L-R	`bool C::operator&&(C const&) const` `bool operator&&(C const&, C const&)`	Oui
OU logique	`\|\|`	`x\|\|y`	3	L-R	`bool C::operator\|\|(C const&) const` `bool operator\|\|(C const&, C const&)`	Oui
Opérateur ternaire	`? :`	`x ? y : z`	2	R-L	Non surchargeable	Oui
Affectation	`=`	`x=2`	1	R-L	`R& C::operator=(A const&)`	Oui
Affectation par addition	`+=`	`x+=2`	1	R-L	`R& C::operator+=(A const&)` `R operator+=(C const&, A const&)`	Oui
Affectation par soustraction	`-=`	`x-=2`	1	R-L	`R& C::operator-=(A const&)` `R operator-=(C const&, A const&)`	Oui
Affectation par multiplication	`*=`	`x*=2`	1	R-L	`R& C::operator=(A const&)` `R operator=(C const&, A const&)`	Oui
Affectation par division	`/=`	`x/=2`	1	R-L	`R& C::operator/=(A const&)` `R operator/=(C const&, A const&)`	Oui
Affectation par modulo	`%=`	`x%=2`	1	R-L	`R& C::operator%=(A const&)` `R operator%=(C const&, A const&)`	Oui
Affectation par ET bit à bit	`&=`	`x&=2`	1	R-L	`R& C::operator&=(A const&)` `R operator&=(C const&, A const&)`	Oui
Affectation par OU exclusif (XOR) bit à bit	`^=`	`x^=2`	1	R-L	`R& C::operator^=(A const&)` `R operator^=(C const&, A const&)`	Oui
Affectation par OU bit à bit	`\|=`	`x\|=2`	1	R-L	`R& C::operator\|=(A const&)` `R operator\|=(C const&, A const&)`	Oui
Affectation par décalage de bits vers la gauche	`<<=`	`x<<=2`	1	R-L	`R& C::operator<<=(A const&)` `R operator<<=(C const&, A const&)`	Oui
Affectation par décalage de bits vers la droite	`>>=`	`x>>=2`	1	R-L	`R& C::operator>>=(A const&)` `R operator>>=(C const&, A const&)`	Oui
Opérateur virgule	`,`	`x=2, y=3`	0	R-L	`R C::operator,(A const&)` `R operator,(C const&, A const&)`	Oui

Quelques explications

Il y a deux colonnes un peu mystérieuses dans ce tableau, celles intitulées "Priorité" et "Associativité". La première indique dans quelle ordre les opérations seront effectuées, ce qu'on appelle l'ordre de préséance. Vous avez certainement appris à l'école qu'en arithmétique on effectue les multiplications avant les additions. C'est la même chose en C++. Certains opérations s'effectuent avant d'autres. Les opérations avec une plus grande priorité seront effectuées avant les autres. Ainsi, la ligne

a %= ++b*8;

correspond à la ligne

a %= ((++b)*8);

L'associativité indique dans quel ordre sont effectuées les opérations de même priorité. C'est-à-dire en allant de gauche à droite (LR = left to right) ou de droite à gauche (RL = right to left). Une suite de divisions comme :

a/b/c/d

sera interprétée comme valant :

((a/b)/c)/d

et non pas comme valant :

a/(b/(c/d))

ce qui serait le cas si l'opérateur division avait une associativité R-L.

Les prototypes

Les prototypes des surcharges sont donnés à titre d'exemple pour les cas d'utilisation les plus courants.Creprésente la classe dont on cherche à surcharger les opérateurs,Rest le type du résultat (qui peut être le même queC) etAest une autre classe (potentiellement la même queCouR).
Ainsi, pour la classeDuree, l'opérateur += pour un entier s'écrira:

Duree& Duree::operator+=(int secondes); //Methode de classe

Duree& operator+=(Duree& duree, int secondes); //Fonction libre en-dehors de toute classe

La première version étant une méthode de la classe et la deuxième une fonction libre. La première version est celle que nous avons dans le chapitre sur la surcharge d'opérateurs et je vous invite vivement à suivre les recettes données dans ce chapitre pour écrire vos opérateurs surchargés de manière optimale.

La différence entre l'opérateur incrémentation préfixée et suffixée est la présence d'un argument de typeintdans la version suffixée. Cet argument est inutilisé dans le corps des fonctions et est uniquement là pour différentier les deux opérateurs.

L'opérateur ternaire

Cet opérateur est un brin spécial dans le sens où c'est le seul qui prend trois arguments. Il permet de remplacer l'instructionif(){}else{}un peu à la manière de la fonctionSI()que l'on retrouve dans les tableurs comme Microsoft Excel.
On l'utilise comme suit:

int a(2), b(4), c(5);

int resultat = a > 0 ? b : c;

qui se traduit par

int a(2), b(4), c(5);

int resultat;
if(a > 0)
    resultat = b;
else
    resultat = c;

C'est une notation plus concise que certains programmeurs adorent mais qui laisse souvent les débutants sur leur faim.

Liste des mots-clés du C++

Cette annexe contient la liste des mots-clés du langage C++. Nous avons vu une grande partie de ces mots-clés dans le cours mais certains plus rares ont été omis. L'important est de savoir qu'il est interdit d'utiliser un de ces mots pour nommer une variable, une fonction, méthode ou classe.

Nom	Courte description
`and`	Permet de remplacer le symbole`&&`.
`and_eq`	Permet de remplacer le symbole`&=`.
`asm`	Permet de déclarer une portion de code écrite directement en assembleur.
`auto`	Permet de déclarer une variable comme locale. La mémoire allouée sera automatiquement désallouée à la fin du bloc. Ce mot-clé est devenu inutile car toutes les variables sont`auto`par défaut.
`bitand`	Permet de remplacer le symbole`&`.
`bitor`	Permet de remplacer le symbole`\|`.
`bool`	Type de variable contenant une valeur booléenne (valant vrai ou faux uniquement).
`break`	Instruction permettant de sortir d'une boucle (`for`ou`while`) ou d'un`switch`.
`case`	Instruction indiquant un des cas d'un`switch`.
`catch`	Instruction introduisant un bloc permettant d'attraper des exceptions.
`char`	Type de variable contenant une lettre.
`class`	Mot-clé introduisant la définition d'une classe.
`compl`	Permet de remplacer le symbole`~`.
`const`	Indique qu'une variable ou objet ne peut pas être modifié. Indique qu'une méthode ne changera pas l'état d'un objet.
`const_cast`	Permet de changer le type d'un objet déclaré`const`ou`volatile`en un objet de même type mais pas`const`.
`continue`	Instruction permettant de passer à l'itération suivante d'une boucle (for ou while).
`default`	Instruction indiquant le cas par défaut d'un`switch`.
`delete`	Opérateur libérant la mémoire allouée précédemment via`new`.
`do`	Déclare une boucle constituée d'une condition finale uniquement dont le corps est exécuté au moins une fois.
`double`	Type de variable contenant un nombre à virgule (généralement sur 64 bits).
`dynamic_cast`	Permet de changer le type d'un objet déclaré d'une classe parent vers enfant ou d'une classe parent à une autre.
`else`	Introduit une portion de code exécutée si un test`if`ne renvoie pas`true`.
`enum`	Mot-clé introduisant la définition d'un type énuméré.
`explicit`	Indique que le constructeur doit être appelé explicitement par l'utilisateur.
`export`	Mot-clé (non utilisé) permettant de séparer le prototype de la définition d'un`template`.
`extern`	Indique qu'une variable ou un objet est déclaré dans un autre fichier source.
`false`	La valeur logique "faux".
`float`	Type de variable contenant un nombre à virgule (généralement sur 32 bits).
`for`	Déclare une boucle constituée d'une initialisation, d'une condition finale et d'un incrément.
`friend`	Mot-clé permettant de déclarer une fonction ou une classe amie d'une autre classe.
`goto`	Instruction permettant de sauter directement à un autre point du code source.
`if`	Introduit une structure conditionnelle.
`inline`	Indique que le corps d'une fonction ou méthode doit être (si possible) copiée à l'endroit de l'appel.
`int`	Type de variable contenant un nombre entier (généralement sur 32 bits).
`long`	Type de variable contenant un nombre entier (généralement sur 64 bits).
`mutable`	Indique qu'un attribut peut changer même si l'instance de la classe est déclarée constante.
`namespace`	Mot-clé introduisant la définition d'un espace de nom.
`new`	Opérateur allouant de la mémoire et appelant le constructeur d'une variable ou d'un objet.
`not`	Permet de remplacer le symbole`!`.
`not_eq`	Permet de remplacer le symbole`!=`.
`operator`	Permet de déclarer une surcharge d'opérateur.
`or`	Permet de remplacer le symbole`\|\|`.
`or_eq`	Permet de remplacer le symbole`\|=`.
`private`	Droit d'accès aux éléments d'une classe interdisant l'accès depuis l'extérieur de la classe.
`protected`	Droit d'accès aux éléments d'une classe interdisant l'accès depuis l'extérieur de la classe sauf pour les classes héritées.
`public`	Droit d'accès aux éléments d'une classe autorisant l'accès depuis l'extérieur de la classe.
`register`	Indique qu'une variable ou un objet doit être stockée dans les registres du processeurs si possible.
`reinterpret_cast`	Permet de changer le type d'un objet déclaré en réinterprétant les données brutes bit par bit.
`return`	Indique la valeur qu'une fonction doit renvoyer.
`short`	Type de variable contenant un nombre entier (généralement sur 16 bits).
`signed`	Indique qu'un type peut contenir des valeurs positives et négatives (comportement par défaut).
`sizeof`	Opérateur renvoyant la taille en octets d'un type.
`static`	Permet de déclarer un attribut ou une méthode comme étant statique.
`static_cast`	Permet de changer le type d'un objet déclaré vers un autre objet si les types sont compatibles.
`struct`	Mot-clé introduisant la définition d'une structure (une classe où tout est`public`par défaut).
`switch`	Introduit une structure conditionnelle avec plusieurs sorties possibles selon la valeur de l'expression testée.
`template`	Mot-clé introduisant la définition d'un patron de classe ou de fonction.
`this`	Pointeur vers l'objet courant.
`throw`	Instruction lançant une exception.
`true`	La valeur logique "vrai".
`try`	Instruction introduisant un bloc sensible aux exceptions.
`typedef`	Mot-clé introduisant la définition d'un alias de type.
`typeid`	Opérateur renvoyant des informations (nom, ...) sur un objet.
`typename`	Permet de décrire un type indéterminé dans le cadre d'une fonction ou d'une classe template.
`union`	Mot-clé introduisant la définition d'une union (structure où les attributs utilisent la même adresse mémoire).
`unsigned`	Indique qu'un type peut contenir des valeurs positives seulement.
`using`	Permet d'indiquer que l'on utilise les objets et variables d'un espace de nom sans avoir à le spécifier à chaque utilisation. Permet de démasquer une méthode masquée dans une classe fille.
`virtual`	Permet de déclarer une méthode comme étant virtuelle. Permet de définir un héritage virtuel dans le cas de l'héritage multiple.
`void`	Type de retour d'une fonction ne renvoyant rien.
`volatile`	Indique qu'une variable peut changer à tout moment pour des raisons externes au programme.
`wchar_t`	Type de variable contenant une lettre généralisée (UTF-8 ou autre).
`while`	Déclare une boucle constituée d'une condition finale uniquement.
`xor`	Permet de remplacer le symbole`^`.
`xor_eq`	Permet de remplacer le symbole`^=`.

Créez un compte
OpenClassrooms

Connexion