C++ pour débutants - Daniel Harder

C++ pour débutants
Votre guide complet étape par étape pour tout savoir sur C++
Daniel Harder
Introduction
C++ est un langage de programmation hautes performances largement utilisé dans diverses applications,
telles que les systèmes d'exploitation, les navigateurs Web et les jeux vidéo. Il a été développé en 1979
par Bjarne Stroustrup comme une extension du langage de programmation C, ajoutant des fonctionnalités
orientées objet et d'autres améliorations.
C++ est un langage compilé à typage statique, ce qui signifie qu'il est plus efficace que les langages à
typage dynamique comme Python ou JavaScript. C'est aussi un langage très expressif, permettant aux
programmeurs d'écrire du code à la fois efficace et facile à lire.
L'une des principales caractéristiques de C++ est sa prise en charge de la programmation orientée objet
(POO). Dans la POO, les données et le comportement sont encapsulés dans des "objets", qui peuvent être
utilisés pour modéliser des concepts du monde réel et interagir les uns avec les autres via des méthodes.
C++ prend également en charge la programmation procédurale, qui est un style de programmation plus
traditionnel qui se concentre sur l'écriture de fonctions pour effectuer des tâches spécifiques.
C++ est un langage puissant et flexible, mais il peut aussi être complexe et difficile à apprendre pour les
débutants. Cela nécessite une bonne compréhension des concepts informatiques et une base solide dans
les concepts de programmation tels que les variables, les types de données, les boucles et les structures
de contrôle. Cependant, une fois que vous avez une bonne compréhension de ces concepts, C++ peut être
un langage très enrichissant à apprendre et à utiliser.
Chapitre un
concepts de base
Système de types C++
En C++, les données sont stockées et manipulées à l'aide de différents types de données. Ces types de
données déterminent la taille et la disposition de la mémoire utilisée par les variables, ainsi que
l'ensemble des opérations pouvant être effectuées sur celles-ci.
C++ possède un système de type riche qui inclut à la fois des types intégrés et des types définis par
l'utilisateur.
Les types intégrés incluent :
Types entiers : ils représentent des nombres entiers et incluent char , short , int , long et long
long . Chacun de ces types a une taille différente, l' omble chevalier étant le plus petit et long
étant le plus grand.
Types à virgule flottante : ils représentent des nombres avec des parties fractionnaires et
incluent float , double et long double . Ces types ont également des tailles différentes, le flotteur
étant le plus petit et le double long étant le plus grand.
Type booléen : cela représente une valeur vrai/faux et est représenté par le type
booléen
.
Types de caractères : ils représentent des caractères individuels et incluent char et wchar_t .
char est utilisé pour les caractères ASCII et wchar_t est utilisé pour les caractères larges, qui
peuvent représenter des caractères d'une variété d'alphabets différents.
Les types définis par l'utilisateur en C++ incluent :
Classes : une classe est un type de données défini par l'utilisateur qui vous permet de définir
vos propres champs de données et méthodes.
Structures : une structure est similaire à une classe, mais les champs de données et les
méthodes sont publics par défaut.
Énumérations : une énumération est un type défini par l'utilisateur qui se compose d'un
ensemble de constantes nommées.
Typedef : Le mot-clé typedef vous permet de définir un nouveau nom pour un type de données
existant. Cela peut être utilisé pour créer des noms plus lisibles ou expressifs pour les types
complexes.
C++ prend également en charge la conversion de type, ce qui vous permet de convertir une valeur d'un
type de données à un autre. Cela peut être utile lorsque vous travaillez avec différents types de données
qui doivent être utilisés ensemble, mais des précautions doivent être prises lors de l'utilisation de la
conversion de type, car cela peut entraîner une perte de précision ou d'autres comportements inattendus
s'ils ne sont pas utilisés correctement.
Portée
En C++, la portée d'une variable fait référence à la partie du programme dans laquelle la variable est
visible ou accessible. La portée d'une variable est déterminée par l'emplacement de sa déclaration dans le
programme.
Il existe deux principaux types de portée en C++ : la portée locale et la portée globale.
Une variable locale est une variable déclarée dans une fonction ou un bloc de code. Les variables locales
ne sont visibles qu'à l'intérieur de la fonction ou du bloc dans lequel elles sont déclarées, et elles ne sont
accessibles que du point de leur déclaration à la fin du bloc. Lorsque la fonction ou le bloc se termine, la
variable locale est détruite et n'est plus accessible.
Une variable globale est une variable déclarée en dehors de toute fonction ou bloc de code. Les variables
globales sont visibles dans tout le programme et sont accessibles depuis n'importe quelle fonction ou bloc
de code. Cependant, il est généralement considéré comme une bonne pratique de programmation de
minimiser l'utilisation de variables globales, car elles peuvent rendre le programme plus difficile à
comprendre et à maintenir.
C++ prend également en charge les étendues imbriquées, où un bloc de code est défini dans un autre
bloc de code. Dans ce cas, les variables déclarées dans le bloc interne ne sont visibles que dans ce bloc,
mais elles sont également accessibles depuis le bloc externe.
La portée d'une variable est un concept important en C++, car elle détermine la visibilité et l'accessibilité
de la variable dans le programme. Comprendre la portée des variables est essentiel pour écrire un code
efficace et maintenable.
Fichiers d'en-tête
En C++, un fichier d'en-tête est un fichier qui contient des déclarations de fonctions, de variables et
d'autres constructions pouvant être utilisées dans un programme C++. Les fichiers d'en-tête sont
généralement désignés par le suffixe .h et sont inclus dans un fichier source C++ à l'aide de la directive
#include .
Les fichiers d'en-tête sont utilisés à diverses fins en C++. Ils peuvent être utilisés pour déclarer des
fonctions et des variables qui sont définies dans un autre fichier source, leur permettant d'être utilisées
dans plusieurs fichiers sans duplication de code. Ils peuvent également être utilisés pour déclarer des
fonctions et des variables qui sont implémentées dans une bibliothèque, leur permettant d'être utilisées
dans un programme sans avoir besoin de lier la bibliothèque au programme.
Les fichiers d'en-tête peuvent également être utilisés pour définir des macros, qui sont de courts
morceaux de code qui sont remplacés par le préprocesseur avec leur forme développée correspondante.
Les macros sont souvent utilisées pour définir des constantes et d'autres valeurs qui doivent être utilisées
à plusieurs endroits dans un programme.
L'un des principaux avantages de l'utilisation des fichiers d'en-tête est qu'ils permettent d'organiser et de
réutiliser plus facilement le code. En séparant les déclarations des définitions et en les plaçant dans un
fichier d'en-tête séparé, il est possible d'utiliser le même code dans plusieurs programmes sans avoir à le
copier et le coller. Cela facilite la maintenance et la mise à jour du code, car les modifications ne doivent
être apportées qu'à un seul endroit.
Quelques exemples de fichiers d'en-tête C++ standard incluent <iostream> , qui fournit des flux d'entrée et
de sortie pour lire et écrire des données, et <string> , qui fournit des fonctions et des classes pour
travailler avec des chaînes. Il existe de nombreux autres fichiers d'en-tête disponibles dans la bibliothèque
standard C++, ainsi que dans des bibliothèques tierces, qui fournissent un large éventail de
fonctionnalités pour diverses tâches.
Unités de traduction et liaison
En C++, une unité de traduction est un fichier source et tous les fichiers d'en-tête qu'il inclut, ainsi que
tous les fichiers d'en-tête inclus par ces fichiers d'en-tête, etc. Le processus de transformation d'une unité
de traduction en un programme exécutable est appelé compilation.
Lors de la compilation, le préprocesseur traite les directives #include dans l'unité de traduction, en
insérant le contenu des fichiers d'en-tête inclus dans le fichier source. Le fichier source développé
résultant est ensuite transmis au compilateur, qui le traduit en code objet.
Le code objet est une représentation lisible par machine du programme qui peut être exécuté par
l'ordinateur. Cependant, le code objet n'est pas sous une forme qui peut être directement exécutée par le
système d'exploitation. Au lieu de cela, il doit être combiné avec d'autres fichiers de code objet et
bibliothèques pour créer un programme exécutable. Ce processus est appelé liaison.
Il existe deux types de liaison en C++ : la liaison interne et la liaison externe.
La liaison interne fait référence aux symboles (variables et fonctions) qui ne sont visibles que dans une
seule unité de traduction. Ces symboles sont généralement utilisés pour les détails de mise en œuvre qui
ne sont pas destinés à être accessibles à partir d'autres unités de traduction. La liaison interne est
obtenue en déclarant des symboles avec le mot-clé static .
La liaison externe fait référence aux symboles qui sont visibles par plusieurs unités de traduction. Ces
symboles sont généralement utilisés pour définir des fonctions et des variables destinées à être partagées
entre plusieurs unités de traduction. La liaison externe est la valeur par défaut pour les symboles qui ne
sont pas déclarés avec le mot-clé static .
La liaison est un concept important en C++, car elle détermine la visibilité et l'accessibilité des symboles
dans un programme. Comprendre la liaison est essentiel pour écrire un code efficace et maintenable, en
particulier lorsque vous travaillez avec de gros programmes composés de plusieurs fichiers sources et
bibliothèques.
fonction principale et arguments de ligne de commande
En C++, la fonction principale est le point d'entrée d'un programme. C'est la fonction qui est appelée par le
système d'exploitation au démarrage du programme et qui détermine le flux de contrôle pour le reste du
programme.
La fonction principale a une syntaxe et un type de retour spécifiques. En C++, il peut être déclaré de l'une
des manières suivantes :
La première version de main ne prend aucun argument et renvoie une valeur int . La seconde version
prend deux arguments : argc et argv . argc est une valeur int qui représente le nombre d'arguments de
ligne de commande passés au programme, et argv est un tableau de valeurs char* qui contient les
arguments réels.
Les arguments de la ligne de commande sont des valeurs transmises au programme lorsqu'il est lancé à
partir de la ligne de commande. Ils sont généralement utilisés pour transmettre des options de
configuration ou d'autres entrées au programme.
Par exemple, considérez le programme suivant qui imprime les arguments de ligne de commande qu'il
reçoit :
#include <iostream>
Pour exécuter ce programme et lui transmettre des arguments de ligne de commande, vous utiliseriez une
commande comme celle-ci :
Cela imprimerait la sortie suivante :
Comme vous pouvez le voir, le premier argument ( argv[0] ) est le nom du programme lui-même, et les
arguments restants sont ceux passés sur la ligne de commande.
Les arguments de ligne de commande peuvent être utiles pour fournir une entrée à un programme ou
pour configurer son comportement. Ils sont une caractéristique commune à de nombreux programmes en
ligne de commande et sont faciles à utiliser en C++.
Fin du programme
En C++, un programme se termine lorsque la fonction
appelée.
principale
revient ou lorsque la fonction
exit
est
La fonction main est le point d'entrée d'un programme C++ et détermine le flux de contrôle pour le reste
du programme. Lorsque la fonction principale revient, le programme se termine. La valeur de retour de
est l'état de sortie du programme, qui peut être utilisé par le système d'exploitation ou d'autres
programmes pour déterminer le résultat du programme. Une valeur de retour de 0 indique généralement
que le programme s'est exécuté avec succès, tandis qu'une valeur différente de zéro indique
généralement une erreur.
main
Par exemple, la fonction
succès :
main
suivante renvoie 0 pour indiquer que le programme s'est exécuté avec
La fonction exit est une fonction définie dans la bibliothèque cstdlib qui permet à un programme de se
terminer immédiatement. Il prend une valeur int comme argument, qui est l'état de sortie du programme.
La fonction de sortie peut être appelée de n'importe où dans le programme et entraînera l'arrêt immédiat
du programme, même s'il existe d'autres fonctions ou blocs de code qui ne sont pas encore terminés.
Par exemple, le code suivant appelle la fonction
1:
exit
pour terminer le programme avec un état de sortie de
Il est généralement considéré comme une bonne pratique de programmation d'utiliser le retour pour
mettre fin à la fonction principale et de réserver la fonction de sortie aux situations d'urgence ou aux
circonstances exceptionnelles.
Comprendre comment un programme se termine est important pour écrire un code efficace et
maintenable, car cela vous permet de vous assurer que toutes les tâches de nettoyage nécessaires sont
effectuées avant la fermeture du programme.
Lvalues et rvalues
En C++, une lvalue (abréviation de "left value") est une expression qui fait référence à un emplacement
mémoire et peut apparaître sur le côté gauche d'une affectation. Une rvalue (abréviation de "right value")
est une expression qui ne fait pas référence à un emplacement mémoire et ne peut pas apparaître sur le
côté gauche d'une affectation.
Voici quelques exemples de lvalues et rvalues :
En C++, les lvalues ont un type spécifique et peuvent être utilisées pour faire référence à des objets
stockés en mémoire. Les valeurs R, en revanche, n'ont pas de type spécifique et ne peuvent pas être
utilisées pour faire référence à des objets stockés en mémoire.
Les valeurs L et rvalues sont un concept important en C++, car elles déterminent l'ensemble des
opérations pouvant être effectuées sur les expressions. Par exemple, les lvalues peuvent être affectées à,
tandis que les rvalues ne le peuvent pas. Les Lvalues peuvent également être déréférencées,
contrairement aux rvalues. Comprendre la différence entre lvalues et rvalues est essentiel pour écrire du
code C++ correct et efficace.
Objets temporaires
En C++, un objet temporaire est un objet créé pour contenir le résultat d'une expression et détruit
immédiatement après l'évaluation de l'expression. Les objets temporaires sont également appelés
"rvalues", car ils sont généralement créés à partir d'expressions rvalue (expressions qui ne font pas
référence à un emplacement mémoire et ne peuvent pas apparaître sur le côté gauche d'une affectation).
Les objets temporaires sont créés dans diverses situations en C++. Par exemple, ils peuvent être créés
lorsqu'une rvalue est transmise à une fonction ou lorsqu'une rvalue est utilisée comme opérande droit
d'une affectation.
Voici quelques exemples d'objets temporaires créés en C++ :
Point p = Point(1, 2); // un objet temporaire est créé pour contenir le résultat du constructeur Point
Les objets temporaires sont souvent utilisés pour éviter les copies inutiles ou pour tirer parti de la
sémantique de déplacement, qui permet au contenu d'un objet d'être "déplacé" plutôt que copié.
Il est important d'être conscient des objets temporaires en C++, car ils peuvent avoir un comportement
différent des objets normaux et peuvent conduire à des résultats inattendus s'ils ne sont pas utilisés
correctement. Par exemple, il n'est généralement pas autorisé de lier une référence non const à un objet
temporaire, car l'objet temporaire sera détruit dès que la référence sortira de la portée. Comprendre le
comportement des objets temporaires est essentiel pour écrire du code C++ correct et efficace.
Alignement
En C++, l'alignement fait référence à la manière dont les données sont organisées en mémoire.
L'alignement peut avoir un impact sur les performances et l'efficacité d'un programme, car il peut affecter
la vitesse d'accès aux données et la quantité de mémoire utilisée.
C++ fournit un certain nombre de fonctionnalités de langage et de fonctions de bibliothèque pour
contrôler l'alignement.
Une façon de contrôler l'alignement en C++ consiste à utiliser les mots-clés alignas et alignof . Le mot-clé
alignas peut être utilisé pour spécifier l'alignement d'une variable ou d'un type de données, et le mot-clé
alignof peut être utilisé pour déterminer l'alignement d'une variable ou d'un type de données.
Par exemple, le code suivant définit une variable
x
avec un alignement de 16 octets :
Le mot-clé alignof peut être utilisé pour déterminer l'alignement d'une variable ou d'un type de données,
comme illustré dans l'exemple suivant :
Une autre façon de contrôler l'alignement en C++ consiste à utiliser les types std::aligned_storage et
std::aligned_union à partir de l' en-tête <type_traits> . Ces types fournissent un moyen de stocker des données
avec un alignement spécifié de manière portable et efficace.
Par exemple, le code suivant définit un
avec un alignement de 16 octets :
stockage variable
qui peut être utilisé pour stocker un objet de type
T
Comprendre l'alignement est important pour écrire du code C++ efficace et performant, en particulier
lorsque vous travaillez avec de grandes structures de données ou lorsque vous interagissez avec du
matériel ou des systèmes de bas niveau. Un bon alignement peut améliorer considérablement les
performances d'un programme en réduisant le nombre d'accès à la mémoire et
Types triviaux, standard et POD
En C++, un type est considéré comme trivial s'il s'agit d'un type qui a un constructeur par défaut trivial,
un destructeur trivial et aucune fonction virtuelle ou classe de base virtuelle.
Un type est considéré comme de mise en page standard s'il s'agit d'un type qui satisfait aux conditions
suivantes :
C'est un type trivial.
Il n'a pas de membres de données non statiques de type classe de mise en page non standard
(ou tableau de tels types).
Il n'a pas de fonctions virtuelles ni de classes de base virtuelles.
Un type est considéré comme un type POD (Plain Old Data) s'il s'agit d'un type qui satisfait les conditions
suivantes :
C'est un type de mise en page standard.
Il n'a pas de membres de données non statiques de type classe non POD (ou tableau de tels
types).
Il n'a pas d'opérateur d'affectation de copie défini par l'utilisateur ni de destructeur défini par
l'utilisateur.
Les types triviaux, à disposition standard et POD sont des concepts importants en C++, car ils ont un
comportement et des propriétés spécifiques sur lesquels le programmeur peut s'appuyer. Par exemple, les
types triviaux peuvent être memset à zéro et copiés à l'aide de memcpy, tandis que les types de mise en
page standard peuvent être passés aux fonctions C et peuvent être utilisés pour implémenter des types
d'union. Les types POD peuvent être utilisés pour implémenter des structures de style C et peuvent être
initialisés avec une liste d'initialisation entre accolades.
Comprendre le comportement et les propriétés des types triviaux, de mise en page standard et POD est
important pour écrire un code C++ efficace et correct, en particulier lorsque vous travaillez avec du
matériel ou des systèmes de bas niveau, ou lors de l'interfaçage avec du code C.
qu'est-ce que les types de valeur
En C++, un type valeur est un type qui contient une valeur et est généralement stocké en mémoire sur la
pile. Les types valeur sont également appelés "types fondamentaux", car ce sont les types les plus
basiques fournis par le langage.
La bibliothèque C++ standard fournit plusieurs types de valeurs, dont les suivants :
bool
: un type booléen qui représente vrai ou faux.
char
: un type de caractère qui représente un seul caractère.
int
,
float
short
et
,
long
double
et
long long
: types entiers de tailles variables.
: types à virgule flottante de précision variable.
Les types valeur sont généralement utilisés pour contenir des données simples, telles que des nombres,
des caractères et des booléens. Ils sont efficaces à utiliser, car ils ne nécessitent aucune gestion de
mémoire supplémentaire et sont stockés directement en mémoire sur la pile.
Voici un exemple d'utilisation des types valeur en C++ :
Les types valeur sont un concept important en
C++, car ils constituent la base de nombreux autres types du langage. Comprendre comment
fonctionnent les types de valeur et comment ils peuvent être utilisés est essentiel pour écrire un code
C++ efficace et correct.
Conversions de type et sécurité de type
En C++, les conversions de type sont le processus de conversion d'une valeur d'un type à un autre. Il
existe plusieurs façons d'effectuer des conversions de type en C++, notamment la conversion de type
explicite, la surcharge de fonctions et les opérateurs de conversion de type.
La conversion de type explicite est le processus de conversion explicite d'une valeur d'un type à un autre
à l'aide de l' opérateur static_cast . Ceci est généralement utilisé pour convertir une valeur d'un type de
base en un type dérivé, ou d'un type dérivé en un type de base.
Par exemple, le code suivant utilise une conversion de type explicite pour convertir une valeur
valeur int :
double en une
La surcharge de fonctions est le processus de définition de plusieurs fonctions avec le même nom mais
avec des types de paramètres différents. Cela permet à la même fonction d'être utilisée pour effectuer
différentes opérations selon le type de ses arguments.
Par exemple, le code suivant définit une fonction
d'un int , d'un float ou d'un double :
abs
qui peut être utilisée pour calculer la valeur absolue
Conversions standards
En C++, une conversion standard est une conversion de type implicite prédéfinie qui est effectuée par le
compilateur. Les conversions standard sont un ensemble de règles prédéfinies qui dictent comment des
valeurs de différents types peuvent être converties les unes aux autres.
Il existe trois types de conversions standard en C++ :
1. Conversion Lvalue-rvalue : cette conversion est appliquée aux lvalues (expressions qui font
référence à un emplacement mémoire) pour produire des rvalues (expressions qui ne font pas
référence à un emplacement mémoire). Cette conversion est généralement appliquée aux
objets pour leur permettre d'être utilisés comme rvalues, par exemple lorsqu'ils sont passés à
des fonctions ou utilisés comme opérande droit d'une affectation.
2. Conversion de tableau en pointeur : cette conversion est appliquée aux tableaux pour les
convertir en pointeurs vers leur premier élément. Cette conversion est généralement
appliquée lorsqu'un tableau est passé à une fonction ou lorsqu'il est utilisé dans une
expression.
3. Conversion de fonction en pointeur : cette conversion est appliquée aux noms de fonction
pour les convertir en pointeurs vers la fonction. Cette conversion est généralement appliquée
lorsqu'un nom de fonction est passé à une fonction ou lorsqu'il est utilisé dans une
expression.
Les conversions standard sont appliquées automatiquement par le compilateur et le programmeur n'a pas
besoin de les spécifier explicitement. Ils constituent une partie importante du système de types C++, car
ils permettent d'utiliser indifféremment des valeurs de différents types dans de nombreux contextes.
Comprendre le fonctionnement des conversions standard est essentiel pour écrire du code C++ correct et
efficace.
Chapitre II
types intégrés
Types intégrés
En C++, les types intégrés sont un ensemble de types prédéfinis fournis par le langage et implémentés
directement par le compilateur. Les types intégrés sont également appelés "types fondamentaux" ou
"types valeur", car ce sont les types les plus basiques fournis par le langage et ils sont généralement
stockés en mémoire sur la pile.
La bibliothèque standard C++ fournit plusieurs types intégrés, dont les suivants :
bool
: un type booléen qui représente vrai ou faux.
char
: un type de caractère qui représente un seul caractère.
int
,
short
,
long
et
long long
: types entiers de tailles variables.
float
et
void
: un type spécial qui représente l'absence d'une valeur.
double
: types à virgule flottante de précision variable.
Les types intégrés sont un concept important en C++, car ils constituent la base de nombreux autres
types du langage. Comprendre comment fonctionnent les types intégrés et comment ils peuvent être
utilisés est essentiel pour écrire un code C++ efficace et correct.
Voici un exemple d'utilisation de types intégrés en C++ :
Plages de types de données
En C++, la plage d'un type de données est l'ensemble de valeurs qu'il peut représenter. La plage d'un
type de données est déterminée par sa taille et la manière dont il est codé.
La bibliothèque standard C++ fournit plusieurs types intégrés, chacun avec une plage spécifique de
valeurs qu'il peut représenter. Le tableau suivant montre la plage de certains types intégrés courants en
C++ :
Taper
Taille (octets)
1
carboniser
1
wchar_t
2 ou 4
char16_t
2
char32_t
4
court
2
entier
4
long
4 ou 8
longtemps longtemps 8
flotteur
4
double
8
longue double
8 ou 10 ou 16
bourdonner
Valeur minimum
Valeur maximum
faux
vrai
-128
127
défini par la mise en œuvre défini par la mise en œuvre
0
65535
0
4294967295
-32768
32767
-2147483648
2147483647
défini par la mise en œuvre défini par la mise en œuvre
-9223372036854775808
9223372036854775807
1.17549e-38
3.40282e+38
2.22507e-308
1.79769e+308
défini par la mise en œuvre défini par la mise en œuvre
Il est important de connaître la plage d'un type de données lorsque vous travaillez avec C++, car
l'utilisation d'une valeur en dehors de sa plage peut entraîner un comportement indéfini. Comprendre la
plage d'un type de données est également important pour choisir le type approprié pour une tâche
donnée, car l'utilisation d'un type avec une plage plus large peut entraîner de meilleures performances ou
des résultats plus précis.
nullptr
En C++, nullptr est un mot-clé spécial qui représente une valeur de pointeur null. Il a été introduit en
C++11 comme un moyen plus sûr et plus explicite de représenter un pointeur nul que l'utilisation de la
constante entière 0 ou de la macro NULL .
a le type std::nullptr_t , qui est un type spécial qui peut être implicitement converti en n'importe quel
type de pointeur. Cela permet à nullptr d'être utilisé dans une variété de contextes où un pointeur est
attendu, comme lors de l'initialisation d'un pointeur ou lors du passage d'un pointeur à une fonction.
nullptr
Voici un exemple d'utilisation de
nullptr
en C++ :
L'utilisation de nullptr au lieu de 0 ou NULL présente plusieurs avantages. Il est plus explicite et plus facile
à lire, car il indique clairement qu'un pointeur nul est utilisé. Il est également plus sûr, car il empêche les
conversions accidentelles entre les pointeurs et les entiers, ce qui peut entraîner un comportement
indéfini.
est un concept important en C++, en particulier lorsque vous travaillez avec des pointeurs et des
valeurs nullables. Comprendre comment utiliser nullptr et comment il diffère de 0 et NULL est essentiel
pour écrire du code C++ correct et sûr.
nullptr
nullptr
En C++, nullptr est un mot-clé spécial qui représente une valeur de pointeur null. Il a été introduit en
C++11 comme un moyen plus sûr et plus explicite de représenter un pointeur nul que l'utilisation de la
constante entière 0 ou de la macro NULL .
a le type std::nullptr_t , qui est un type spécial qui peut être implicitement converti en n'importe quel
type de pointeur. Cela permet à nullptr d'être utilisé dans une variété de contextes où un pointeur est
attendu, comme lors de l'initialisation d'un pointeur ou lors du passage d'un pointeur à une fonction.
nullptr
Voici un exemple d'utilisation de
nullptr
en C++ :
L'utilisation de nullptr au lieu de 0 ou NULL présente plusieurs avantages. Il est plus explicite et plus facile
à lire, car il indique clairement qu'un pointeur nul est utilisé. Il est également plus sûr, car il empêche les
conversions accidentelles entre les pointeurs et les entiers, ce qui peut entraîner un comportement
indéfini.
est un concept important en C++, en particulier lorsque vous travaillez avec des pointeurs et des
valeurs nullables. Comprendre comment utiliser nullptr et comment il diffère de 0 et NULL est essentiel
pour écrire du code C++ correct et sûr.
nullptr
bourdonner
En C++, bool est un type de données intégré qui représente une valeur booléenne, qui peut être
false . Il est utilisé pour représenter la vérité ou la fausseté d'une condition ou d'une expression.
true
ou
Voici un exemple d'utilisation du type de données
bool
en C++ :
#include <iostream>
La sortie de ce programme sera :
b1 : 1
b2 : 0
En C++, true est généralement représenté par 1 et false est représenté par 0 . Cependant, vous pouvez
utiliser les valeurs true et false directement dans votre code pour représenter des valeurs booléennes.
Par exemple, le code suivant est également valide :
La sortie de ce programme sera :
b1
b2
b1
b2
:1
:0
est vrai
est faux
faux
En C++, false est une valeur booléenne qui représente l'opposé de
vérité ou la fausseté d'une condition ou d'une expression.
true
. Il est utilisé pour représenter la
En C++, false est généralement représenté par 0 . Cependant, vous pouvez utiliser la valeur
directement dans votre code pour représenter une valeur booléenne.
Voici un exemple d'utilisation de la valeur
false
false
en C++ :
La sortie de ce programme sera :
b1
b2
b1
b2
:1
:0
est vrai
est faux
Dans cet exemple, la variable b2 reçoit la valeur false , qui est représentée par 0 . Lorsque la valeur de
est testée dans une instruction if , elle est considérée comme étant false et le code du bloc else est
exécuté.
b2
vrai
En C++, true est une valeur booléenne qui représente l'opposé de
vérité ou la fausseté d'une condition ou d'une expression.
false
. Il est utilisé pour représenter la
En C++, true est généralement représenté par 1 . Cependant, vous pouvez utiliser la valeur
directement dans votre code pour représenter une valeur booléenne.
Voici un exemple d'utilisation de la valeur
true
en C++ :
true
La sortie de ce programme sera :
b1
b2
b1
b2
:1
:0
est vrai
est faux
Dans cet exemple, la variable b1 reçoit la valeur true , qui est représentée par 1 . Lorsque la valeur de
est testée dans une instruction if , elle est considérée comme true et le code du bloc if est exécuté.
b1
__m64
est une définition de type dans le langage de programmation C++ qui représente une valeur entière
64 bits. Il s'agit d'un type de données intégré fourni par le compilateur Intel C++ à utiliser avec les
instructions Intel Streaming SIMD Extensions (SSE).
__m64
Le type __m64 peut être utilisé pour stocker et manipuler des valeurs entières 64 bits d'une manière
optimisée pour une utilisation avec les instructions SSE. Il est destiné à être utilisé dans des applications
hautes performances, multimédias et scientifiques où les données doivent être traitées en parallèle.
Voici un exemple d'utilisation du type de données
__m64
en C++ :
La sortie de ce programme sera :
m1 : [1, 2]
m2 : [3, 3]
Notez que le type de données __m64 n'est disponible que lors de l'utilisation du compilateur Intel C++ et
lorsque le fichier d'en-tête emmintrin.h est inclus. Ce n'est pas un type de données C++ standard et n'est
pas pris en charge par d'autres compilateurs.
__m128
est une définition de type dans le langage de programmation C++ qui représente une valeur à
virgule flottante de 128 bits. Il s'agit d'un type de données intégré fourni par le compilateur Intel C++ à
utiliser avec les instructions Intel Streaming SIMD Extensions (SSE).
__m128
Le type __m128 peut être utilisé pour stocker et manipuler des valeurs à virgule flottante 128 bits d'une
manière optimisée pour une utilisation avec les instructions SSE. Il est destiné à être utilisé dans les
hautes performances,
applications multimédias et scientifiques où les données doivent être traitées en parallèle.
Voici un exemple d'utilisation du type de données
__m128
en C++ :
La sortie de ce programme sera :
m1 : [1.0, 2.0, 3.0, 4.0]
m2 : [5,0, 5,0, 5,0, 5,0]
Notez que le type de données __m128 n'est disponible que lors de l'utilisation du compilateur Intel C++ et
lorsque le fichier d'en-tête emmintrin.h est inclus. Ce n'est pas un type de données C++ standard et n'est
pas pris en charge par d'autres compilateurs.
__m128d
est une définition de type dans le langage de programmation C++ qui représente une valeur à
virgule flottante de 128 bits. Il s'agit d'un type de données intégré fourni par le compilateur Intel C++ à
utiliser avec les instructions Intel Streaming SIMD Extensions (SSE).
__m128d
Le type __m128d peut être utilisé pour stocker et manipuler des valeurs à virgule flottante 128 bits d'une
manière optimisée pour une utilisation avec les instructions SSE. Il est destiné à être utilisé dans des
applications hautes performances, multimédias et scientifiques où les données doivent être traitées en
parallèle.
Voici un exemple d'utilisation du type de données
__m128d
en C++ :
La sortie de ce programme sera :
m1 : [1.0, 2.0]
m2 : [3,0, 3,0]
Notez que le type de données __m128d n'est disponible que lors de l'utilisation du compilateur Intel C++ et
lorsque le fichier d'en-tête emmintrin.h est inclus. Ce n'est pas un type de données C++ standard et n'est
pas pris en charge par d'autres compilateurs.
__m128i
est une définition de type dans le langage de programmation C++ qui représente une valeur
entière de 128 bits. Il s'agit d'un type de données intégré fourni par le compilateur Intel C++ à utiliser
avec les instructions Intel Streaming SIMD Extensions (SSE).
__m128i
Le type __m128i peut être utilisé pour stocker et manipuler des valeurs entières 128 bits d'une manière
optimisée pour une utilisation avec les instructions SSE. Il est destiné à être utilisé dans des applications
hautes performances, multimédias et scientifiques où les données doivent être traitées en parallèle.
Voici un exemple d'utilisation du type de données
__m128i
en C++ :
La sortie de ce programme sera :
m1 : [1, 2, 3, 4]
m2 : [5, 5, 5, 5]
Notez que le type de données __m128i n'est disponible que lors de l'utilisation du compilateur Intel C++ et
lorsque le fichier d'en-tête emmintrin.h est inclus. Ce n'est pas un type de données C++ standard et n'est
pas pris en charge par d'autres compilateurs.
__ptr32, __ptr64
et __ptr64 sont des spécificateurs de type dans le langage de programmation C++ qui sont utilisés
pour déclarer des pointeurs avec une taille spécifique. Ils sont fournis par le compilateur Microsoft Visual
C++ et sont destinés à être utilisés respectivement dans les applications 32 bits et 64 bits.
__ptr32
Le spécificateur __ptr32 déclare un pointeur 32 bits, qui est une adresse mémoire qui occupe 4 octets de
mémoire. Ce type de pointeur est utilisé dans les applications 32 bits, qui sont généralement limitées à
l'adressage de 4 Go de mémoire.
Le spécificateur __ptr64 déclare un pointeur 64 bits, qui est une adresse mémoire qui occupe 8 octets de
mémoire. Ce type de pointeur est utilisé dans les applications 64 bits, qui peuvent adresser plus de 4 Go
de mémoire.
Voici un exemple d'utilisation des spécificateurs de type
__ptr32
et
__ptr64
en C++ :
La sortie de ce programme dépendra de la taille des pointeurs sur votre système. Sur un système 32 bits,
la sortie sera :
p1 : 0x0012FF74
p2 : 0x0012FF74
Sur un système 64 bits, la sortie sera :
p1 : 0x00007FF75F4BFF74
p2 : 0x00007FF75F4BFF74
Notez que les spécificateurs de type __ptr32 et __ptr64 ne sont disponibles que lors de l'utilisation du
compilateur Microsoft Visual C++. Ce ne sont pas des spécificateurs de type C++ standard et ils ne sont
pas pris en charge par d'autres compilateurs.
Chapitre III
LIMITES NUMERIQUES
Limites numériques
En C++, le fichier d'en-tête <limits> définit un ensemble de modèles et de constantes qui fournissent des
informations sur la plage et la précision des types de données fondamentaux. Ces modèles et constantes
sont connus sous le nom de limites numériques.
Les limites numériques peuvent être utilisées pour déterminer les valeurs minimales et maximales
pouvant être représentées par un type de données donné, ainsi que la précision du type de données. Ils
peuvent être utiles pour s'assurer que les valeurs utilisées dans un programme se situent dans la plage de
valeurs pouvant être représentées par le type de données.
Voici un exemple d'utilisation des limites numériques en C++ :
La sortie de ce programme dépendra de l'implémentation de la bibliothèque standard C++ sur votre
système. Cela peut ressembler à ceci :
Valeur minimale de int : -2147483648
Valeur maximale de int : 2147483647
Précision du flotteur : 6 chiffres décimaux
Le fichier d'en-tête <limits> définit des modèles de limites numériques et des constantes pour tous les
types de données fondamentaux, notamment char , short , int , long , long long , float , double et long double .
Vous pouvez utiliser ces modèles et constantes pour déterminer la plage et la précision de n'importe
lequel de ces types de données.
Limites d'entiers
En C++, le fichier d'en-tête <limits> définit un ensemble de modèles et de constantes qui fournissent des
informations sur la plage et la précision des types de données entiers. Ces modèles et constantes sont
connus sous le nom de limites entières.
Les limites d'entiers peuvent être utilisées pour déterminer les valeurs minimales et maximales pouvant
être représentées par les types de données entiers, tels que char , short , int , long et long long . Ils peuvent
être utiles pour s'assurer que les valeurs utilisées dans un programme se situent dans la plage de valeurs
pouvant être représentées par le type de données.
Voici un exemple d'utilisation des limites d'entiers en C++ :
La sortie de ce programme
dépendra de l'implémentation de la bibliothèque standard C++ sur votre système. Cela peut ressembler à
ceci :
Limites flottantes
En C++, le fichier d'en-tête <limits> définit un ensemble de modèles et de constantes qui fournissent des
informations sur la plage et la précision des types de données à virgule flottante. Ces modèles et
constantes sont connus sous le nom de limites en virgule flottante.
Les limites en virgule flottante peuvent être utilisées pour déterminer les valeurs minimale et maximale
pouvant être représentées par les types de données en virgule flottante, tels que float , double et long double
. Ils peuvent également être utilisés pour déterminer la précision de ces types de données, c'est-à-dire le
nombre de chiffres décimaux de précision qu'ils peuvent représenter.
Voici un exemple d'utilisation des limites en virgule flottante en C++ :
le quatrième chapitre
Déclarations et définitions
En C++, les déclarations et les définitions sont deux concepts différents qui font référence à la manière
dont les variables, fonctions et autres entités sont introduites et utilisées dans un programme.
Une déclaration est une instruction qui introduit une entité et spécifie son type, son nom et d'autres
attributs. Il n'alloue aucune mémoire et n'exécute aucun code. Une déclaration peut être faite à l'aide du
mot-clé extern , qui indique que l'entité est définie dans une autre unité de traduction.
Une définition est une instruction qui crée une entité en allouant de la mémoire et en exécutant du code.
Il doit inclure une déclaration et peut également inclure des détails supplémentaires tels qu'une valeur
initiale ou un corps de fonction. Une définition doit être faite dans une seule unité de traduction, mais elle
peut être déclarée dans plusieurs unités de traduction à l'aide du mot-clé extern .
Voici un exemple de déclaration et de définition en C++ :
Dans cet exemple, la variable globale x est déclarée à l'aide du mot clé
définie dans une autre unité de traduction. Le local
extern
, ce qui signifie qu'elle est
Classes de stockage
En C++, les classes de stockage sont des mots clés qui spécifient la durée de vie et la visibilité des
variables et des fonctions. Ils déterminent comment les variables et les fonctions sont stockées en
mémoire et comment elles sont accessibles à partir de différentes parties d'un programme.
Il existe quatre classes de stockage en C++ :
1.
auto
: Il s'agit de la classe de stockage par défaut pour les variables locales. Il spécifie que la
variable est créée et détruite automatiquement lorsqu'elle sort de la portée.
2.
statique
3.
registre
4.
extern
: cette classe de stockage spécifie que la variable ou la fonction a un emplacement
mémoire fixe et une durée de vie qui s'étend sur toute la durée du programme. Il est souvent
utilisé pour créer des variables qui conservent leur valeur entre les appels de fonction.
: Cette classe de stockage spécifie que la variable doit être stockée dans un registre
plutôt que dans la mémoire principale. Cela peut améliorer les performances du programme
en réduisant le temps d'accès à la variable. Cependant, il n'est pas garanti que la variable soit
réellement stockée dans un registre, et le nombre de registres disponibles est souvent limité.
: cette classe de stockage spécifie que la variable ou la fonction est définie dans une
autre unité de traduction et est déclarée dans l'unité de traduction actuelle. Il est souvent
utilisé pour partager des variables et des fonctions entre plusieurs fichiers source.
Voici un exemple d'utilisation des classes de stockage en C++ :
auto
En C++, auto est une classe de stockage qui spécifie qu'une variable est créée et détruite
automatiquement lorsqu'elle sort de la portée. C'est la classe de stockage par défaut pour les variables
locales, qui sont des variables déclarées dans une fonction ou un bloc.
La classe de stockage automatique est utilisée pour créer des variables qui ont une durée de vie limitée et
ne sont accessibles que dans le bloc dans lequel elles sont déclarées. Lorsque le bloc se termine, la
variable est automatiquement détruite et la mémoire qu'elle occupe est libérée pour d'autres utilisations.
Voici un exemple d'utilisation de la classe de stockage
automatique
en C++ :
La sortie de ce programme sera :
x : 10
y : 20
Notez que la classe de stockage automatique n'est pas la même que le spécificateur de type automatique , qui est utilisé
pour déduire le type d'une variable à partir de son initialiseur. Par exemple:
constante
En C++, const est un qualificateur de type qui spécifie qu'un objet ne peut pas être modifié. Il peut être
appliqué à des variables, des fonctions et d'autres types d'objets pour indiquer que leur valeur ou leur
comportement ne peut pas être modifié.
Le qualificatif const peut être utilisé pour empêcher les modifications involontaires des variables et pour
s'assurer que les fonctions ne modifient pas leurs arguments ou leur état global. Il peut également être
utilisé pour améliorer la lisibilité et la maintenabilité d'un programme en rendant explicite le
comportement prévu des variables et des fonctions.
Voici un exemple d'utilisation du qualificatif
const
en C++ :
Le qualificatif const peut également être appliqué aux pointeurs et aux références pour indiquer que
l'objet pointé ou référencé ne peut pas être modifié. Par exemple:
constexpr
En C++,
constexpr
est un mot clé qui spécifie qu'une fonction ou une variable est une constante de
compilation. Cela indique que la valeur de la fonction ou de la variable peut être déterminée au moment
de la compilation, plutôt qu'au moment de l'exécution.
Le mot-clé constexpr peut être utilisé pour améliorer les performances d'un programme en permettant au
compilateur d'effectuer un pliage constant et d'autres techniques d'optimisation sur des expressions qui
utilisent des constantes de compilation. Il peut également être utilisé pour s'assurer que la valeur d'une
constante est connue au moment de la compilation, ce qui est requis dans certains contextes, comme lors
de l'initialisation de tableaux avec des expressions constantes.
Voici un exemple d'utilisation du mot-clé
constexpr
en C++ :
La sortie de ce programme sera :
x : 10
y : 20
carré
externe
En C++, extern est une classe de stockage qui spécifie qu'une variable ou une fonction est définie dans
une autre unité de traduction et est déclarée dans l'unité de traduction actuelle. Il est souvent utilisé pour
partager des variables et des fonctions entre plusieurs fichiers source.
La classe de stockage externe est utilisée pour déclarer des variables et des fonctions qui sont définies
dans une autre unité de traduction. Il n'alloue aucune mémoire et n'exécute aucun code. Au lieu de cela, il
indique au compilateur que la variable ou la fonction est définie ailleurs et est accessible à partir de
l'unité de traduction actuelle.
Voici un exemple d'utilisation de la classe de stockage
externe en C++ :
Dans cet exemple, la variable globale x et la fonction sum() sont déclarées dans le fichier d'en-tête
declarations.h à l'aide de la classe de stockage externe . Ils sont définis dans le fichier source definitions.cpp , qui
inclut le fichier d'en-tête. Le fichier source principal main.cpp comprend également le fichier d'en-tête, qui
lui permet d'accéder à la variable et à la fonction.
Notez que la classe de stockage extern n'est pas la même que le mot-clé extern , qui est utilisé pour indiquer qu'une
variable ou une fonction est définie
Initialiseurs
En C++, un initialiseur est une valeur ou une expression utilisée pour initialiser une variable lorsqu'elle
est déclarée. Il spécifie la valeur à laquelle la variable doit être initialisée lors de sa création.
Les initialiseurs peuvent être utilisés pour donner à une variable une valeur spécifique au moment où elle
est déclarée, plutôt que de lui affecter une valeur plus tard. Cela peut être utile pour définir la valeur
initiale d'une variable sur une constante ou pour fournir une valeur par défaut pour un argument de
fonction.
Il existe plusieurs façons de spécifier un initialiseur en C++ :
1. Utilisation d'une expression d'affectation : c'est la manière la plus courante d'initialiser une
variable. Il utilise l'opérateur d'affectation = pour spécifier la valeur initiale de la variable.
Par exemple:
int x = 10 ;
y double = 3,14 ;
car c = 'A';
2. Utilisation d'une liste d'initialisation : cette méthode est utilisée pour initialiser des variables
qui ont un type de données composé, telles que des tableaux et des structures. Il utilise une
liste de valeurs entre accolades pour spécifier les valeurs initiales des variables. Par exemple:
int a[3] = {1, 2, 3} ;
struct Point { int x, y; } p = {1, 2} ;
3. Utilisation d'un constructeur : cette méthode est utilisée pour initialiser des variables qui ont
un type défini par l'utilisateur, telles que des classes et des énumérations. Il utilise une
fonction constructeur pour créer et initialiser un objet du type souhaité. Par exemple:
Voici un exemple d'utilisation des initialiseurs dans
Alias et typedefs
En C++, un alias est un nouveau nom introduit pour un type ou un objet existant. Il vous permet d'utiliser
un nom différent pour faire référence au même type ou objet, ce qui peut améliorer la lisibilité et la
maintenabilité d'un programme.
Il existe deux manières de créer un alias en C++ :
1. Utilisation du mot-clé using : cette méthode vous permet de créer un alias pour n'importe quel
type ou objet, y compris les types intégrés, les types définis par l'utilisateur et les modèles. Il
utilise la syntaxe suivante :
en utilisant alias_name = type_name ;
Par exemple:
en utilisant Int = int ;
en utilisant Str = std::string;
2. Utilisation de typedef : cette méthode vous permet de créer un alias pour n'importe quel type,
y compris les types intégrés, les types définis par l'utilisateur et les modèles. Il utilise la
syntaxe suivante :
typedef nom_type nom_alias ;
Par exemple:
typedef int Entier ;
typedef std::string Str;
Voici un exemple d'utilisation des alias et des typedefs en C++ :
#include <iostream>
#include <chaîne>
// Crée un alias en utilisant le mot-clé 'using'
en utilisant Int = int ;
// Crée un alias en utilisant 'typedef'
typedef std::string Str;
int main() {
// Déclare et définit les variables en utilisant les alias
Int x = 10 ;
Str s = "Bonjour" ;
std::cout << "x: " << x << std::endl;
std::cout << "s: " << s << std::endl;
renvoie 0 ;
}
La sortie de ce programme sera :
x : 10
s : bonjour
Notez que le mot-clé typedef était largement utilisé en C++ avant l'introduction du mot-clé using , mais le
mot-clé using est maintenant considéré comme le moyen préféré pour créer des alias en C++. Il est plus
flexible et permet un code plus concis et expressif.
à l'aide de la déclaration
En C++, une déclaration using est une instruction qui introduit un nom d'un espace de noms dans la portée actuelle. Il vous
permet d'utiliser le nom sans spécifier l'espace de noms dans lequel il est défini.
Une déclaration using est souvent utilisée pour éviter de taper le nom complet de l'espace de noms chaque
fois que vous souhaitez utiliser un nom de l'espace de noms. Il peut également être utilisé pour amener
plusieurs noms du même espace de noms ou d'espaces de noms différents dans la même portée, ce qui
peut améliorer la lisibilité et la maintenabilité d'un programme.
Voici un exemple d'utilisation d'une déclaration
using
en C++ :
La sortie de ce programme sera :
x : 10
foo ::y: 20
Vous pouvez également utiliser une déclaration using pour amener plusieurs noms du même espace de
noms ou d'espaces de noms différents dans la même portée, comme ceci :
volatil
En C++, volatile est un qualificateur de type qui spécifie qu'une variable peut être modifiée par un
processus externe ou par du matériel. Il indique que la valeur de la variable peut changer de manière
inattendue, même si elle ne semble pas avoir été modifiée dans le programme.
Le qualificatif volatile est utilisé pour empêcher le compilateur d'effectuer certaines optimisations sur une
variable, comme la mise en cache de sa valeur dans un registre ou l'optimisation de son accès. Il est
souvent utilisé pour les variables partagées avec le matériel ou avec d'autres processus, tels que les
registres d'E/S mappés en mémoire ou les variables globales accessibles par plusieurs threads.
Voici un exemple d'utilisation du qualificatif
volatile
en C++ :
La sortie de ce programme sera :
x : 10
x : 20
Notez que le qualificateur volatile n'est pas le même que le mot-clé volatile , qui est utilisé pour indiquer qu'une
variable ou une fonction peut être modifiée par un processus externe ou par du matériel. Le qualificatif
volatile est utilisé pour indiquer qu'une variable peut être modifiée par un processus externe ou par du
matériel, alors que le mot-clé volatile est utilisé pour déclarer une variable ou une fonction
decltype
En C++, decltype est un mot clé qui vous permet de déterminer le type d'une expression. Il est souvent
utilisé pour déduire le type d'une variable ou d'une fonction à partir de son initialiseur ou de son type de
retour.
Le mot-clé decltype est utilisé pour spécifier le type d'une variable ou d'une fonction en évaluant une
expression ou un type-id. Il est souvent utilisé en conjonction avec le mot-clé auto pour déduire le type
d'une variable à partir de son initialiseur.
Voici un exemple d'utilisation du mot clé
decltype
en C++ :
La sortie de ce programme sera :
Type de a : entier
Type de b : double
Vous pouvez également utiliser le mot-clé decltype pour déterminer le type de retour d'une fonction en
spécifiant le nom de la fonction en tant qu'expression. Par exemple:
Les attributs
En C++, les attributs sont des métadonnées supplémentaires qui peuvent être associées à une fonction,
une variable, un type ou une autre construction de langage. Ils vous permettent de fournir des
informations supplémentaires ou de spécifier certains comportements pour la conception, tels que son
alignement, sa visibilité ou sa plate-forme cible.
Les attributs sont spécifiés à l'aide de la syntaxe [[attribute]] , qui est suivie du nom de l'attribut et de tout
argument supplémentaire. Ils peuvent être appliqués aux déclarations et définitions de fonctions,
variables, types et autres constructions.
C++ a un certain nombre d'attributs prédéfinis qui sont spécifiés dans le fichier d'en-tête
Voici quelques exemples d'attributs prédéfinis :
<attributes>
.
: Indique qu'une fonction ne retourne pas à son appelant.
[[noreturn]]
: indique qu'une fonction peut porter une dépendance entre l'un de ses
arguments et sa valeur de retour.
[[carries_dependency]]
[[obsolète]]
: indique qu'une fonction ou un type est obsolète et ne doit pas être utilisé.
[[nodiscard]]
: Indique que la valeur de retour d'une fonction ne doit pas être ignorée.
Voici un exemple d'utilisation des attributs en C++ :
Dans cet exemple, la fonction
exit()
est déclarée avec l' attribut
[[noreturn]]
, qui indique qu'elle
Chapitre V
Opérateurs intégrés, priorité et association
En C++, les opérateurs sont des symboles spéciaux qui effectuent des opérations spécifiques sur un, deux
ou trois opérandes et produisent un résultat. Les opérateurs peuvent être classés comme unaires, binaires
ou ternaires en fonction du nombre d'opérandes dont ils ont besoin.
C++ possède un ensemble d'opérateurs intégrés prédéfinis par le langage et utilisables dans n'importe
quel programme. Ces opérateurs peuvent être regroupés dans les catégories suivantes :
1. Opérateurs arithmétiques : ces opérateurs effectuent des calculs arithmétiques sur des
opérandes, tels que l'addition, la soustraction, la multiplication et la division.
2. Opérateurs de comparaison : ces opérateurs comparent deux opérandes et renvoient une
valeur booléenne indiquant si la comparaison est vraie ou fausse.
3. Opérateurs logiques : ces opérateurs effectuent des opérations logiques sur les opérandes,
telles que AND, OR et NOT.
4. Opérateurs au niveau du bit : ces opérateurs effectuent des opérations au niveau du bit sur
les opérandes, telles que AND, OR, XOR et NOT.
5. Opérateurs d'affectation : ces opérateurs attribuent une valeur à une variable.
6. Opérateurs d'incrémentation et de décrémentation : ces opérateurs augmentent ou diminuent
la valeur d'une variable de 1.
7. Opérateur conditionnel : cet opérateur sélectionne l'un des deux opérandes en fonction d'une
condition booléenne.
Les opérateurs ont une priorité, qui détermine l'ordre dans lequel ils sont évalués dans une expression.
Les opérateurs de priorité supérieure sont évalués avant les opérateurs de priorité inférieure.
Les opérateurs ont également une associativité, qui détermine l'ordre dans lequel ils sont évalués
lorsqu'ils ont la même priorité. Les opérateurs avec une associativité de gauche à droite sont évalués de
gauche à droite, tandis que les opérateurs avec une associativité de droite à gauche sont évalués de droite
à gauche.
opérateur alignof
En C++, l' opérateur alignof est un mot clé qui détermine l'exigence d'alignement d'un type ou d'une
expression. Il renvoie l'alignement minimum requis pour un objet du type spécifié, en octets.
L' opérateur alignof est utilisé pour déterminer l'exigence d'alignement d'un type ou d'une expression afin
d'allouer de la mémoire pour un objet de ce type. Il est souvent utilisé en conjonction avec le spécificateur
alignas pour spécifier l'alignement d'une variable ou d'un type.
Voici un exemple d'utilisation de l' opérateur
alignof
en C++ :
La sortie de ce programme sera :
alignof(S) : 4 octets
alignof(int): 4 octets
Notez que l' opérateur
alignof
n'est pas le même que le spécificateur
alignas
, qui est utilisé pour spécifier
l'alignement d'une variable ou d'un type. L' opérateur
d'alignement d'un type ou d'une expression
alignof
est utilisé pour déterminer l'exigence
Opérateur __uuidof
En C++, l' opérateur __uuidof est un opérateur spécifique à Microsoft qui renvoie l'identificateur universel
unique (UUID) d'un type. Il est utilisé pour identifier un type, une interface ou un composant dans un
programme COM (Component Object Model).
L' opérateur __uuidof est utilisé pour récupérer l'UUID d'un type ou d'une interface afin de créer une
instance de l'objet ou d'interroger les informations de type de l'objet. Il est souvent utilisé conjointement
avec la fonction CoCreateInstance pour créer une instance d'un objet COM.
Voici un exemple d'utilisation de l' opérateur
__uuidof
en C++ :
Dans cet exemple, l' opérateur __uuidof est utilisé pour récupérer l'UUID de l' interface IUnknown , qui est
une interface fondamentale dans la programmation COM. L'UUID est ensuite passé à la fonction
CoCreateInstance pour créer une instance de l' interface IUnknown .
Notez que l' opérateur __uuidof est un opérateur spécifique à Microsoft et ne fait pas partie du langage
C++ standard. Il n'est disponible que sur les plates-formes prenant en charge la programmation COM.
Opérateurs additifs : + et En C++, les opérateurs + et - sont des opérateurs additifs qui effectuent respectivement une addition et
une soustraction. Ils peuvent être utilisés pour ajouter ou soustraire deux opérandes de types identiques
ou compatibles, et produire un résultat du même type que les opérandes.
L' opérateur + est un opérateur binaire qui additionne deux opérandes et renvoie leur somme. Il peut être
utilisé avec des opérandes de tout type arithmétique, y compris des nombres entiers, des nombres à
virgule flottante et des nombres complexes.
L' opérateur - est également un opérateur binaire qui soustrait un opérande à un autre et renvoie la
différence. Il peut être utilisé avec des opérandes de tout type arithmétique, y compris des nombres
entiers, des nombres à virgule flottante et des nombres complexes.
Voici un exemple d'utilisation des opérateurs
+
et
- en C++ :
La sortie de ce programme sera :
x + y = 30
x - y = -10
Notez que les opérateurs + et - peuvent également être utilisés comme opérateurs unaires, auquel cas ils
opèrent sur un seul opérande. L' opérateur + renvoie l'opérande inchangé, tandis que l' opérateur renvoie le négatif
Adresse de l'opérateur : &
En C++, l' opérateur & est l'opérateur d'adresse de, qui renvoie l'adresse mémoire d'une variable ou d'un
objet. C'est un opérateur unaire qui prend un seul opérande et renvoie un pointeur sur l'opérande.
L' opérateur & permet d'obtenir l'adresse mémoire d'une variable ou d'un objet afin d'y accéder
directement ou de le passer en argument à une fonction. Il est souvent utilisé en conjonction avec des
variables de pointeur pour manipuler la valeur de l'objet pointé.
Voici un exemple d'utilisation de l' opérateur
&
en C++ :
La sortie de ce programme sera :
x : 10
&x : 0x7ffdc91a6884
px : 0x7ffdc91a6884
Dans cet exemple, l' opérateur & est utilisé pour obtenir l'adresse mémoire de la variable x , qui est stockée dans le
pointeur px . La valeur de x est alors accessible directement par le pointeur à l'aide de l' opérateur
comme ceci :
*px = 20 ;
std::cout << "x: " << x << std::endl;
*,
La sortie de ce code sera :
x : 20
Notez que l' opérateur & a une priorité plus élevée que l' opérateur * , il est donc évalué avant l'
opérateur * . Par exemple, l'expression *&x est équivalente à x , alors que l'expression &*x est
équivalente à x si x est un pointeur,
Opérateurs d'affectation
En C++, les opérateurs d'affectation sont utilisés pour affecter une valeur à une variable. L'opérateur
d'affectation le plus basique est l' opérateur = , qui affecte la valeur de l'opérande de droite à l'opérande
de gauche.
C++ possède également un certain nombre d'opérateurs d'affectation composés, qui effectuent une
opération sur l'opérande de gauche et affectent le résultat à l'opérande de gauche. Ces opérateurs
comprennent :
: Ajouter l'opérande de droite à l'opérande de gauche et affecter le résultat à l'opérande
de gauche.
+=
: Soustrayez l'opérande de droite de l'opérande de gauche et affectez le résultat à
l'opérande de gauche.
-=
: Multipliez l'opérande de gauche par l'opérande de droite et affectez le résultat à
l'opérande de gauche.
*=
: divise l'opérande de gauche par l'opérande de droite et affecte le résultat à l'opérande de
gauche.
/=
: Calcule le reste de l'opérande de gauche divisé par l'opérande de droite et affecte le
résultat à l'opérande de gauche.
%=
Voici un exemple d'utilisation des opérateurs d'affectation en C++ :
Opérateur ET au niveau du bit : &
En C++, l' opérateur & est l'opérateur ET au niveau du bit, qui effectue une opération ET au niveau du
bit sur deux opérandes et renvoie le résultat. C'est un opérateur binaire qui prend deux opérandes de type
intégral et renvoie un résultat du même type que les opérandes.
L'opérateur ET au niveau du bit compare chaque bit du premier opérande au bit correspondant du
deuxième opérande, et si les deux bits sont 1, le bit de résultat correspondant est défini sur 1. Sinon, le
bit de résultat est défini sur 0.
Voici un exemple d'utilisation de l'opérateur ET au niveau du bit en C++ :
La sortie de ce programme sera :
x&y=0
Dans cet exemple, l'opérateur AND au niveau du bit est utilisé pour effectuer une opération AND au
niveau du bit sur les variables x et y . Le résultat est stocké dans la variable z , qui a une valeur de 0 en décimal.
Notez que l'opérateur ET au niveau du bit a une priorité plus élevée que l' opérateur = , il est donc évalué
avant l'affectation. Par exemple, l'expression x = y & z est équivalente à x = (y & z) , alors que l'expression x
&= y est équivalente à x = x & y .
Opérateur OU exclusif au niveau du bit : ^
En C++, l' opérateur ^ est l'opérateur OR exclusif au niveau du bit (XOR), qui effectue une opération
XOR au niveau du bit sur deux opérandes et renvoie le résultat. C'est un opérateur binaire qui prend deux
opérandes de type intégral et renvoie un résultat du même type que les opérandes.
L'opérateur XOR au niveau du bit compare chaque bit du premier opérande au bit correspondant du
deuxième opérande, et si l'un des bits est 1 et l'autre est 0, le bit de résultat correspondant est défini sur
1. Sinon, le bit de résultat est défini à 0.
Voici un exemple d'utilisation de l'opérateur XOR au niveau du bit en C++ :
La sortie de ce programme sera :
x ^ y = 15
Dans cet exemple, l'opérateur XOR au niveau du bit est utilisé pour effectuer une opération XOR au
niveau du bit sur les variables x et y . Le résultat est stocké dans la variable z , qui a une valeur de 15 en décimal.
Notez que l'opérateur XOR au niveau du bit a une priorité plus élevée que l' opérateur = , il est donc
évalué avant l'affectation. Par exemple, l'expression x = y ^ z est équivalente à x = (y ^ z) , alors que
l'expression x ^= y est équivalente à x = x ^ y .
Opérateur OU inclusif au niveau du bit : |
En C++, le | L'opérateur est l'opérateur OU inclusif au niveau du bit (OU), qui effectue une opération OU
au niveau du bit sur deux opérandes et renvoie le résultat. C'est un opérateur binaire qui prend deux
opérandes de type intégral et renvoie un résultat du même type que les opérandes.
L'opérateur OU au niveau du bit compare chaque bit du premier opérande au bit correspondant du
deuxième opérande, et si l'un des bits est 1, le bit de résultat correspondant est défini sur 1. Sinon, le bit
de résultat est défini sur 0.
Voici un exemple d'utilisation de l'opérateur OR au niveau du bit en C++ :
La sortie de ce programme sera :
x | y = 15
Dans cet exemple, l'opérateur OU au niveau du bit est utilisé pour effectuer une opération OU au niveau
du bit sur les variables x et y . Le résultat est stocké dans la variable z , qui a une valeur de 15 en décimal.
Notez que l'opérateur OU au niveau du bit a une priorité plus élevée que l' opérateur = , il est donc
évalué avant l'affectation. Par exemple, l'expression x = y | z est équivalent à x = (y | z) , alors que
l'expression x |= y est équivalente à x = x | y .
Opérateur Cast : ()
En C++, l' opérateur () est l'opérateur de cast, qui est utilisé pour convertir explicitement une valeur d'un
type à un autre. C'est un opérateur unaire qui prend un seul opérande et un type comme opérandes, et
renvoie une valeur du type spécifié.
L'opérateur cast est utilisé pour convertir une valeur d'un type à un autre lorsqu'une conversion implicite
n'est pas possible ou souhaitée. Il est souvent utilisé pour convertir des valeurs entre des types de base,
tels que des entiers et des nombres à virgule flottante, ou pour convertir des pointeurs entre différents
types.
Voici un exemple d'utilisation de l'opérateur cast en C++ :
La sortie de ce programme sera :
y=3
Dans cet exemple, l'opérateur cast est utilisé pour convertir la variable x , qui a un type de double , en int et
stocker le résultat dans la variable y . La valeur de x est tronquée en entier lorsqu'elle est convertie en
.
Notez que l'opérateur cast a une priorité plus élevée que l' opérateur = , il est donc évalué avant
l'affectation. Par exemple, l'expression x = (int)y est équivalente à x = (int)(y) , tandis que l'expression
int(y) est également équivalente à x = (int)(y) .
int
x=
C++ fournit également un certain nombre d'opérateurs de conversion de type sécurisé, tels que
dynamic_cast , static_cast , const_cast et reinterpret_cast , qui effectuent des types de conversions plus spécialisés.
Ces opérateurs sont souvent utilisés conjointement avec l'héritage et le polymorphisme pour effectuer des
conversions entre types apparentés.
Opérateur de virgule : ,
En C++, l' opérateur , est l'opérateur virgule, qui sépare deux ou plusieurs opérandes et les évalue de
gauche à droite. C'est un opérateur binaire qui prend deux opérandes ou plus et renvoie la valeur de
l'opérande de droite.
L'opérateur virgule est souvent utilisé pour inclure plusieurs expressions dans une seule instruction, où
chaque expression est séparée par une virgule. Seule la valeur de l'opérande de droite est utilisée dans le
résultat final, tandis que les valeurs des autres opérandes sont ignorées.
Voici un exemple d'utilisation de l'opérateur virgule en C++ :
La sortie de ce programme sera :
z = 32
Dans cet exemple, l'opérateur virgule est utilisé pour évaluer les expressions x++ et y++ , qui
incrémentent les valeurs de x et y , respectivement. La valeur de x + y est ensuite calculée et affectée à la
variable z .
Notez que l'opérateur virgule a une priorité inférieure à la plupart des autres opérateurs, il est donc
généralement évalué après les autres opérateurs. Par exemple, l'expression x = y, z est équivalente à
z , alors que l'expression x = y + z est équivalente à x = (y + z) .
(x = y),
Opérateur conditionnel : ? :
En C++, le ? : L'opérateur est l'opérateur conditionnel, également appelé opérateur ternaire, qui est
utilisé pour évaluer une expression conditionnelle. C'est un opérateur ternaire qui prend trois opérandes
et renvoie une valeur basée sur le résultat de l'expression conditionnelle.
L'opérateur conditionnel est souvent utilisé comme forme abrégée d'une instruction if , où le premier
opérande est une condition booléenne, le deuxième opérande est la valeur à renvoyer si la condition est
vraie et le troisième opérande est la valeur à renvoyer si la condition est fausse.
Voici un exemple d'utilisation de l'opérateur conditionnel en C++ :
La sortie de ce programme sera :
z = 10
Dans cet exemple, l'opérateur conditionnel est utilisé pour évaluer la condition x < y . Si la condition est
vraie, la valeur de x est renvoyée ; sinon, la valeur de y est renvoyée. Le résultat est stocké dans la
variable z .
Notez que l'opérateur conditionnel a une priorité inférieure à l'opérateur d'affectation, il est donc
généralement évalué après l'affectation. Par exemple, l'expression x = y ? z : w est équivalent à x = (y ? z : w) ,
alors que l'expression x ? y = z : w = t est équivalent à (x ? (y = z) : (w = t)) .
opérateur de suppression
En C++, l' opérateur delete est utilisé pour libérer de la mémoire précédemment allouée par l' opérateur
new . C'est un opérateur unaire qui prend un pointeur comme opérande et libère la mémoire pointée par le
pointeur.
L' opérateur de suppression est utilisé pour libérer la mémoire occupée par un objet ou un tableau créé à
l'aide de l' opérateur new . Il est important d'utiliser l' opérateur de suppression pour libérer de la mémoire
lorsqu'elle n'est plus nécessaire, afin d'éviter les fuites de mémoire et d'autres problèmes liés à la
mémoire.
Voici un exemple d'utilisation de l' opérateur
delete
en C++ :
Dans cet exemple, le nouvel opérateur est utilisé pour allouer dynamiquement de la mémoire pour un objet
int et affecter l'adresse de l'objet au pointeur p . La valeur de l'objet est alors initialisée à 10. L' opérateur
de suppression est alors utilisé pour désallouer la mémoire pointée par p .
Notez que l' opérateur de suppression ne doit être utilisé que pour libérer de la mémoire précédemment
allouée à l'aide de l' opérateur new . Il ne doit pas être utilisé pour libérer de la mémoire qui a été allouée
sur la pile ou en utilisant d'autres techniques de gestion de la mémoire, telles que malloc() et free() .
Opérateurs d'égalité : == et !=
En C++, les opérateurs == et != sont respectivement les opérateurs d'égalité et d'inégalité, qui sont
utilisés pour comparer deux valeurs d'égalité ou d'inégalité. Ce sont des opérateurs binaires qui prennent
deux opérandes et renvoient une valeur booléenne indiquant si les opérandes sont égaux ou inégaux.
L'opérateur d'égalité == compare les valeurs de ses opérandes et renvoie vrai s'ils sont égaux et faux s'ils
ne sont pas égaux. L'opérateur d'inégalité != compare les valeurs de ses opérandes et renvoie vrai s'ils ne
sont pas égaux, et faux s'ils sont égaux.
Voici un exemple d'utilisation des opérateurs d'égalité et d'inégalité en C++ :
La sortie de ce programme sera :
x
x
x
x
== y : 0
!= y : 1
== z : 1
!= z : 0
Dans cet exemple, les opérateurs d'égalité et d'inégalité sont utilisés pour comparer les valeurs des
variables x , y et z . Les résultats des comparaisons sont imprimés sur la console.
Notez que les opérateurs d'égalité et d'inégalité ont une priorité inférieure à la plupart des autres
opérateurs, ils sont donc généralement évalués après les autres opérateurs. Par exemple, l'expression
y == z est équivalente à x = (y == z) , alors que l'expression x == y = z est équivalente à (x == (y = z)) .
x=
Opérateur de conversion de type explicite : ()
En C++, l' opérateur () est l'opérateur de conversion de type explicite, qui est utilisé pour convertir
explicitement une valeur d'un type à un autre. C'est un opérateur unaire qui prend un seul opérande et un
type comme opérandes, et renvoie une valeur du type spécifié.
L'opérateur de conversion de type explicite est utilisé pour convertir une valeur d'un type à un autre
lorsqu'une conversion implicite n'est pas possible ou souhaitée. Il est souvent utilisé pour convertir des
valeurs entre des types de base, tels que des entiers et des nombres à virgule flottante, ou pour convertir
des pointeurs entre différents types.
Voici un exemple d'utilisation de l'opérateur de conversion de type explicite en C++ :
La sortie de ce programme sera :
y=3
Dans cet exemple, l'opérateur de conversion de type explicite est utilisé pour convertir la variable x , qui a
un type de double , en int et stocker le résultat dans la variable y . La valeur de x est tronquée en entier
lorsqu'elle est convertie en int .
Notez que l'opérateur de conversion de type explicite a une priorité plus élevée que l' opérateur = , il est
donc évalué avant l'affectation. Par exemple, l'expression x = int(y) est équivalente à x = (int)(y) , tandis que
l'expression x = y + int(z) est équivalente à x = (y + (int)(z)) .
C++ fournit également un certain nombre d'opérateurs de conversion de type sécurisé, tels que
dynamic_cast , static_cast , const_cast et reinterpret_cast , qui effectuent des types de conversions plus spécialisés.
Ces opérateurs sont souvent utilisés conjointement avec l'héritage et le polymorphisme pour effectuer des
conversions entre types apparentés.
Opérateur d'appel de fonction : ()
En C++, l' opérateur () est l'opérateur d'appel de fonction, qui est utilisé pour appeler une fonction et
exécuter son code. C'est un opérateur unaire qui prend un nom de fonction et une liste d'arguments
comme opérandes et renvoie une valeur du type de retour de la fonction.
L'opérateur d'appel de fonction est utilisé pour invoquer une fonction et lui transmettre des arguments.
Les arguments sont spécifiés entre parenthèses et sont séparés par des virgules. L'opérateur d'appel de
fonction peut également être utilisé pour invoquer une fonction via un pointeur de fonction ou une
fonction membre d'une classe.
Voici un exemple d'utilisation de l'opérateur d'appel de fonction en C++ :
La sortie de ce programme sera :
z = 30
Dans cet exemple, la fonction
add()
est définie pour prendre deux arguments
int et renvoyer leur somme.
L'opérateur d'appel de fonction est ensuite utilisé pour invoquer la fonction add() et transmettre les
valeurs de x et y comme arguments. Le résultat de l'appel de la fonction est stocké dans la variable
z.
Notez que l'opérateur d'appel de fonction a une priorité plus élevée que l'opérateur d'affectation, il est
donc évalué avant l'affectation. Par exemple, l'expression x = add(y, z) est équivalente à x = (add(y, z)) , alors
que l'expression x = y + add(z, w) est équivalente à x = (y + (add (z, w))) .
Opérateur d'indirection : *
En C++, l' opérateur * est l'opérateur d'indirection, également appelé opérateur de déréférencement, qui
est utilisé pour accéder à la valeur stockée à une adresse mémoire. C'est un opérateur unaire qui prend
un pointeur comme opérande et renvoie la valeur pointée par le pointeur.
L'opérateur d'indirection est souvent utilisé en conjonction avec des pointeurs pour accéder à la valeur
stockée à l'adresse mémoire pointée par le pointeur. Il est également utilisé pour déclarer des pointeurs,
où il est placé devant le nom de la variable pour indiquer que la variable est un pointeur.
Voici un exemple d'utilisation de l'opérateur d'indirection en C++ :
La sortie de ce programme sera :
x = 10
*p = 10
Dans cet exemple, le pointeur p est déclaré et initialisé à l'adresse de la variable x . L'opérateur
d'indirection est alors utilisé pour accéder à la valeur stockée à l'adresse mémoire pointée par p , qui est
la valeur de la variable x .
Notez que l'opérateur d'indirection a une priorité plus élevée que l'opérateur d'affectation, il est donc
évalué avant l'affectation. Par exemple, l'expression x = *p est équivalente à x = (*p) , tandis que
l'expression x = *p + y est équivalente à x = (*p) + y .
Opérateurs de décalage à gauche et à droite (>> et <<)
En C++, les opérateurs << et >> sont respectivement les opérateurs de décalage vers la gauche et vers
la droite, qui sont utilisés pour effectuer un décalage de bits sur des valeurs entières. Ce sont des
opérateurs binaires qui prennent deux opérandes, une valeur entière et un nombre de décalages, et
renvoient une valeur correspondant à la valeur d'origine décalée vers la gauche ou vers la droite du
nombre de bits spécifié.
L'opérateur de décalage à gauche << décale les bits de son premier opérande vers la gauche du nombre
de positions spécifié dans le deuxième opérande. L'opérateur de décalage vers la droite >> décale les bits
de son premier opérande vers la droite du nombre de positions spécifié dans le deuxième opérande.
Voici un exemple d'utilisation des opérateurs de décalage vers la gauche et vers la droite en C++ :
La sortie de ce programme sera :
x << y = 80
x >> y = 1
Dans cet exemple, l'opérateur de décalage à gauche << est utilisé pour décaler les bits de la variable x
vers la gauche de 3 positions, et l'opérateur de décalage à droite >> est utilisé pour décaler les bits de la
variable x vers la droite de 3 positions . Les résultats des opérations de décalage sont imprimés sur la console.
Notez que les opérateurs de décalage vers la gauche et vers la droite ont une priorité plus élevée que les
opérateurs d'addition et de soustraction, ils sont donc généralement évalués avant ces opérateurs. Par
exemple, l'expression x << y + z est équivalente à x << (y + z) , alors que l'expression x + y << z est
équivalente à (x + y) << z .
Opérateur ET logique : &&
En C++, l' opérateur && est l'opérateur ET logique, qui est utilisé pour effectuer une opération ET
logique sur deux valeurs booléennes. C'est un opérateur binaire qui prend deux opérandes booléens et
renvoie une valeur booléenne indiquant le résultat de l'opération logique ET.
L'opérateur ET logique && effectue une évaluation en court-circuit de ses opérandes, ce qui signifie qu'il
n'évalue le deuxième opérande que si le premier opérande est vrai . Si le premier opérande est faux , le
deuxième opérande n'est pas évalué et le résultat de l' opérateur && est faux . Cela peut être utile pour
optimiser le code et éviter les calculs inutiles.
Voici un exemple d'utilisation de l'opérateur logique AND en C++ :
La sortie de ce programme sera :
x && y : 0
x && z : 1
y && z : 0
Dans cet exemple, l'opérateur logique ET && est utilisé pour effectuer des opérations logiques ET sur les
variables x , y et z . Les résultats des opérations && sont imprimés sur la console.
Notez que l'opérateur logique ET a une priorité plus élevée que l'opérateur logique OU || , il est donc
généralement évalué avant le || opérateur. Par exemple, l'expression x && y || z est équivalent à (x && y) || z ,
alors que l'expression x || y && z est équivalent à `x || (y && z)
Opérateur de négation logique : !
En C++, le ! L'opérateur est l'opérateur de négation logique, qui est utilisé pour nier une valeur
booléenne. C'est un opérateur unaire qui prend un opérande booléen et renvoie la valeur négative.
L'opérateur de négation logique
l'opérande est vrai , le ! renvoie
!
nie la valeur de son opérande en inversant sa valeur de vérité. Si
, et si l'opérande est false , le ! l'opérateur renvoie vrai .
false
Voici un exemple d'utilisation de l'opérateur de négation logique en C++ :
La sortie de ce programme sera :
!x : 0
!y : 1
Dans cet exemple, l'opérateur de négation logique ! est utilisé pour inverser les valeurs des variables
y . Les résultats du ! les opérations sont imprimées sur la console.
x
et
Notez que l'opérateur de négation logique a une priorité plus élevée que les opérateurs logiques ET et OU
&& et || , il est donc généralement évalué avant ces opérateurs. Par exemple, l'expression !x && y est
équivalente à (!x) && y , alors que l'expression x || !y est équivalent à x || (!y) .
Opérateur logique OU : ||
En C++, le || L'opérateur est l'opérateur logique OU, qui est utilisé pour effectuer une opération logique
OU sur deux valeurs booléennes. C'est un opérateur binaire qui prend deux opérandes booléens et
renvoie une valeur booléenne indiquant le résultat de l'opération logique OU.
L'opérateur logique OU || effectue une évaluation en court-circuit de ses opérandes, ce qui signifie qu'il
n'évalue le deuxième opérande que si le premier opérande est faux . Si le premier opérande est true , le
deuxième opérande n'est pas évalué et le résultat du || l'opérateur est vrai . Cela peut être utile pour
optimiser le code et éviter les calculs inutiles.
Voici un exemple d'utilisation de l'opérateur logique OR en C++ :
La sortie de ce programme sera :
x || y : 1
x || z : 1
y || z : 1
Dans cet exemple, l'opérateur logique OR
||
est utilisé pour effectuer des opérations OU logiques sur les
variables
x
,
y
et
z.
Les résultats du
||
les opérations sont imprimées sur la console.
Notez que l'opérateur logique OU a une priorité inférieure à l'opérateur logique ET && , il est donc
généralement évalué après l' opérateur && . Par exemple, l'expression x || y && z est équivalent à x || (y && z)
, alors que l'expression x && y || z est équivalent à (x && y) || z .
Opérateurs d'accès membres : . et ->
En C++, le . et -> les opérateurs sont les opérateurs d'accès aux membres, qui sont utilisés pour accéder
aux membres de données et aux fonctions membres d'une classe ou d'un struct. Ce sont des opérateurs
binaires qui prennent un objet ou un pointeur vers un objet comme opérande gauche et le nom d'un
membre de données ou d'une fonction membre comme opérande droit.
Le . L'opérateur est utilisé pour accéder aux membres de données et aux fonctions membres d'un objet,
tandis que l' opérateur -> est utilisé pour accéder aux membres de données et aux fonctions membres
d'un pointeur vers un objet. L' opérateur -> équivaut à utiliser l' opérateur * pour déréférencer le
pointeur et le . opérateur pour accéder au membre de données ou à la fonction membre.
Voici un exemple d'utilisation des opérateurs d'accès aux membres en C++ :
La sortie de ce programme sera :
(30, 40)
(70, 80)
Dans cet exemple, la classe Point est définie avec deux données membres x et y , et deux fonctions
membres set() et print() . La fonction main() crée un objet Point p et un pointeur vers un objet Point q . Les
opérateurs d'accès membres
membres des objets p et q .
.
et
->
sont utilisés pour accéder aux données membres et aux fonctions
Notez que les opérateurs d'accès aux membres ont une priorité plus élevée que l'opérateur d'affectation =
, ils sont donc généralement évalués avant l'affectation. Par exemple, l'expression px = y est équivalente à
(px) = y , alors que l'expression x = py est équivalente à x = (py) .
Opérateurs multiplicatifs et opérateur de module
En C++, les opérateurs * , / et % sont respectivement les opérateurs multiplicatifs et l'opérateur de
module, qui sont utilisés pour effectuer des opérations de multiplication, de division et de module sur des
valeurs entières et à virgule flottante. Ce sont des opérateurs binaires qui prennent deux opérandes et
renvoient une valeur qui est le résultat de l'opération de multiplication, de division ou de module.
L' opérateur * est l'opérateur de multiplication, qui multiplie ses opérandes et renvoie le produit. L'
opérateur / est l'opérateur de division, qui divise son premier opérande par son deuxième opérande et
renvoie le quotient. L' opérateur % est l'opérateur de module, qui renvoie le reste de la division de son
premier opérande par son deuxième opérande.
Voici un exemple d'utilisation des opérateurs multiplicatifs et de l'opérateur de module en C++ :
La sortie de ce programme sera :
x * y = 30
x/y=3
x%y=1
x * z = 55
x / z = 1,81818
z / x = 0,55
Dans cet exemple, les opérateurs multiplicatifs * , / et % sont utilisés pour effectuer des opérations de
multiplication, de division et de module sur les variables x , y et z . Les résultats des opérations sont
imprimés sur la console.
Notez que les opérateurs multiplicatifs et l'opérateur de module ont une priorité plus élevée que les
opérateurs additifs + et - , ils sont donc généralement évalués avant ces opérateurs. Par exemple,
l'expression x * y + z est équivalente à (x * y) + z , tandis que l'expression x + y * z est équivalente à x + (y * z) .
nouvel opérateur
En C++, le nouvel opérateur est utilisé pour allouer dynamiquement de la mémoire à partir du tas pour un
objet ou un tableau d'objets. Il s'agit d'un opérateur unaire qui prend un type et une expression
d'initialisation facultative comme opérande et renvoie un pointeur vers la mémoire nouvellement allouée.
L' opérateur new est souvent utilisé pour créer des objets qui ont une durée de vie plus longue que les
variables locales, ou pour créer des objets qui sont plus grands que la mémoire de pile disponible. Il est
généralement associé à l' opérateur de suppression pour libérer la mémoire lorsqu'elle n'est plus nécessaire.
Voici un exemple d'utilisation de l' opérateur
new
en C++ :
La sortie de ce programme sera :
p: (10, 20)
q[0] : (1, 2)
q[4] : (9, 10)
Dans cet exemple, le nouvel opérateur est utilisé pour allouer dynamiquement de la mémoire pour un seul
objet Point et un tableau d' objets Point . L' opérateur de suppression est utilisé pour libérer la mémoire
lorsqu'elle n'est plus nécessaire. Les opérateurs d'accès aux membres -> et [] sont utilisés pour accéder
aux données membres des objets.
Notez que le nouvel opérateur lève une exception std::bad_alloc s'il ne parvient pas à allouer la mémoire
demandée, il est donc généralement utilisé dans un bloc try-catch pour gérer l'exception. Il est également
recommandé d'utiliser les opérateurs new et delete de manière cohérente, car leur mélange avec les
fonctions malloc() et free() de la bibliothèque standard C peut entraîner un comportement indéfini.
Opérateur complément à un : ~
En C++, l' opérateur ~ est l'opérateur de complément à un, qui est utilisé pour effectuer une opération
NOT au niveau du bit sur une valeur entière. C'est un opérateur unaire qui prend un opérande entier et
renvoie une valeur entière qui est le résultat de l'opération NOT au niveau du bit.
L'opérateur de complément à un ~ annule la valeur de son opérande en retournant tous ses bits. Si
l'opérande est un entier de n bits, l' opérateur ~ renvoie un entier de n bits dont tous les bits sont
inversés. Par exemple, le complément à un de 0000 1100 (12 en décimal) est 1111 0011 (243 en décimal).
Voici un exemple d'utilisation de l'opérateur complément à un en C++ :
La sortie de ce programme sera :
x : 12
y : -13
Dans cet exemple, l'opérateur de complément à un ~ est utilisé pour annuler la valeur de la variable
Le résultat de l' opération ~ est stocké dans la variable y et imprimé sur la console.
x.
Notez que l'opérateur de complément à un a une priorité plus élevée que les opérateurs AND, OR et XOR
au niveau du bit & , | , et ^ , il est donc généralement évalué avant ces opérateurs. Par exemple,
l'expression ~x & y est équivalente à (~x) & y , alors que l'expression x | ~y est équivalent à x | (~y) .
Opérateurs pointeur vers membre : .* et ->*
En C++, l' opérateur .* et l'opérateur
struct via un pointeur vers l'objet.
->*
sont utilisés pour accéder à un membre d'une classe ou d'un
L' opérateur .* est utilisé lorsque l'objet lui-même est un pointeur, tandis que l' opérateur ->* est utilisé
lorsque l'objet est un objet réel et que vous souhaitez accéder à un membre via un pointeur vers l'objet.
Voici un exemple d'utilisation de ces opérateurs :
Le résultat de ce programme serait :
sx = 10
sy = 3,14
(p->*px) = 10
(p->*py) = 3,14
(s.*px) = 10
(s.*py) = 3,14
Dans cet exemple, nous avons une structure S avec deux membres : x et y . Nous créons un objet s de
type S et un pointeur p vers s . Nous définissons également deux pointeurs vers les membres de S , px
et py , qui pointent respectivement vers les membres x et y .
Nous pouvons accéder aux membres x et y de s directement en utilisant l'opérateur point . , et nous
pouvons y accéder via le pointeur p en utilisant l' opérateur ->* . Nous pouvons également accéder aux
membres x et y de s via le pointeur vers l'objet lui-même en utilisant l' opérateur . * .
Opérateurs d'incrémentation et de décrémentation suffixés : ++ et -En C++, l'opérateur d'incrémentation postfixé ( ++ ) et l'opérateur de décrémentation postfixé ( -- ) sont
utilisés pour incrémenter ou décrémenter la valeur d'une variable de 1. Ces opérateurs sont appelés
"postfixés" car ils viennent après l'opérande (la variable dont la valeur est incrémentée ou décrémentée).
Voici un exemple d'utilisation de ces opérateurs :
Le résultat de ce programme serait :
x = 10
y = 10
x++ = 10
y-- = 10
x = 11
y=9
Dans cet exemple, nous avons deux variables x et y , toutes deux initialisées à 10. Nous utilisons
l'opérateur d'incrémentation postfixé x++ pour incrémenter la valeur de x de 1, et nous utilisons
l'opérateur de décrémentation postfixé y-- pour décrémenter la valeur de y de 1.
Les opérateurs suffixés d'incrémentation et de décrémentation renvoient la valeur de l'opérande avant
qu'il ne soit incrémenté ou décrémenté. C'est pourquoi la sortie de x++ et y-- est 10, même si les valeurs
de x et y sont respectivement incrémentées et décrémentées.
Il est important de noter que les opérateurs d'incrémentation et de décrémentation suffixés ont une
priorité inférieure à la plupart des autres opérateurs, ils sont donc souvent utilisés en combinaison avec
d'autres opérateurs. Par exemple:
Dans cet exemple, la valeur de c est calculée comme 10 + 20 = 30 , et
la valeur de a est incrémentée à 11 une fois le calcul terminé. De même, la valeur de d est calculée
comme 11 - 20 = -1 , et la valeur de a est décrémentée à 10 une fois le calcul terminé.
Opérateurs d'incrémentation et de décrémentation préfixés : ++ et -En C++, l'opérateur d'incrémentation de préfixe ( ++ ) et l'opérateur de décrémentation de préfixe ( -- )
sont utilisés pour incrémenter ou décrémenter la valeur d'une variable de 1. Ces opérateurs sont appelés
"préfixe" car ils viennent avant l'opérande (la variable dont la valeur est incrémentée ou décrémentée).
Voici un exemple d'utilisation de ces opérateurs :
Le résultat de ce programme serait :
x = 10
y = 10
++x = 11
--y = 9
x = 11
y=9
Dans cet exemple, nous avons deux variables x et y , toutes deux initialisées à 10. Nous utilisons
l'opérateur d'incrémentation de préfixe ++x pour incrémenter la valeur de x de 1, et nous utilisons
l'opérateur de décrémentation de préfixe --y pour décrémenter la valeur de y par 1.
Les opérateurs d'incrémentation et de décrémentation de préfixe renvoient la valeur de l'opérande après
l'avoir incrémenté ou décrémenté. C'est pourquoi la sortie de ++x et --y est 11 et 9, respectivement,
même si les valeurs de x et y sont incrémentées et décrémentées avant que la sortie ne soit produite.
Il est important de noter que les opérateurs d'incrémentation et de décrémentation préfixés ont une
priorité plus élevée que la plupart des autres opérateurs, ils sont donc souvent utilisés en combinaison
avec d'autres opérateurs. Par exemple:
Dans cet exemple, la valeur de
20 = 31 . De même, la valeur de
10 - 20 = -10 .
a
a
est incrémentée à 11 avant que la valeur de
est décrémentée à 10 avant que la valeur de
c
d
soit calculée comme 11 +
ne soit calculée comme
Opérateurs relationnels : <, >, <= et >=
En C++, les opérateurs relationnels < , > , <= et >= sont utilisés pour comparer les valeurs de deux
opérandes. Ces opérateurs renvoient une valeur booléenne indiquant si la comparaison est vraie ou
fausse.
Voici un exemple d'utilisation de ces opérateurs :
Le résultat de ce programme serait :
(x
(x
(x
(x
(x
(x
< y) = 1
> y) = 0
<= y) = 1
>= y) = 0
== z) = 1
!= z) = 0
Dans cet exemple, nous avons trois variables : x , y et z . Nous utilisons les opérateurs relationnels pour
comparer les valeurs de x et y , ainsi que les valeurs de x et z .
L'opérateur relationnel < renvoie true si la valeur de l'opérande gauche est inférieure à la valeur de
l'opérande droit, et false sinon. L'opérateur relationnel > renvoie true si la valeur de l'opérande gauche
est supérieure à la valeur de l'opérande droit, et
false
sinon.
L'opérateur relationnel <= renvoie true si la valeur de l'opérande de gauche est inférieure ou égale à la
valeur de l'opérande de droite, et false sinon. L'opérateur relationnel >= renvoie true si la valeur de
l'opérande gauche est supérieure ou égale à la valeur de l'opérande droit, et false sinon.
L'opérateur relationnel == renvoie true si la valeur de l'opérande gauche est égale à la valeur de
l'opérande droit, et false sinon. L'opérateur relationnel != renvoie true si la valeur de l'opérande de
gauche n'est pas égale à la valeur de l'opérande de droite, et false sinon.
Il est important de noter que les opérateurs relationnels ont une priorité inférieure à la plupart des autres
opérateurs, ils sont donc souvent utilisés en combinaison avec d'autres opérateurs. Par exemple:
int a = 10 ;
entier b = 20 ;
si (a < b && b > a)
{
std::cout << "a est inférieur à b et b est supérieur à a" << std::endl;
}
si (une == b || une != b)
{
std::cout << "a est soit égal à b soit différent de b" << std::endl;
}
Dans cet exemple, la première instruction
if
sera vraie car les deux conditions
Opérateur de résolution de portée : ::
En C++, l'opérateur de résolution de portée ( :: ) est utilisé pour spécifier la portée dans laquelle un nom
est défini. Il est utilisé pour qualifier le nom d'une classe, d'une fonction ou d'une variable, et est souvent
utilisé pour accéder à un nom défini dans une portée différente.
Voici un exemple d'utilisation de l'opérateur de résolution de portée :
Le résultat de ce programme serait :
x = 20
::x = 10
Dans cet exemple, nous avons une variable globale x et une variable locale x dans la fonction main . La
variable locale x est définie dans la portée de la fonction principale , tandis que la variable globale x est
définie en dehors de toute fonction et se trouve donc dans la portée globale.
Nous utilisons l'opérateur de résolution de portée :: pour spécifier la portée globale lors de l'accès à la
variable globale x . Sans l'opérateur de résolution de portée, la variable locale x serait accessible à la
place.
L'opérateur de résolution de portée peut également être utilisé pour accéder à un nom défini dans un
espace de noms différent :
Le résultat de ce programme serait :
x = 20
NS1 ::x = 10
NS2 ::x = 20
Dans cet exemple, nous avons deux espaces de noms, NS1 et NS2 , chacun avec une variable x . La
variable x dans NS2 est définie dans le périmètre de la fonction principale , tandis que la variable x dans
NS1 est définie en dehors de toute fonction et est donc dans le périmètre global.
Nous utilisons l'opérateur de résolution de portée :: pour spécifier l'espace de noms lors de l'accès aux
variables x dans NS1 et NS2 . Sans l'opérateur de résolution de portée, la variable locale x dans NS2
serait accessible à la place.
taille de l'opérateur
En C++, l' opérateur sizeof est utilisé pour déterminer la taille, en octets, d'un type de données ou d'une
expression. Il est souvent utilisé pour allouer dynamiquement de la mémoire ou pour déterminer la taille
d'un tableau.
Voici un exemple d'utilisation de l' opérateur
sizeof :
#include <iostream>
#include <tableau>
int main()
{
std::cout << "sizeof(int) = " << sizeof(int) << " octets" << std::endl;
std::cout << "sizeof(double) = " << sizeof(double) << " octets" << std::endl;
std::array<int, 10> arr ;
std::cout << "sizeof(arr) = " << sizeof(arr) << " bytes" << std::endl;
int* p = nouveau int[10] ;
std::cout << "sizeof(p) = " << sizeof(p) << " octets" << std::endl;
supprimer [] p ;
renvoie 0 ;
}
La sortie de ce programme dépendra de la machine et du compilateur utilisés, mais cela pourrait
ressembler à ceci :
sizeof(entier) = 4 octets
sizeof(double) = 8 octets
sizeof(arr) = 40 octets
sizeof(p) = 8 octets
Dans cet exemple, nous utilisons l' opérateur sizeof pour déterminer la taille de divers types de données et
expressions. Nous l'utilisons pour déterminer la taille d'un int et d'un double , ainsi que la taille d'un
std::array d' int s et d'un tableau d' int s alloué dynamiquement .
Il est important de noter que l' opérateur sizeof n'évalue pas l'expression à laquelle il est appliqué. Il
détermine simplement la taille du type de données ou de l'expression, quelle que soit sa valeur.
Par exemple:
int x = 10 ;
std::cout << "sizeof(x + 20) = " << sizeof(x + 20) << " bytes" << std::endl;
Le résultat de ce programme serait :
sizeof(x + 20) = 4 octets
Dans cet exemple, l'expression
qui est de 4 octets.
x + 20
n'est pas évaluée. L' opérateur
sizeof détermine simplement la taille d'un int
,
Opérateur d'indice :
En C++, l'opérateur d'indice ( [] ) est utilisé pour accéder à un élément d'un tableau ou d'une classe de
conteneur. Il est utilisé pour spécifier l'index de l'élément auquel on accède.
Voici un exemple de la façon dont l'opérateur d'indice peut être utilisé avec un tableau :
Le résultat de ce programme serait :
tab[0]
tab[1]
tab[2]
tab[9]
=
=
=
=
1
2
3
10
Dans cet exemple, nous avons un tableau de int s appelé arr , avec 10 éléments. Nous utilisons l'opérateur
d'indice [] pour accéder aux éléments du tableau, en spécifiant l'index de l'élément auquel nous voulons
accéder. Le premier élément du tableau a un index de 0, le deuxième élément a un index de 1, et ainsi de
suite.
L'opérateur d'indice peut également être utilisé avec des classes de conteneur qui fournissent des
surcharges d'opérateur d'indice, telles que std::vector et std::map . Par exemple:
Le résultat de ce programme serait :
vec[0] = 1
vec[1] = 2
m["un"] = 1
m["deux"] = 2
Dans cet exemple, nous avons un std::vector d' int s appelé vec et un std::map d' int s appelé m . Nous
utilisons l'opérateur d'indice [] pour accéder aux éléments du vecteur et de la carte , en spécifiant l'index
de l'élément auquel nous voulons accéder. Les indices d'un vecteur sont des valeurs entières commençant à
0, tandis que les indices d'une carte sont des clés du type approprié (dans ce cas, std::string ).
Il est important de noter que l'opérateur d'indice peut être utilisé à la fois pour lire et écrire dans les
éléments d'un tableau ou d'un conteneur. Par exemple:
arr[0]
opérateur typeid dans
En C++, l' opérateur typeid est utilisé pour déterminer le type d'une expression lors de l'exécution. Il
renvoie un objet std :: type_info qui décrit le type de l'expression.
Voici un exemple d'utilisation de l' opérateur
typeid
:
La sortie de ce programme dépendra de l'implémentation, mais cela pourrait ressembler à ceci :
typeid(x).nom() = je
typeid(y).nom() = d
typeid(z).name() = NSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE
Dans cet exemple, nous avons trois variables : x de type int , y de type double et z de type std::string . Nous
utilisons l' opérateur typeid pour déterminer le type de chaque variable au moment de l'exécution, et nous
utilisons la fonction membre name de l'objet std::type_info qui est renvoyé pour obtenir le nom du type.
Il est important de noter que l' opérateur typeid ne peut être utilisé qu'avec des expressions qui ont un
type défini. Il ne peut pas être utilisé avec des expressions qui ont un type indéfini ou incomplet, telles
que des variables non initialisées ou des variables avec des types de classe incomplets.
Par exemple:
entier x ;
std::cout << "typeid(x).name() = " << typeid(x).name() << std::endl; // erreur : x a un type indéfini
Dans cet exemple, la variable x a un type indéfini car elle n'est pas initialisée. Tenter d'utiliser l'
opérateur typeid sur x entraînerait une erreur de compilation.
Opérateurs unaires plus et négation : + et En C++, les opérateurs unaires plus et négation ( + et - ) sont utilisés pour effectuer des opérations
arithmétiques sur un seul opérande. L'opérateur unaire plus renvoie la valeur de l'opérande, tandis que
l'opérateur de négation unaire renvoie la négation de la valeur de l'opérande.
Voici un exemple d'utilisation de ces opérateurs :
Le résultat de ce programme serait :
+x = 10
-x = -10
+y = -20
-y = 20
Dans cet exemple, nous avons deux variables :
-20.
x
et
y
.
x
a une valeur de 10, tandis que
y
a une valeur de
Nous utilisons l'opérateur unaire plus + pour renvoyer la valeur de x , qui est 10. Nous utilisons
l'opérateur de négation unaire - pour renvoyer la négation de la valeur de x , qui est -10.
Nous utilisons l'opérateur unaire plus + pour renvoyer la valeur de y , qui est -20. Nous utilisons
l'opérateur de négation unaire - pour renvoyer la négation de la valeur de y , qui est 20.
Il est important de noter que l'opérateur unaire plus n'effectue aucune opération arithmétique, il renvoie
simplement la valeur de l'opérande. Il est souvent utilisé pour indiquer explicitement qu'une valeur est
positive, en particulier lorsque la valeur est entourée d'autres opérateurs arithmétiques.
Par exemple:
int a = 10 ;
entier b = 20 ;
entier c = -30 ;
std::cout << a + b - c << std :: endl; // sortie : 40
std::cout <<a + +b - c << std::endl; // sortie : 50
Dans le premier exemple, l'expression
40.
a+b-c
est évaluée comme
10 + 20 - (-30)
, ce qui donne une valeur de
Dans le deuxième exemple, l'expression a + +b - c est évaluée comme 10 + (+20) - (-30) , ce qui donne une
valeur de 50. L'opérateur unaire plus est utilisé pour indiquer explicitement que la valeur de b est positif,
même s'il s'agit déjà d'une valeur positive.
Expressions
En C++, une expression est une combinaison d'un ou plusieurs opérandes et opérateurs qui peuvent être
évalués en une seule valeur. Les expressions peuvent être simples, comme une valeur constante ou une
variable, ou elles peuvent être complexes, impliquant plusieurs opérations et appels de fonction.
Voici quelques exemples d'expressions en C++ :
1 + 2 // expression simple, vaut 3
x + y // expression simple, évalue à la somme de x et y
f(x) // expression d'appel de fonction, évalue la valeur de retour de la fonction f
x + y * z // expression complexe, correspond à la somme de x et au produit de y et z
Les expressions peuvent être utilisées dans divers contextes en C++, notamment comme partie droite
d'une instruction d'affectation, comme argument d'une fonction ou comme partie d'une expression plus
large.
Par exemple:
int x = 1 + 2 ; // instruction d'affectation, x reçoit la valeur 3
int y = f(x + 3); // appel de fonction, y reçoit la valeur de retour de f(x + 3)
if (x > 0 && y < 10) // instruction conditionnelle, teste si x est supérieur à 0 et y est inférieur à 10
std::cout << "x est positif et y est inférieur à 10" << std::endl;
Il est important de noter que les expressions peuvent avoir des effets secondaires, comme la modification
de la valeur d'une variable ou l'exécution d'une autre action. Par exemple:
entier x = 1 ;
entier y = x++ ; // y reçoit la valeur de x avant que x ne soit incrémenté
std::cout << "x = " << x << " y = " << y << std::endl; // sortie : x = 2 y = 1
Dans cet exemple, l'expression x++ incrémente la valeur de x après avoir été utilisée pour affecter une
valeur à y . La sortie du programme est x = 2 y = 1 , indiquant que x a été incrémenté après avoir été
utilisé pour attribuer une valeur à y .
Chapitre six
Types d'expressions
En C++, il existe plusieurs types d'expressions, chacune avec sa propre syntaxe et ses propres règles
d'évaluation. Certains types d'expressions courants incluent :
Expressions arithmétiques : ces expressions impliquent des opérations arithmétiques, telles
que l'addition, la soustraction, la multiplication et la division. Ils peuvent inclure des
constantes, des variables et d'autres expressions arithmétiques comme opérandes. Par
exemple : 1 + 2 , x + y , x * y / z .
Expressions relationnelles : ces expressions impliquent des opérateurs de comparaison, tels
que < , > , <= et >= , et donnent une valeur booléenne indiquant si la comparaison est vraie
ou fausse. Ils peuvent inclure des constantes, des variables et d'autres expressions
arithmétiques comme opérandes. Par exemple : x < y , a <= b , c > d .
Expressions logiques : ces expressions impliquent des opérateurs logiques, tels que && (et),
|| (ou), et ! (non) et évalue à une valeur booléenne indiquant si l'opération logique est vraie
ou fausse. Ils peuvent inclure des constantes, des variables et d'autres expressions logiques
comme opérandes. Par exemple : x && y , un || b , !c .
Expressions d'affectation : ces expressions impliquent l'opérateur d'affectation = et sont
utilisées pour affecter une valeur à une variable. Ils peuvent inclure des constantes, des
variables,
Expressions primaires
En C++, une expression primaire est une expression simple qui peut être autonome et ne nécessite aucun
opérateur supplémentaire pour être évaluée. Les expressions principales incluent les littéraux, les
variables, les appels de fonction et les expressions d'accès aux objets ou aux membres.
Voici quelques exemples d'expressions primaires en C++ :
Littéraux : les constantes telles que les littéraux entiers ( 42 ), les littéraux à virgule flottante
( 3.14 ), les littéraux caractères ( 'a' ) et les littéraux chaîne ( "hello" ) sont toutes des
expressions primaires.
Variables : les variables telles que
x
,
y
et
z
sont des expressions principales.
Appels de fonction : les appels de fonction tels que
f(x, y, z)
sont des expressions principales.
Expressions d'accès à un objet ou à un membre : les expressions qui accèdent à un objet ou à
un membre d'un objet, telles que obj.x , ptr->y et arr[i] , sont des expressions principales.
Les expressions primaires sont souvent utilisées comme opérandes dans des expressions plus grandes,
mais elles peuvent également être utilisées seules.
Par exemple:
int x = 10 ;
y double = 3,14 ;
std::string z = "bonjour" ;
std::cout
std::cout
std::cout
std::cout
<<
<<
<<
<<
x << std::endl; // expression primaire : variable x
y << std::endl; // expression primaire : variable y
z << std::endl; // expression primaire : variable z
f(x, y) << std::endl; // expression primaire : appel de fonction f(x, y)
Dans cet exemple, nous avons trois variables : x de type int , y de type double et z de type std::string . Nous
utilisons chacune de ces variables comme expression principale dans une instruction std::cout distincte .
Nous utilisons également un appel de fonction f(x, y) comme expression principale.
Il est important de noter que les expressions principales n'incluent pas les expressions qui nécessitent
l'évaluation d'opérateurs supplémentaires, telles que les expressions arithmétiques ou les expressions
logiques. Par exemple, x + y et x && y ne sont pas des expressions primaires.
Modèles de points de suspension et variadiques
En C++, des points de suspension ( ... ) sont utilisés pour indiquer une fonction variadique, qui est une
fonction qui peut prendre un nombre variable d'arguments. Des points de suspension sont utilisés dans la
liste des paramètres de la fonction pour indiquer le nombre variable d'arguments.
Voici un exemple de fonction variadique en C++ :
Dans cet exemple, nous avons une fonction appelée print_all qui prend un nombre variable d'arguments. Le
premier argument est un const char* appelé fmt , qui spécifie le format des arguments restants. Les points
de suspension ( ... ) dans la liste des paramètres indiquent qu'il peut y avoir n'importe quel nombre
d'arguments supplémentaires.
Dans la fonction, nous utilisons les macros va_list , va_start , va_arg et va_end pour accéder aux arguments de
la variable. Le type va_list est utilisé pour contenir la liste des arguments, et la macro va_start est utilisée
pour initialiser va_list avec le premier argument après fmt . La macro va_arg est utilisée pour récupérer le
prochain argument de la liste, et la macro va_end est utilisée pour nettoyer la va_list lorsque nous en avons
fini.
Dans cet exemple, nous utilisons une boucle pour parcourir les caractères de la chaîne fmt . Si nous
rencontrons un caractère % , nous incrémentons le pointeur sur la chaîne fmt et vérifions le caractère
suivant pour déterminer le type de l'argument suivant. Si le caractère suivant est d , nous imprimons
l'argument suivant sous la forme d'un int , si c'est s , nous imprimons l'argument suivant sous la forme
d'un const char* , et si c'est f , nous imprimons l'argument suivant sous la forme d'un double .
Le résultat de ce programme serait :
10 bonjour 3.14
Expressions postfixées
En informatique, une expression postfixée est une expression dans laquelle chaque opérateur suit ses
opérandes. Cela contraste avec une expression infixe, dans laquelle les opérateurs sont placés entre leurs
opérandes.
Par exemple, l'expression infixe "2 + 3 * 4" serait écrite comme "2 3 4 * +" en notation postfixée.
Expressions avec opérateurs unaires
Les opérateurs unaires sont des opérateurs qui agissent sur un seul opérande. En C++, il existe plusieurs
opérateurs unaires, notamment :
++
(opérateur d'incrémentation)
--
(opérateur de décrémentation)
+
(plus unaire)
-
(moins unaire)
!
(NON logique)
~
*
&
(NON au niveau du bit)
(opérateur de déréférencement)
(opérateur de référence)
Voici un exemple d'utilisation de l'opérateur d'incrémentation unaire (
L'opérateur de décrémentation unaire (
--
++
) en C++ :
) fonctionne de manière similaire.
Vous pouvez utiliser les opérateurs unaires plus et moins pour modifier le signe d'une valeur :
L'opérateur logique NOT (
!
) peut être utilisé pour inverser la valeur de vérité d'une expression
booléenne :
L'opérateur NOT au niveau du bit (
~
L'opérateur de déréférencement (
) permet d'accéder à la valeur stockée à une adresse mémoire :
L'opérateur de référence (
&
*
) peut être utilisé pour inverser les bits d'une valeur entière :
) permet d'obtenir l'adresse mémoire d'une variable :
Expressions avec opérateurs binaires
Les opérateurs binaires sont des opérateurs qui agissent sur deux opérandes. En C++, il existe plusieurs
opérateurs binaires, notamment :
(ajout)
+
-
(soustraction)
*
(multiplication)
/
(division)
%
(module)
=
(devoir)
(affectation supplémentaire)
+=
-=
(affectation de soustraction)
*=
(affectation de multiplication)
/=
(affectation de division)
%=
(affectation de module)
==
(égal à)
(différent de)
!=
>
(supérieur à)
<
(moins de)
>=
(supérieur ou égal à)
<=
(inférieur ou égal à)
&&
(ET logique)
||
&
|
^
(OU logique)
(ET au niveau du bit)
(OU au niveau du bit)
(XOR au niveau du bit)
<<
(décalage à gauche)
>>
(décalage à droite)
Voici un exemple d'utilisation de certains de ces opérateurs en C++ :
Expressions constantes
En C++, une expression constante est une expression qui peut être évaluée au moment de la compilation,
plutôt qu'au moment de l'exécution. Les expressions constantes sont généralement utilisées pour
initialiser des variables avec des valeurs fixes ou pour spécifier des tailles de tableau.
Il existe plusieurs façons de créer des expressions constantes en C++ :
1. Utilisation de constantes : toute valeur littérale (telle que
constante.
42
,
3.14
ou
2. Utilisation de variables const : Une variable déclarée avec le mot-clé
constante. Par exemple:
const int x = 42 ;
const double pi = 3,14 ;
const char c = 'A';
'A'
) est une expression
const
est une expression
3. Utilisation des variables constexpr : Une variable déclarée avec le mot-clé
expression constante. Par exemple:
constexpr
est une
constexpr int x = 42;
constexpr double pi = 3,14 ;
constexpr char c = 'A';
4. Utilisation d'énumérations : les constantes d'énumération sont traitées comme des constantes
en C++. Par exemple:
enum Couleurs { Rouge, Vert, Bleu } ;
constexpr Couleurs favoriteColor = Vert;
5. Utilisation des fonctions constexpr : Une fonction déclarée avec le mot-clé constexpr et
répondant à certains critères (comme le fait d'avoir une seule instruction de retour) peut être
utilisée dans des expressions constantes. Par exemple:
constexpr entier carré(int x)
{
retourner x * x ;
}
constexpr int x = carré(5); // x vaut 25
Voici un exemple d'utilisation d'une expression constante pour initialiser un tableau en C++ :
Sémantique des expressions
En C++, la sémantique d'une expression fait référence à la signification et au comportement de
l'expression lorsqu'elle est évaluée. Les règles d'évaluation des expressions en C++ sont déterminées par
les règles de priorité et d'associativité des opérateurs, ainsi que par les types et les valeurs des
opérandes.
Voici quelques règles générales pour évaluer les expressions en C++ :
1. Les parenthèses peuvent être utilisées pour remplacer les règles de priorité et d'associativité
par défaut. Les expressions entre parenthèses sont toujours évaluées en premier.
2. Les opérateurs unaires sont évalués avant les opérateurs binaires. Par exemple, dans
l'expression !x + y , l'opérateur logique NOT ( ! ) est appliqué à x avant que l'opérateur
d'addition ( + ) ne soit appliqué à x et y .
3. Les opérateurs binaires sont évalués par ordre de priorité, du plus élevé au plus bas. Par
exemple, dans l'expression x + y * z , l'opérateur de multiplication ( * ) a une priorité plus
élevée que l'opérateur d'addition ( + ), donc y et z sont multipliés en premier.
4. Les opérateurs ayant la même priorité sont évalués de gauche à droite (pour les opérateurs
associatifs à gauche) ou de droite à gauche (pour les opérateurs associatifs à droite). Par
exemple, dans l'expression x = y = z , l'opérateur d'affectation ( = ) est associatif à droite,
donc z est d'abord affecté à y , puis le résultat de cette affectation est affecté à x .
Voici un exemple de la façon dont ces règles peuvent être appliquées dans une expression C++ :
Dans cet exemple, l'opérateur d'addition ( + ) a une priorité inférieure à l'opérateur de multiplication ( *
), de sorte que les expressions entre parenthèses sont évaluées en premier. L'opérateur d'addition ( + )
est associatif à gauche, donc x et y sont ajoutés en premier, puis z et 1 sont ajoutés. Le résultat de ces
additions est ensuite multiplié pour produire le résultat final.
qu'est-ce que le casting
En C++, la conversion est le processus de conversion d'une valeur d'un type en une valeur d'un autre
type. Il existe plusieurs façons d'effectuer un casting en C++ :
1. statique : l' opérateur static_cast est utilisé pour effectuer une conversion de type sûre et
explicite. Il peut être utilisé pour convertir une valeur d'un type à un autre, tant que le type
cible est explicitement spécifié. Par exemple:
double x = 3,14 ;
int y = static_cast<int>(x); // y vaut 3
2. dynamique : l' opérateur dynamic_cast est utilisé pour effectuer une conversion de type lors de
l'exécution. Il est utilisé pour convertir un pointeur ou une référence d'un type de classe de
base en un type de classe dérivé. Par exemple:
classe Base { } ;
classe Dérivée : public Base { };
Base *b = nouvelle Base();
Dérivé *d = dynamic_cast<Derived*>(b); // d est nullptr
3. Reinterpret cast : L' opérateur reinterpret_cast est utilisé pour interpréter les bits d'une valeur
comme une valeur d'un type différent. Il est utilisé pour convertir un pointeur en un type
entier, ou vice versa. Par exemple:
int x = 42 ;
char *ptr = reinterpret_cast<char*>(&x); // ptr pointe sur le premier octet de x
4. const : l' opérateur const_cast est utilisé pour supprimer le qualificatif const d'une valeur. Il est
utilisé pour modifier une valeur const ou pour passer une valeur const à une fonction qui
attend un paramètre non const . Par exemple:
const int x = 42 ;
int *ptr = const_cast<int*>(&x); // ptr pointe vers x, mais x peut être modifié via ptr
Il est important de noter que la conversion peut parfois entraîner une perte d'informations ou un
comportement indéfini si le type cible n'est pas capable de représenter la valeur en cours de conversion.
Par conséquent, il est important d'utiliser le casting avec prudence et uniquement lorsque cela est
nécessaire.
septième chapitre
Opérateurs de fonderie
En C++, la conversion fait référence au processus de conversion d'une valeur d'un type de données en un
autre type de données. Cela peut être fait en utilisant une variété d'opérateurs de coulée, y compris :
1.
static_cast
: cet opérateur est utilisé pour effectuer une conversion de type sûre et explicite. Il
peut être utilisé pour convertir des valeurs entre des types compatibles, comme la conversion
d'un int en un float .
2.
dynamic_cast
3.
const_cast
4.
reinterpret_cast
: Cet opérateur est utilisé pour effectuer une conversion sécurisée et downcast
d'une classe de base vers une classe dérivée. Il est utilisé lorsque le type de l'objet en cours
de conversion n'est pas connu au moment de la compilation et est généralement utilisé en
conjonction avec le polymorphisme.
: Cet opérateur est utilisé pour supprimer l' attribut const ou volatile d'une variable. Il
peut être utilisé pour supprimer le qualificatif const ou volatile d'un pointeur ou d'une
référence, ce qui permet de modifier la valeur.
: cet opérateur est utilisé pour effectuer une conversion de type de bas niveau
définie par l'implémentation. Il peut être utilisé pour convertir une valeur d'un type en une
valeur d'un type différent, que les deux types soient liés ou non. Cet opérateur est
généralement utilisé pour convertir des pointeurs vers et depuis des types entiers, ou pour
convertir un type de pointeur en un autre.
Il est important de noter que ces opérateurs de diffusion peuvent souvent entraîner un comportement
indéfini s'ils sont utilisés de manière incorrecte, ils doivent donc être utilisés avec prudence.
opérateur dynamic_cast
L' opérateur dynamic_cast en C++ est utilisé pour effectuer une conversion sécurisée et downcast d'une
classe de base vers une classe dérivée. Il est généralement utilisé en conjonction avec le polymorphisme,
où un pointeur ou une référence à une classe de base est utilisé pour faire référence à des objets de
classes dérivées.
La syntaxe d'utilisation de
dynamic_cast
est la suivante :
type_dérivé *ptr = dynamic_cast<type_dérivé*>(base_ptr);
Où type_dérivé est le type de la classe dérivée et base_ptr est un pointeur vers la classe de base. Si la
conversion réussit, dynamic_cast renverra un pointeur vers la classe dérivée. Si la conversion n'est pas
possible (par exemple, si base_ptr ne pointe pas réellement vers un objet de la classe dérivée), dynamic_cast
renverra un pointeur nul.
Voici un exemple d'utilisation de
dynamic_cast
pour downcaster un pointeur vers une classe de base :
Dans cet exemple, l' opérateur dynamic_cast est utilisé pour convertir un pointeur vers un objet Shape en un
pointeur vers un objet Circle . Si l' objet Shape est en fait un Circle , la conversion réussira et la méthode
Draw sera appelée sur l' objet Circle . Si l' objet Shape n'est pas un Circle , l' opérateur dynamic_cast renverra
un pointeur null et la méthode Draw ne sera pas appelée.
exception bad_cast
L' exception bad_cast est un type d'exception qui est levée par l' opérateur dynamic_cast en C++ lorsqu'il ne
parvient pas à effectuer une conversion downcast d'une classe de base vers une classe dérivée.
L' exception bad_cast est définie dans l'en- tête stdexcept et est dérivée de la classe
interceptée à l'aide d'un bloc try - catch , comme toute autre exception :
exception
. Elle peut être
Dans cet exemple, l' opérateur dynamic_cast ne parviendra pas à convertir l' objet Shape en un objet Circle et
lèvera une exception bad_cast . L'exception sera capturée dans le bloc catch et le message d'erreur sera
imprimé sur la console.
Il est important de noter que l' exception bad_cast ne sera lancée que si l' opérateur dynamic_cast ne parvient
pas à effectuer la conversion. Si la conversion réussit, l' exception bad_cast ne sera pas levée.
opérateur static_cast
L' opérateur static_cast en C++ est utilisé pour effectuer une conversion de type sûre et explicite. Il peut
être utilisé pour convertir des valeurs entre des types compatibles, comme convertir un int en float , ou
pour convertir un pointeur vers une classe de base en un pointeur vers une classe dérivée.
La syntaxe d'utilisation de
static_cast
est la suivante :
destination_type value = static_cast<destination_type>(expression);
Où type_destination est le type vers lequel la valeur de
convertir.
Voici un exemple d'utilisation de
static_cast
expression
pour convertir un
sera convertie et
int
en
float
expression
est la valeur à
:
Dans cet exemple, la valeur de x est convertie d'un entier à un flottant à l'aide de l' opérateur
résultat est stocké dans la variable flottante y . La sortie de ce programme sera "y = 5.0".
static_cast
et le
Il est important de noter que static_cast n'effectue aucune vérification d'exécution pour s'assurer que la
conversion est valide. Il est de la responsabilité du programmeur de s'assurer que la conversion est sûre
et n'entraînera pas un comportement indéfini.
opérateur const_cast
L' opérateur const_cast en C++ est utilisé pour supprimer l' attribut const ou volatile d'une variable. Il peut
être utilisé pour supprimer le qualificatif const ou volatile d'un pointeur ou d'une référence, ce qui permet
de modifier la valeur.
La syntaxe d'utilisation de
const_cast
est la suivante :
destination_type value = const_cast<destination_type>(expression);
Où type_destination est le type vers lequel la valeur de
convertir.
Voici un exemple d'utilisation de
const_cast
expression
sera convertie et
pour supprimer l' attribut
expression
const d'un const int
est la valeur à
:
Dans cet exemple, l' opérateur const_cast est utilisé pour supprimer l' attribut const d'un pointeur vers x .
Cela permet de modifier la valeur de x via le pointeur y . La sortie de ce programme sera "x = 10", même si
est déclaré comme un const int .
Il est important de noter que l'utilisation de const_cast pour modifier une variable
entraîner un comportement indéfini si la variable est réellement destinée à être
doit être utilisé avec prudence.
const
const
ou
ou
volatile
volatile
x
peut
. const_cast
opérateur reinterpret_cast
L' opérateur reinterpret_cast en C++ est utilisé pour effectuer une conversion de type de bas niveau définie
par l'implémentation. Il peut être utilisé pour convertir une valeur d'un type en une valeur d'un type
différent, que les deux types soient liés ou non. Cet opérateur est généralement utilisé pour convertir des
pointeurs vers et depuis des types entiers, ou pour convertir un type de pointeur en un autre.
La syntaxe d'utilisation de
reinterpret_cast
est la suivante :
destination_type value = reinterpret_cast<destination_type>(expression);
Où type_destination est le type vers lequel la valeur de
convertir.
Voici un exemple d'utilisation de
Dans cet exemple, l' opérateur
reinterpret_cast
reinterpret_cast
expression
sera convertie et
pour convertir un pointeur en
int
expression
est la valeur à
:
est utilisé pour convertir un pointeur en
int
. La sortie de ce
programme sera l'adresse de
x
sous forme de valeur entière.
Il est important de noter que reinterpret_cast n'effectue aucune vérification de type ou conversion de la
valeur en cours de conversion. Il traite simplement la valeur comme une séquence de bits et réinterprète
ces bits comme une valeur du type de destination. Cela peut entraîner un comportement indéfini si les
types convertis ne sont pas compatibles. reinterpret_cast doit être utilisé avec prudence.
Chapitre VIII
Informations sur le type d'exécution (RTTI)
Les informations de type à l'exécution (RTTI) sont une fonctionnalité du langage de programmation C++
qui permet aux programmeurs de déterminer le type d'un objet au moment de l'exécution. RTTI est
implémenté à l'aide d'un ensemble de fonctions spéciales et d'expressions typeid, et est généralement
utilisé en conjonction avec le polymorphisme pour déterminer le type réel d'un objet lorsqu'un pointeur ou
une référence à une classe de base est utilisé pour faire référence à des objets de classes dérivées.
Pour utiliser RTTI, vous devez d'abord l'activer en incluant l' en-tête
avec l' indicateur -frtti .
<typeinfo>
et en compilant votre code
Voici un exemple d'utilisation de RTTI pour déterminer le type d'un objet :
#include <iostream>
#include <typeinfo>
classe Forme {
Publique:
~ Forme virtuelle () {}
};
class Circle : forme publique {
Publique:
void Draw() { std::cout << "Tracer un cercle" << std::endl; }
};
int main() {
Forme *forme = nouveau Cercle ;
std::cout << "Type de forme : " << typeid(*shape).name() << std::endl;
renvoie 0 ;
}
Dans cet exemple, l' opérateur typeid est utilisé pour déterminer le type de l'objet pointé par shape . La
sortie de ce programme sera "Type de forme : classe Cercle", indiquant que l'objet est en fait un objet
Cercle , même s'il est référencé à l'aide d'un pointeur vers un objet Forme .
Il est important de noter que RTTI peut avoir un impact sur les performances de votre code, car il
nécessite des vérifications d'exécution supplémentaires pour déterminer le type d'un objet. Il doit être
utilisé avec parcimonie et uniquement lorsque cela est nécessaire.
exception bad_typeid
L' exception bad_typeid est un type d'exception qui est levée par l' opérateur
utilisé sur un objet avec un type supprimé ou incomplet.
typeid
en C++ lorsqu'il est
L' exception bad_typeid est définie dans l'en- tête stdexcept et est dérivée de la classe
interceptée à l'aide d'un bloc try - catch , comme toute autre exception :
exception
. Elle peut être
#include <iostream>
#include <stdexcept>
int main() {
essayer {
Forme *forme = nullptr ;
std::cout << "Type de forme : " << typeid(*shape).name() << std::endl;
} catch (std::bad_typeid& e) {
std::cout << "Erreur : " << e.what() << std::endl;
}
renvoie 0 ;
}
Dans cet exemple, l' opérateur typeid est utilisé sur un pointeur null, qui a un type supprimé. Cela
entraînera la levée de l'exception bad_typeid , qui sera interceptée dans le bloc catch et le message d'erreur
sera imprimé sur la console.
Il est important de noter que l' exception bad_typeid ne sera levée que si l' opérateur typeid est utilisé sur un
objet avec un type supprimé ou incomplet. Si l'objet a un type complet et valide, l' exception bad_typeid ne
sera pas levée.
classe type_info
La classe type_info en C++ est une classe qui représente des informations sur un type au moment de
l'exécution. Il est utilisé en conjonction avec l' opérateur typeid pour récupérer des informations de type
sur un objet.
La classe
type_info
est définie dans l'en- tête
<typeinfo>
et fournit plusieurs fonctions membres pour accéder
aux informations de type :
name()
: renvoie un tableau de caractères terminé par un caractère nul contenant le nom du
type.
hash_code()
: renvoie un code de hachage unique pour le type.
: renvoie true si le type représenté par cet objet type_info est
lexicographiquement inférieur au type représenté par le rhs objet type_info .
before(const type_info& rhs)
: renvoie
même que le type représenté par le
operator==(const type_info& rhs)
: renvoie
différent du type représenté par le
operator!=(const type_info& rhs)
Voici un exemple d'utilisation de la classe
true
rhs
true
rhs
type_info
si le type représenté par cet objet
objet type_info .
si le type représenté par cet objet
objet type_info .
type_info
type_info
est le
est
pour comparer les types de deux objets :
#include <iostream>
#include <typeinfo>
classe Forme {
Publique:
~ Forme virtuelle () {}
};
class Circle : forme publique {
Publique:
void Draw() { std::cout << "Tracer un cercle" << std::endl; }
};
int main() {
Forme *forme1 = nouvelle forme ;
Forme *forme2 = nouveau cercle ;
si (typeid(*forme1) == typeid(*forme2)) {
std::cout << "shape1 et shape2 sont du même type" << std::endl;
} autre {
std::cout << "shape1 et shape2 sont de types différents" << std::endl;
}
renvoie 0 ;
}
Dans cet exemple, l' opérateur typeid est utilisé pour récupérer les objets type_info pour les objets pointés
par shape1 et shape2 . La fonction membre operator== de la classe type_info est ensuite utilisée pour comparer les
deux types. La sortie de ce programme sera « shape1 et shape2 sont de types différents », indiquant que
les deux objets sont de types différents.
Déclarations
En C++, une instruction est un morceau de code qui exécute une action ou modifie l'état d'un
programme. Il existe plusieurs types d'instructions en C++, notamment :
1. Instructions d'expression : une instruction d'expression est une instruction composée d'une
seule expression suivie d'un point-virgule. Les instructions d'expression sont utilisées pour
évaluer une expression et ignorer le résultat.
2. Instructions de déclaration : une instruction de déclaration introduit un nouveau nom dans le
programme et spécifie le type et la valeur initiale de l'entité nommée. Les instructions de
déclaration sont utilisées pour définir des variables, des fonctions et d'autres entités
nommées.
3. Instructions de sélection : les instructions de sélection sont utilisées pour exécuter différents
blocs de code en fonction de la valeur d'une condition. Les deux types d'instructions de
sélection en C++ sont if et switch .
4. Instructions d'itération : les instructions d'itération, également appelées boucles, sont
utilisées pour exécuter plusieurs fois un bloc de code. Les trois types d'instructions
d'itération en C++ sont for , while et do-while .
5. Instructions de saut : les instructions de saut sont utilisées pour transférer le contrôle à une
autre partie du programme. Les trois types d'instructions de saut en C++ sont break , continue
et goto .
Les instructions sont une partie importante de C++ et sont utilisées pour contrôler le flux d'exécution et
effectuer des actions dans un programme.
Présentation des instructions C++
En C++, les instructions sont utilisées pour effectuer des actions ou modifier l'état d'un programme. Il
existe plusieurs types d'instructions en C++, notamment :
1. Instructions d'expression : les instructions d'expression sont utilisées pour évaluer une
expression et ignorer le résultat. Ils sont généralement utilisés pour appeler des fonctions,
effectuer des affectations et incrémenter ou décrémenter des variables.
2. Instructions de déclaration : les instructions de déclaration sont utilisées pour introduire de
nouveaux noms dans le programme et spécifier le type et la valeur initiale de l'entité
nommée. Les instructions de déclaration peuvent être utilisées pour définir des variables, des
fonctions et d'autres entités nommées.
3. Instructions de sélection : les instructions de sélection sont utilisées pour exécuter différents
blocs de code en fonction de la valeur d'une condition. L' instruction if est utilisée pour
exécuter un bloc de code si une condition est vraie, et l' instruction switch est utilisée pour
exécuter un bloc de code basé sur la valeur d'une variable.
4. Instructions d'itération : les instructions d'itération, également appelées boucles, sont
utilisées pour exécuter plusieurs fois un bloc de code. La boucle for est utilisée pour exécuter
un bloc de code un certain nombre de fois, la boucle while est utilisée pour exécuter un bloc
de code alors qu'une condition est vraie, et la boucle do- while est utilisée pour exécuter un
bloc de code au moins une fois avant d'évaluer une condition.
5. Instructions de saut : les instructions de saut sont utilisées pour transférer le contrôle à une
autre partie du programme. L' instruction break est utilisée pour quitter une boucle ou une
instruction switch, l' instruction continue est utilisée pour ignorer le reste de l'itération en
cours d'une boucle et l' instruction goto est utilisée pour transférer le contrôle à une instruction
étiquetée.
Les instructions sont une partie importante de C++ et sont utilisées pour contrôler le flux d'exécution et
effectuer des actions dans un
Déclarations étiquetées
En C++, les instructions étiquetées sont utilisées pour créer un emplacement nommé dans un bloc de
code. Les instructions étiquetées sont généralement utilisées conjointement avec l' instruction goto pour
transférer le contrôle à un emplacement spécifique dans un programme.
Pour créer une instruction étiquetée, vous pouvez utiliser n'importe quel identifiant valide suivi de
deux points :
étiquette : déclaration
Voici un exemple d'utilisation d'une instruction étiquetée en C++ :
Dans cet exemple, l'instruction étiquetée start : crée un emplacement nommé dans le bloc de code. L'
instruction goto start est ensuite utilisée pour transférer le contrôle à l' étiquette de démarrage et exécuter
l'instruction suivant l'étiquette. Cela entraînera l'exécution du bloc de code 10 fois, la valeur de x
augmentant de 1 à chaque fois. La sortie de ce programme sera les nombres 0 à 9, chacun sur une ligne
distincte.
Il est important de noter que l' instruction goto est généralement considérée comme un mécanisme de flux de
contrôle moins souhaitable et doit être utilisée avec prudence. Cela peut rendre le code difficile à lire et à
comprendre, et peut conduire à un code non structuré et difficile à maintenir. Il existe généralement des
alternatives plus lisibles et maintenables à l'utilisation des instructions goto dans la plupart des situations.
Déclaration d'expression
En C++, une instruction d'expression est une instruction composée d'une seule expression suivie d'un
point-virgule. Les instructions d'expression sont utilisées pour évaluer une expression et ignorer le
résultat.
Voici un exemple d'instruction d'expression en C++ :
Dans cet exemple, l'expression x++ est une instruction d'expression qui incrémente la valeur de x de 1.
Le résultat de l'expression est ignoré et la valeur de x est modifiée. La sortie de ce programme sera "x =
6".
Les instructions d'expression sont couramment utilisées pour effectuer des affectations, incrémenter ou
décrémenter des variables et appeler des fonctions. Ils sont une partie importante de C++ et sont utilisés
pour modifier l'état d'un programme.
Instruction nulle
En C++, une instruction nulle est une instruction composée d'un seul point-virgule. Les instructions
nulles sont utilisées pour créer un espace réservé dans un programme où une instruction est attendue,
mais aucune action n'est requise.
Voici un exemple d'instruction null en C++ :
Dans cet exemple, l'instruction null ; est utilisé comme corps d'une boucle for . Cela crée une boucle qui
s'exécutera 10 fois, mais aucune action ne sera entreprise à chaque itération.
Les instructions nulles sont généralement utilisées comme espaces réservés dans les situations où une
instruction est requise, mais aucune action ne doit être entreprise. Ils sont un outil utile pour créer du
code plus facile à lire et à comprendre.
Instructions composées (Blocs)
En C++, une instruction composée, également appelée bloc, est un groupe d'instructions exécutées
ensemble comme une unité. Les instructions composées sont généralement utilisées pour regrouper des
instructions et créer une nouvelle portée pour les variables.
Les instructions composées sont entourées d'accolades {} et peuvent contenir n'importe quel nombre
d'instructions. Voici un exemple d'instruction composée en C++ :
Dans cet exemple, l'instruction composée { int y = 10; std::cout << "x + y = " << x + y << std::endl; } crée une
nouvelle portée pour la variable y , qui n'est accessible que dans l'instruction composée. La sortie de ce
programme sera "x + y = 15".
Les instructions composées sont une partie importante de C++ et sont utilisées pour regrouper des
instructions et créer de nouvelles portées pour les variables. Ils sont couramment utilisés en conjonction
avec des instructions de sélection et d'itération pour créer des blocs de code qui sont exécutés ensemble.
Chapitre neuf
Énoncés de sélection
En C++, les instructions de sélection sont utilisées pour exécuter différents blocs de code en fonction de
la valeur d'une condition. Il existe deux types d'instructions de sélection en C++ : l' instruction if et l'
instruction switch .
L' instruction if est utilisée pour exécuter un bloc de code si une condition est vraie. La syntaxe de l'
instruction if est la suivante :
si (état) {
// code à exécuter si la condition est vraie
} autre {
// code à exécuter si la condition est fausse
}
Voici un exemple d'utilisation de l' instruction
if
en C++ :
Dans cet exemple, l' instruction if est utilisée pour exécuter différents blocs de code en fonction de la
valeur de x . Si x est supérieur à 0, le premier bloc de code sera exécuté et le message "x est positif" sera
affiché sur la console. Si x n'est pas supérieur à 0, le deuxième bloc de code sera exécuté et le message "x
n'est pas positif" sera affiché sur la console.
L' instruction switch est un autre type d'instruction de sélection en C++ qui est utilisée pour exécuter un
bloc de code basé sur la valeur d'une variable. La syntaxe de l' instruction switch est la suivante :
changer (expression) {
valeur de cas1 :
// code à être
instruction if-else
En C++, l' instruction if-else est une instruction de sélection utilisée pour exécuter différents blocs de
code en fonction de la valeur d'une condition. L' instruction if-else se compose d'une clause if et d'une
clause else , et la syntaxe est la suivante :
si (état) {
// code à exécuter si la condition est vraie
} autre {
// code à exécuter si la condition est fausse
}
La clause if est utilisée pour spécifier une condition, et le code entre les accolades suivant la clause if est
exécuté si la condition est vraie. La clause else est utilisée pour spécifier un autre bloc de code à exécuter
si la condition est fausse.
Voici un exemple d'utilisation de l' instruction
if-else
en C++ :
Dans cet exemple, la clause if spécifie la condition x > 0 , et le code entre les accolades suivant la clause
est exécuté si cette condition est vraie. La clause else spécifie un autre bloc de code à exécuter si la
condition est fausse. Si x est supérieur à 0, le message "x est positif" sera imprimé sur la console. Si x
n'est pas supérieur à 0, le message "x n'est pas positif" sera imprimé sur la console.
if
Le "si
Instruction __if_exists
En C++, l' instruction __if_exists est une directive de préprocesseur utilisée pour inclure un bloc de code si
un symbole spécifié existe. L' instruction __if_exists est généralement utilisée pour inclure du code
spécifique à un compilateur ou une plate-forme particulier, et la syntaxe est la suivante :
#if __has_include(<symbol>)
#include <symbole>
#fin si
Voici un exemple d'utilisation de l' instruction
__if_exists
en C++ :
#include <iostream>
#if __has_include(<windows.h>)
#include <windows.h>
#fin si
int main() {
std::cout << "Bonjour, monde !" << std ::endl;
renvoie 0 ;
}
Dans cet exemple, l' instruction __if_exists est utilisée pour inclure le fichier d'en-tête windows.h s'il existe. Si
le fichier d'en-tête n'est pas disponible, le bloc de code dans les directives #if et #endif sera ignoré et le
fichier d'en-tête windows.h ne sera pas inclus.
L' instruction __if_exists est un outil utile pour inclure du code spécifique à un compilateur ou à une plateforme particulière, et est souvent utilisée pour créer du code portable sur différents systèmes.
Instruction __if_not_exists
En C++, l' instruction __if_not_exists est une directive de préprocesseur utilisée pour inclure un bloc de code
si un symbole spécifié n'existe pas. L' instruction __if_not_exists est généralement utilisée pour inclure du
code spécifique à un compilateur ou une plate-forme particulier, et la syntaxe est la suivante :
#if !__has_include(<symbole>)
#include <symbole>
#fin si
Voici un exemple d'utilisation de l' instruction
__if_not_exists
en C++ :
#include <iostream>
#if !__has_include(<windows.h>)
#include "windows.h"
#fin si
int main() {
std::cout << "Bonjour, monde !" << std ::endl;
renvoie 0 ;
}
Dans cet exemple, l' instruction __if_not_exists est utilisée pour inclure le fichier d'en-tête windows.h s'il
n'existe pas. Si le fichier d'en-tête est disponible, le bloc de code dans les directives #if et #endif sera
ignoré et le fichier d'en-tête windows.h ne sera pas inclus.
L' instruction __if_not_exists est un outil utile pour inclure du code spécifique à un compilateur ou à une
plate-forme particulière, et est souvent utilisée pour créer du code portable sur différents systèmes.
déclaration de commutateur
En C++, l' instruction switch est une instruction de sélection utilisée pour exécuter un bloc de code en
fonction de la valeur d'une variable. L' instruction switch se compose d'une clause switch , d'une série de clauses
case et d'une clause default facultative . La syntaxe de l' instruction switch est la suivante :
changer (expression) {
valeur de cas1 :
// code à exécuter si expression == valeur1
Pause;
valeur de cas2 :
// code à exécuter si expression == valeur2
Pause;
...
défaut:
// code à exécuter si l'expression ne correspond à aucune des valeurs de cas
}
Voici un exemple d'utilisation de l' instruction
switch
en C++ :
#include <iostream>
int main() {
int x = 3 ;
interrupteur (x) {
cas 1:
std :: cout << "x vaut 1" << std :: endl;
Pause;
cas 2 :
std :: cout << "x vaut 2" << std :: endl;
Pause;
cas 3 :
std :: cout << "x vaut 3" << std :: endl;
Pause;
défaut:
std :: cout << "x n'est pas 1, 2 ou 3" << std :: endl;
}
renvoie 0 ;
}
Dans cet exemple, l' instruction switch est utilisée pour exécuter différents blocs de code en fonction de la
valeur de x . Si x vaut 1, le message "x vaut 1" sera imprimé sur la console. Si x vaut 2, le message "x
vaut 2" sera imprimé sur la console. Si x vaut 3, le message "x vaut 3" sera imprimé sur la console. Si x
n'est aucune de ces valeurs, le message "x n'est pas 1, 2 ou 3" sera affiché sur la console.
L' instruction switch est un outil utile pour exécuter du code basé sur la valeur d'une variable et peut être
plus efficace que l'utilisation de plusieurs instructions if-else dans certaines situations. Il est important
d'inclure l' instruction break à la fin de chaque clause case pour empêcher le code de passer au cas
suivant. La clause par défaut est facultative, mais est généralement incluse pour spécifier un bloc de code à
exécuter si l'expression ne correspond à aucune des valeurs de cas.
Instructions d'itération
En C++, les instructions d'itération, également appelées boucles, sont utilisées pour exécuter plusieurs
fois un bloc de code. Il existe trois types d'instructions d'itération en C++ : la boucle for , la boucle while
et la boucle do- while.
La boucle
for est
for est la suivante :
utilisée pour exécuter un bloc de code un certain nombre de fois. La syntaxe de la boucle
for (initialisation ; condition ; incrémentation) {
// code à exécuter
}
La clause d' initialisation est utilisée pour initialiser une variable de boucle, la clause de condition est utilisée
pour spécifier une condition qui est vérifiée avant chaque itération de la boucle, et la clause d'
incrémentation est utilisée pour modifier la variable de boucle à la fin de chaque itération.
Voici un exemple d'utilisation de la boucle
for en C++ :
Dans cet exemple, la boucle for est utilisée pour exécuter le bloc de code 10 fois. La variable de boucle i
est initialisée à 0, et la condition i < 10 est vérifiée avant chaque itération de la boucle. Si la condition est
vraie, le bloc de code est exécuté et la variable de boucle est incrémentée de 1. Cela entraînera
l'exécution de la boucle 10 fois, la valeur de i augmentant de
tandis que la déclaration
En C++, la boucle while est un type d'instruction d'itération utilisée pour exécuter un bloc de code de
façon répétée alors qu'une condition est vraie. La syntaxe de la boucle while est la suivante :
tandis que (état) {
// code à exécuter
}
La clause condition est utilisée pour spécifier une condition qui est vérifiée avant chaque itération de la boucle. Si la condition est
vraie, le bloc de code est exécuté. Si la condition est fausse, la boucle est terminée et le contrôle est
transféré à l'instruction suivante suivant la boucle.
Voici un exemple d'utilisation de la boucle while en C++
:
Dans cet exemple, la boucle while est utilisée pour exécuter le bloc de code 10 fois. La condition x < 10 est
vérifiée avant chaque itération de la boucle. Si la condition est vraie, le bloc de code est exécuté et la
valeur de x est incrémentée de 1. Cela entraînera l'exécution de la boucle 10 fois, la valeur de x
augmentant de 1 à chaque fois. La sortie de ce programme sera les nombres 0 à 9, chacun sur une ligne
distincte.
La boucle while est un outil utile pour exécuter un bloc de code de manière répétée alors qu'une condition
est vraie. Il est important d'inclure une instruction dans la boucle qui finira par entraîner la condition à
devenir
instruction do-while
En C++, la boucle do- while est un type d'instruction d'itération utilisée pour exécuter un bloc de code de
manière répétée alors qu'une condition est vraie. La syntaxe de la boucle do- while est la suivante :
faire {
// code à exécuter
} tant que (condition);
Le bloc de code est exécuté une fois avant que la condition ne soit vérifiée. Si la condition est vraie, le bloc
de code est exécuté à nouveau. Si la condition est fausse, la boucle est terminée et le contrôle est
transféré à l'instruction suivante suivant la boucle.
Voici un exemple d'utilisation de la boucle
do-
while en C++ :
Dans cet exemple, la boucle do- while est utilisée pour exécuter le bloc de code 10 fois. Le bloc de code
est exécuté une fois avant que la condition x < 10 ne soit vérifiée. Si la condition est vraie, le bloc de code
est exécuté à nouveau et la valeur de x est incrémentée de 1. Cela entraînera l'exécution de la boucle 10
fois, la valeur de x augmentant de 1 à chaque fois. La sortie de ce programme sera les nombres 0 à 9,
chacun sur une ligne distincte.
La boucle
do- while
pour la déclaration
En C++, la boucle for est un type d'instruction d'itération utilisée pour exécuter un bloc de code un
certain nombre de fois. La syntaxe de la boucle for est la suivante :
for (initialisation ; condition ; incrémentation) {
// code à exécuter
}
La clause d' initialisation est utilisée pour initialiser une variable de boucle, la clause de condition est utilisée
pour spécifier une condition qui est vérifiée avant chaque itération de la boucle, et la clause d'
incrémentation est utilisée pour modifier la variable de boucle à la fin de chaque itération.
Voici un exemple d'utilisation de la boucle
for en C++ :
Dans cet exemple, la boucle for est utilisée pour exécuter le bloc de code 10 fois. La variable de boucle i
est initialisée à 0, et la condition i < 10 est vérifiée avant chaque itération de la boucle. Si la condition est
vraie, le bloc de code est exécuté et la variable de boucle est incrémentée de 1. Cela entraînera
l'exécution de la boucle 10 fois, la valeur de i augmentant de 1 à chaque fois. La sortie de ce programme
sera les nombres 0 à 9, chacun sur une ligne distincte.
La boucle for est un outil utile pour exécuter un bloc de code un certain nombre de fois et est souvent
utilisée lorsque le nombre d'itérations est connu à l'avance. Il est important d'inclure une instruction dans
la boucle qui finira par rendre la condition fausse, sinon la boucle deviendra une boucle infinie.
Instruction for basée sur la plage
En C++, la boucle for basée sur la plage est un type d'instruction d'itération utilisée pour itérer sur les
éléments d'une plage. La syntaxe de la boucle for basée sur la plage est la suivante :
for (range_declaration : range_expression) {
// code à exécuter
}
La range_declaration est une variable déclarée pour chaque élément de la plage, et la
expression qui spécifie la plage sur laquelle itérer.
Voici un exemple d'utilisation de la boucle
range_expression
est une
for basée sur la plage en C++ :
Dans cet exemple, la boucle for basée sur la plage est utilisée pour parcourir les éléments du vecteur de
nombres . Le numéro de variable de boucle est déclaré pour chaque élément de la plage, et les numéros
d'expression de plage spécifient la plage sur laquelle itérer. Cela entraînera l'exécution de la boucle 5 fois, la
valeur de number étant définie tour à tour sur chaque élément du vecteur de nombres . La sortie de ce
programme sera les nombres 1 à 5, chacun sur une ligne distincte.
basée sur la plage est un outil utile pour itérer sur les éléments d'une plage et est souvent utilisée pour
simplifier le code qui utilise des boucles for traditionnelles. Il est important de s'assurer que l'expression de
plage spécifie une plage qui n'est pas modifiée pendant la boucle, car cela peut entraîner un
comportement indéfini.
for
Chapitre dix
instructions de saut
En C++, les instructions de saut sont utilisées pour transférer le contrôle à un autre point du programme.
Il existe quatre types d'instructions de saut en C++ : l' instruction break , l' instruction continue , l' instruction
goto et l' instruction return .
L' instruction break est utilisée pour terminer une boucle ou une instruction switch et transférer le
contrôle à l'instruction suivante suivant la boucle ou l'interrupteur. La syntaxe de l' instruction break est la
suivante :
Pause;
Voici un exemple d'utilisation de l' instruction
break
en C++ :
Dans cet exemple, l' instruction break est utilisée pour terminer la boucle for lorsque la valeur de i est 5.
La boucle s'exécutera 5 fois, la valeur de i augmentant de 1 à chaque fois. Lorsque la valeur de i devient
5, l' instruction break sera exécutée et la boucle sera terminée. La sortie de ce programme sera les
nombres 0 à 4, chacun sur une ligne séparée.
L' instruction continue est utilisée pour ignorer le reste de l'itération en cours d'une boucle et transférer le
contrôle à l'itération suivante. La syntaxe de l' instruction continue est la suivante :
Continuez;
Voici un exemple d'utilisation de l' instruction
continue
en C++ :
Dans cet exemple, l' instruction continue est utilisée pour ignorer le reste de l'itération actuelle de la
boucle for si la valeur de i est paire. La boucle s'exécutera 10 fois, la valeur de i augmentant de 1 à chaque
fois. Si la valeur de i est paire, l' instruction continue sera exécutée et le reste de l'itération en cours sera
ignoré. La sortie de ce programme sera les nombres impairs de 1 à 9, chacun sur une ligne distincte.
L' instruction goto est utilisée pour transférer le contrôle à une instruction étiquetée dans la même fonction.
La syntaxe de l' instruction goto est la suivante :
aller à l'étiquette ;
...
étiquette:
// code à exécuter
L' instruction
return
est utilisée pour terminer une fonction et retourner une valeur
déclaration de rupture
En C++, l' instruction break est une instruction de saut utilisée pour terminer une boucle ou une
instruction switch et transférer le contrôle à l'instruction suivante suivant la boucle ou l'interrupteur. La
syntaxe de l' instruction break est la suivante :
Pause;
Voici un exemple d'utilisation de l' instruction
break
en C++ :
Dans cet exemple, l' instruction break est utilisée pour terminer la boucle for lorsque la valeur de i est 5.
La boucle s'exécutera 5 fois, la valeur de i augmentant de 1 à chaque fois. Lorsque la valeur de i devient
5, l' instruction break sera exécutée et la boucle sera terminée. La sortie de ce programme sera les
nombres 0 à 4, chacun sur une ligne séparée.
L' instruction break est souvent utilisée pour terminer une boucle ou une instruction switch plus tôt
lorsqu'une certaine condition est remplie. Il est important d'utiliser l' instruction break uniquement dans le
corps d'une boucle ou d'une instruction switch, car son utilisation en dehors de ces contextes entraînera
une erreur de compilation.
continuer la déclaration
En C++, l' instruction continue est une instruction de saut utilisée pour ignorer le reste de l'itération
actuelle d'une boucle et transférer le contrôle à l'itération suivante. La syntaxe de l' instruction continue est
la suivante :
Continuez;
Voici un exemple d'utilisation de l' instruction
continue
en C++ :
Dans cet exemple, l' instruction continue est utilisée pour ignorer le reste de l'itération actuelle de la
boucle for si la valeur de i est paire. La boucle s'exécutera 10 fois, la valeur de i augmentant de 1 à chaque
fois. Si la valeur de i est paire, l' instruction continue sera exécutée et le reste de l'itération en cours sera
ignoré. La sortie de ce programme sera les nombres impairs de 1 à 9, chacun sur une ligne distincte.
L' instruction continue est souvent utilisée pour ignorer certaines itérations d'une boucle lorsqu'une
certaine condition est remplie. Il est important d'utiliser l' instruction continue uniquement dans le corps
d'une boucle, car son utilisation en dehors d'une boucle entraînera une erreur de compilation.
déclaration de retour
En C++, l' instruction de retour est une instruction de saut utilisée pour terminer une fonction et renvoyer
une valeur à la fonction appelante. La syntaxe de l' instruction return est la suivante :
expression de retour ;
L'
est une expression facultative qui spécifie une valeur à renvoyer à la fonction appelante. Si l'
est omise, la fonction renvoie la valeur par défaut pour le type de retour de la fonction.
expression
expression
Voici un exemple d'utilisation de l' instruction
return
en C++ :
Dans cet exemple, l' instruction return est utilisée pour renvoyer le résultat de la fonction add à la fonction
appelante. La fonction add prend deux arguments, x et y , et renvoie leur somme. L' instruction return est
exécutée lorsque la fonction add est appelée et la valeur de x + y est renvoyée à la fonction appelante.
Dans ce cas, la valeur 5 est renvoyée et imprimée à l'écran.
L' instruction return est utilisée pour terminer une fonction et renvoyer une valeur à la fonction appelante.
Il est important de s'assurer que le type de retour de la fonction est compatible avec la valeur renvoyée,
car tenter de renvoyer une valeur du mauvais type entraînera une erreur de compilation.
Aller à l'instruction
En C++, l' instruction goto est une instruction de saut utilisée pour transférer le contrôle à une instruction
étiquetée dans la même fonction. La syntaxe de l' instruction goto est la suivante :
aller à l'étiquette ;
...
étiquette:
// code à exécuter
L' étiquette est un identifiant défini par l'utilisateur qui est utilisé pour marquer un point dans le code
auquel le contrôle peut être transféré.
Voici un exemple d'utilisation de l'
instruction goto
en C++ :
Dans cet exemple, l' instruction goto est utilisée pour transférer le contrôle à l' étiquette paire lorsque la
valeur de x est paire. La boucle while s'exécutera indéfiniment, la valeur de x augmentant de 1 à chaque fois.
Si la valeur de x est paire, l' instruction goto sera exécutée et le contrôle sera transféré à l' étiquette paire .
Au niveau de l' étiquette paire , un message est imprimé à l'écran indiquant qu'un nombre pair a été
rencontré.
L' instruction goto est généralement considérée comme une construction de flux de contrôle moins
souhaitable que d'autres options telles que les instructions if , les boucles for et les boucles while . Il est
généralement recommandé d'utiliser goto avec parcimonie, voire pas du tout, car cela peut rendre le code
plus difficile à comprendre et à maintenir.
Transferts de contrôle
En C++, les transferts de contrôle sont utilisés pour modifier le flux d'exécution d'un programme. Il existe
plusieurs types de transferts de contrôle en C++, notamment :
Instructions conditionnelles : Les instructions conditionnelles sont utilisées pour exécuter
un bloc de code de manière conditionnelle en fonction de la valeur d'une expression
booléenne. L' instruction if est utilisée pour exécuter un bloc de code si une condition est
vraie, et l' instruction if-else est utilisée pour exécuter un bloc de code si une condition est
vraie et un autre bloc de code si la condition est fausse.
itération : Les instructions d'itération sont utilisées pour exécuter un bloc de code de
manière répétée. La boucle while est utilisée pour exécuter un bloc de code alors qu'une
condition est vraie, la boucle do- while est utilisée pour exécuter un bloc de code au moins
une fois puis à plusieurs reprises tant qu'une condition est vraie, et la boucle for est utilisée
pour exécuter un bloc de code un certain nombre de fois.
saut : Les instructions de saut sont utilisées pour transférer le contrôle à un point différent
du programme. L' instruction break est utilisée pour terminer une boucle ou une instruction
switch et transférer le contrôle à l'instruction suivante suivant la boucle ou l'interrupteur, l'
instruction continue est utilisée pour ignorer le reste de l'itération en cours d'une boucle et
transférer le contrôle à l'itération suivante, la goto est utilisée pour transférer le contrôle à
une instruction étiquetée dans la même fonction, et l' instruction return est utilisée pour
terminer une fonction et renvoyer une valeur à la fonction appelante.
Gestion des exceptions : La gestion des exceptions permet de gérer des erreurs ou des
circonstances exceptionnelles pouvant survenir lors de l'exécution d'un programme. L'
instruction try est utilisée pour inclure un bloc de code susceptible de lever une exception, l'
instruction throw est utilisée pour lever une exception et l' instruction catch est utilisée pour
gérer une exception qui a été levée.
Espaces de noms
En C++, un espace de noms est un conteneur pour un ensemble d'identificateurs (tels que des fonctions,
des variables et des classes). Les espaces de noms sont utilisés pour organiser et gérer les identifiants
dans un programme et pour éviter les collisions de noms entre des identifiants portant le même nom mais
des significations différentes.
La syntaxe pour définir un espace de noms en C++ est la suivante :
espace de noms namespace_name {
// déclarations
}
Le namespace_name est le nom de l'espace de noms et les déclarations dans l'espace de noms sont les
identificateurs contenus dans l'espace de noms.
Voici un exemple de définition et d'utilisation d'un espace de noms en C++ :
Dans cet exemple, l' espace de noms my_namespace contient les variables x et y et la fonction add . Les
identificateurs au sein de l'espace de noms sont accessibles à l'aide de la syntaxe namespace_name ::identifier .
Dans ce cas, les variables x et y sont accessibles à l'aide de la syntaxe my_namespace::x et my_namespace::y , et la
fonction add est accessible à l'aide de la syntaxe my_namespace::add .
Les espaces de noms sont utiles pour organiser et gérer les identifiants dans un programme et pour
empêcher les collisions de noms entre des identifiants portant le même nom mais des significations
différentes. Il est important de choisir des noms descriptifs et uniques pour les espaces de noms afin
d'éviter les conflits avec d'autres espaces de noms dans le même programme.
Énumérations
Une énumération (ou enum) en C++ est un moyen de définir un ensemble de constantes entières
nommées. Il est souvent utilisé pour attribuer des noms significatifs à un ensemble de valeurs intégrales,
ce qui facilite la compréhension et la maintenance du code.
Voici un exemple de définition d'une énumération :
enum Couleur {
RED, // RED reçoit la valeur 0
GREEN, // GREEN reçoit la valeur 1
BLEU, // BLEU prend la valeur 2
JAUNE // JAUNE prend la valeur 3
};
Dans cet exemple, nous avons défini une énumération appelée Color avec quatre membres : RED , GREEN ,
BLUE et YELLOW . Par défaut, le premier membre d'une énumération se voit attribuer la valeur 0, et chaque
membre suivant se voit attribuer une valeur supérieure d'une unité au membre précédent. Donc, dans ce
cas, ROUGE est 0, VERT est 1, BLEU est 2 et JAUNE est 3.
Vous pouvez également spécifier explicitement les valeurs de chaque membre de l'énumération, comme
ceci :
enum Couleur {
ROUGE = 10, // ROUGE reçoit la valeur 10
GREEN = 20, // GREEN reçoit la valeur 20
BLEU = 30, // BLEU reçoit la valeur 30
JAUNE = 40 // JAUNE prend la valeur 40
};
Une fois que vous avez défini une énumération, vous pouvez utiliser ses membres comme des variables :
Couleur favoriteColor = RED;
si (favoriteColor == ROUGE) {
std::cout << "Votre couleur préférée est le rouge." << std ::endl;
}
Les énumérations sont souvent utilisées en conjonction avec une instruction
ensemble fixe de valeurs :
switch (favoriteColor) {
boîtier ROUGE :
std::cout << "Votre couleur préférée est le rouge." << std ::endl;
Pause;
boîtier VERT :
std::cout << "Votre couleur préférée est le vert." << std ::endl;
Pause;
étui BLEU :
std::cout << "Votre couleur préférée est le bleu." << std ::endl;
Pause;
switch
pour gérer un
boîtier JAUNE :
std::cout << "Votre couleur préférée est le jaune." << std ::endl;
Pause;
défaut:
std::cout << "Votre couleur préférée est inconnue." << std ::endl;
Pause;
}
J'espère que ça aide! Faites moi savoir si vous avez des questions.
Les syndicats
En C++, une union est un type de données qui vous permet de stocker différents types de données dans le
même emplacement mémoire. Il est similaire à une structure, mais un seul membre est accessible à la
fois.
Voici un exemple de définition d'une union en C++ :
Dans cet exemple, le syndicat MyUnion compte trois membres : x , y et z . Cependant, étant donné qu'un
syndicat ne vous permet d'accéder qu'à un seul membre à la fois, vous ne pouvez utiliser qu'un seul de ces
membres à la fois.
Pour accéder aux membres d'un syndicat, vous pouvez utiliser le
une structure :
.
opérateur, comme vous le feriez avec
Les unions sont souvent utilisées lorsque vous souhaitez stocker différents types de données dans le
même emplacement mémoire, mais vous n'avez besoin d'accéder qu'à l'un d'entre eux à la fois. Cela peut
être utile pour économiser de la mémoire dans certaines situations. Cependant, vous devez être prudent
lorsque vous utilisez des unions, car il est facile d'écraser accidentellement les valeurs d'un membre avec
un autre.
Les fonctions
En C++, une fonction est un bloc de code qui exécute une tâche spécifique et peut renvoyer une valeur.
Les fonctions vous permettent de réutiliser le code et de diviser un programme volumineux en éléments
plus petits et plus faciles à gérer.
Voici un exemple de fonction simple en C++ :
Cette fonction, appelée
d'entier.
add
, prend deux arguments entiers,
x
et
y
, et renvoie leur somme sous forme
Pour appeler cette fonction et utiliser sa valeur de retour, vous feriez quelque chose comme ceci :
En C++, les fonctions peuvent avoir différents types de paramètres et de valeurs de retour. Par exemple,
une fonction pourrait renvoyer une valeur à virgule flottante, ou elle pourrait n'avoir aucune valeur de
retour (auquel cas elle aurait un type de retour de void ).
Les fonctions peuvent également avoir des valeurs par défaut pour leurs paramètres. Cela vous permet
d'appeler la fonction avec moins d'arguments, auquel cas les valeurs par défaut seront utilisées pour les
arguments manquants. Voici un exemple:
Les fonctions sont une partie importante de C++ et sont largement utilisées dans la plupart des
programmes. Ils vous aident à écrire un code plus modulaire et réutilisable, ce qui peut faciliter la
compréhension et la maintenance de vos programmes.
Fonctions avec des listes d'arguments variables
En C++, vous pouvez définir une fonction avec un nombre variable d'arguments en utilisant la notation
C'est ce qu'on appelle une fonction « variadique ».
Voici un exemple de fonction variadique simple en C++ :
....
Cette fonction, appelée print , prend une chaîne de format comme premier argument et un nombre variable
d'arguments supplémentaires. La chaîne de format spécifie les types des arguments supplémentaires. Par
exemple, si la chaîne de format est "dffs", cela indique que les trois arguments suivants sont des entiers et
que le quatrième argument est une chaîne.
Pour appeler cette fonction, vous pouvez utiliser la notation
un exemple:
... pour transmettre les arguments supplémentaires.
Voici
print("dffs", 10, 3.14, 5.67, "bonjour"); // Sortie "10 3.14 5.67 bonjour"
Les fonctions variadiques peuvent être utiles lorsque vous devez transmettre un nombre variable
d'arguments à une fonction, mais elles peuvent également être plus difficiles à utiliser et à gérer que les
fonctions à arguments fixes. Il est généralement recommandé d'utiliser des fonctions à arguments fixes
dans la mesure du possible et de n'utiliser des fonctions variadiques que lorsque cela est nécessaire.
Surcharge de fonctions
En C++, la surcharge de fonctions est une fonctionnalité qui vous permet de définir plusieurs fonctions
avec le même nom, mais avec des ensembles d'arguments différents. Le compilateur C++ sélectionnera
automatiquement la fonction correcte à appeler en fonction du nombre et des types d'arguments passés à
la fonction.
Voici un exemple de surcharge de fonction en C++ :
Dans cet exemple, la fonction add est surchargée trois fois. La première version prend deux arguments
entiers et renvoie un entier. La deuxième version prend deux arguments doubles et renvoie un double. La
troisième version prend deux arguments de chaîne et renvoie une chaîne.
Pour appeler l'une de ces fonctions, vous pouvez utiliser la syntaxe d'appel de fonction normale et le
compilateur C++ sélectionnera automatiquement la version correcte de la fonction en fonction des types
d'arguments que vous transmettez. Par exemple:
int a = ajouter(1, 2); // Appelle la première version de add
double b = addition(3.14, 2.72); // Appelle la seconde version de add
std::string c = add("bonjour", "monde"); // Appelle la troisième version de add
La surcharge de fonction peut être utile lorsque vous souhaitez effectuer des opérations similaires sur
différents types de données ou lorsque vous souhaitez fournir plusieurs versions d'une fonction avec
différents nombres d'arguments. Cependant, vous devez être prudent lorsque vous surchargez des
fonctions, car cela peut être déroutant pour les utilisateurs de votre code si les fonctions ont le même nom
mais se comportent différemment en fonction des arguments. C'est généralement une bonne idée de
choisir des noms de fonctions qui décrivent clairement leur objectif et les types d'arguments qu'elles
attendent.
Fonctions explicitement définies par défaut et supprimées
En C++, vous pouvez utiliser la syntaxe
certaines fonctions de votre classe.
= default
et
= delete
pour spécifier le comportement par défaut de
La syntaxe = default peut être utilisée pour spécifier explicitement qu'une fonction doit avoir son
comportement par défaut, qui est défini par le langage C++. Ceci est généralement utilisé pour les
fonctions qui ont une implémentation par défaut, telles que le constructeur de copie ou l'opérateur
d'affectation.
Voici un exemple d'utilisation de
constructeur de copie :
= default
pour spécifier explicitement le comportement par défaut d'un
La syntaxe = delete peut être utilisée pour spécifier explicitement qu'une fonction ne doit pas être utilisée.
Ceci est souvent utilisé pour empêcher le compilateur de générer certaines fonctions dont vous ne voulez
pas, comme le constructeur de copie ou l'opérateur d'affectation.
Voici un exemple d'utilisation de
pas être utilisé :
= delete
pour spécifier explicitement qu'un constructeur de copie ne doit
L'utilisation de = default et = delete peut être utile dans certaines situations où vous souhaitez contrôler
explicitement le comportement de certaines fonctions de votre classe. Cependant, vous devez être
prudent lorsque vous utilisez ces syntaxes, car elles peuvent prêter à confusion pour les utilisateurs de
votre code si elles ne sont pas utilisées correctement. C'est généralement une bonne idée d'utiliser le
comportement par défaut des fonctions chaque fois que possible, et d'utiliser uniquement = default ou =
delete lorsque cela est nécessaire.
Recherche de nom dépendant de l'argument (Koenig) sur
En C++, la recherche de nom dépendante de l'argument (également appelée "recherche Koenig") est une
fonctionnalité qui permet au compilateur de rechercher des fonctions dans les espaces de noms des types
des arguments de la fonction. Cela peut être utile lorsque vous souhaitez appeler une fonction définie
dans le même espace de noms que l'un des arguments de la fonction.
Voici un exemple du fonctionnement de la recherche de nom dépendant d'un argument en C++ :
Dans cet exemple, la fonction f est définie dans l' espace de noms A et prend un argument de type X , qui
est également défini dans l' espace de noms A. La fonction f appelle la fonction g , qui n'est pas définie
dans l' espace de noms A. Cependant, comme g est appelé avec un argument de type Y , qui est défini
dans l' espace de noms B , le compilateur recherchera g dans l' espace de noms B en utilisant la
recherche de nom dépendant de l'argument. Cela permet au compilateur de trouver la bonne définition de
g et de l'appeler correctement.
La recherche de nom dépendante de l'argument peut être utile lorsque vous souhaitez appeler des
fonctions définies dans le même espace de noms que l'un des arguments de la fonction. Cependant, cela
peut également prêter à confusion si vous ne faites pas attention, car le compilateur peut trouver
plusieurs définitions de la même fonction dans différents espaces de noms. C'est généralement une bonne
idée d'utiliser des noms complets pour les fonctions afin d'éviter toute confusion potentielle.
fonctions en c++
En C++, une fonction est un bloc de code qui exécute une tâche spécifique et peut renvoyer une valeur.
Les fonctions vous permettent de réutiliser le code et de diviser un programme volumineux en éléments
plus petits et plus faciles à gérer.
Voici un exemple de fonction simple en C++ :
Cette fonction, appelée
d'entier.
add
, prend deux arguments entiers,
x
et
y
, et renvoie leur somme sous forme
Pour appeler cette fonction et utiliser sa valeur de retour, vous feriez quelque chose comme ceci :
En C++, les fonctions peuvent avoir différents types de paramètres et de valeurs de retour. Par exemple,
une fonction pourrait renvoyer une valeur à virgule flottante, ou elle pourrait n'avoir aucune valeur de
retour (auquel cas elle aurait un type de retour de void ).
Les fonctions peuvent également avoir des valeurs par défaut pour leurs paramètres. Cela vous permet
d'appeler la fonction avec moins d'arguments, auquel cas les valeurs par défaut seront utilisées pour les
arguments manquants. Voici un exemple:
Les fonctions sont une partie importante de C++ et sont largement utilisées dans la plupart des
programmes. Ils vous aident à écrire un code plus modulaire et réutilisable, ce qui peut faciliter la
compréhension et la maintenance de vos programmes.
Arguments par défaut
En C++, vous pouvez spécifier des valeurs par défaut pour les arguments de fonction. Cela vous permet
d'appeler la fonction avec moins d'arguments, auquel cas les valeurs par défaut seront utilisées pour les
arguments manquants.
Voici un exemple de fonction avec des arguments par défaut en C++ :
Dans cet exemple, la fonction add prend deux arguments entiers, x et y . L' argument y a une valeur par défaut
de 1 , ce qui signifie qu'il est facultatif. Vous pouvez appeler cette fonction avec un ou deux arguments :
int a = ajouter(3); // a est maintenant égal à 4
entier b = ajouter(3, 5); // b est maintenant égal à 8
Les arguments par défaut peuvent être utiles lorsque vous souhaitez fournir des valeurs par défaut pour
les arguments de fonction facultatifs. Cependant, vous devez être prudent lorsque vous utilisez des
arguments par défaut, car ils peuvent rendre votre code plus difficile à comprendre s'ils sont utilisés de
manière excessive. C'est généralement une bonne idée d'utiliser des arguments par défaut uniquement
pour les arguments facultatifs qui ont une valeur par défaut claire et évidente.
Fonctions en ligne
En C++, une fonction inline est une fonction qui est développée sur place par le compilateur chaque fois
qu'elle est appelée, plutôt que d'être appelée via le mécanisme d'appel de fonction normal. Les fonctions
en ligne peuvent être utiles pour améliorer les performances de votre programme en réduisant la
surcharge des appels de fonction.
Voici un exemple de fonction inline en C++ :
Pour utiliser cette fonction en ligne, vous pouvez l'appeler comme n'importe quelle autre fonction :
int a = 3 ;
entier b = 4 ;
entier c = ajouter(a, b); // c est maintenant égal à 7
Le mot-clé inline est une demande au compilateur pour développer la fonction en ligne, mais le
compilateur n'est pas obligé d'honorer cette demande. Le compilateur peut choisir de ne pas intégrer la
fonction s'il détermine que cela ne serait pas bénéfique.
Les fonctions en ligne peuvent être utiles pour améliorer les performances de votre programme en
réduisant la surcharge des appels de fonction. Cependant, vous devez être prudent lorsque vous utilisez
des fonctions en ligne, car elles peuvent augmenter la taille de votre programme si elles sont utilisées de
manière excessive. C'est généralement une bonne idée d'utiliser les fonctions inline uniquement pour les
petites fonctions simples qui sont appelées fréquemment.
Chapitre onze
Surcharge de l'opérateur
En C++, la surcharge d'opérateur est une fonctionnalité qui vous permet de redéfinir le comportement
des opérateurs pour les types définis par l'utilisateur. Cela peut être utile pour rendre votre code plus
lisible et intuitif en vous permettant d'utiliser des opérateurs comme + , - , * et / avec vos propres types.
Voici un exemple de surcharge d'opérateur en C++ :
Dans cet exemple, la classe Vector2 a trois opérateurs surchargés : + , - et * . Ces opérateurs vous
permettent d'ajouter, de soustraire et de multiplier des objets Vector2 à l'aide des opérateurs familiers
- et * .
+
,
Pour utiliser ces opérateurs surchargés, vous pouvez utiliser la syntaxe d'opérateur normale :
La surcharge d'opérateurs peut être utile pour rendre votre code plus lisible et intuitif. Cependant, vous
devez être prudent lorsque vous surchargez des opérateurs, car cela peut être source de confusion pour
les utilisateurs de votre code si les opérateurs se comportent de manière inattendue. C'est généralement
une bonne idée de surcharger les opérateurs d'une manière cohérente avec leur comportement standard.
Règles générales de surcharge des opérateurs
En C++, il existe quelques règles générales à suivre lors de la surcharge d'opérateurs :
1. Opérateurs de surcharge uniquement pour les types qui ont un sens. Par exemple, il n'est pas
logique de surcharger l' opérateur + pour un type qui représente une connexion à une base de données.
2. Surcharger les opérateurs d'une manière cohérente avec leur comportement standard. Par
exemple, si vous surchargez l' opérateur + pour un type qui représente un nombre complexe,
il doit ajouter les parties réelles et imaginaires des nombres.
3. Évitez de surcharger les opérateurs qui modifient le comportement fondamental de
l'opérateur. Par exemple, ce n'est généralement pas une bonne idée de surcharger l'
opérateur
= pour effectuer une autre opération, car cela peut prêter à confusion pour les utilisateurs de votre code.
4. Utilisez le mot-clé const de manière appropriée lors de la surcharge d'opérateurs. Cela vous
permettra d'utiliser l'opérateur surchargé sur les objets const et d'empêcher les utilisateurs de modifier
accidentellement l'objet.
5. Soyez conscient de la priorité et de l'associativité des opérateurs que vous surchargez. Cela
garantira que vos opérateurs surchargés se comportent comme prévu lorsqu'ils sont utilisés
dans des expressions avec d'autres opérateurs.
En suivant ces règles générales, vous pouvez vous assurer que la surcharge de votre opérateur est claire,
intuitive et cohérente avec le comportement standard des opérateurs. Cela rendra votre code plus facile à
comprendre et à maintenir.
Surcharger les opérateurs unaires
En C++, vous pouvez surcharger les opérateurs unaires (opérateurs qui prennent un seul opérande) en
définissant des fonctions membres ou des fonctions non membres avec les noms appropriés.
Voici un exemple de surcharge de l'opérateur unaire
Dans cet exemple, la classe
Vector2 .
Vector2 a un opérateur -
-
en tant que fonction membre :
surchargé qui annule les composants
x
et
y
de l' objet
Pour utiliser cet opérateur surchargé, vous pouvez utiliser la syntaxe normale de l'opérateur :
Voici un exemple de surcharge de l'unaire
!
opérateur en tant que fonction non membre :
Dans cet exemple, la classe MyClass a une fonction membre appelée getValue qui renvoie la valeur d'une
variable membre privée. Le ! L'opérateur est surchargé en tant que fonction non membre qui nie la
valeur renvoyée par getValue .
Pour utiliser cet opérateur surchargé, vous pouvez utiliser la syntaxe normale de l'opérateur :
La surcharge d'opérateur unaire peut être utile pour rendre votre code plus lisible et intuitif. Cependant,
vous devez être prudent lorsque vous surchargez des opérateurs unaires, car cela peut être source de
confusion pour les utilisateurs de votre code si les opérateurs se comportent de manière inattendue. C'est
généralement une bonne idée de surcharger les opérateurs unaires d'une manière cohérente avec leur
comportement standard.
Surcharge des opérateurs d'incrémentation et de décrémentation
En C++, vous pouvez surcharger les opérateurs d'incrémentation ( ++ ) et de décrémentation ( -- ) pour
les types définis par l'utilisateur. Cela peut être utile pour rendre votre code plus lisible et intuitif en vous
permettant d'utiliser ces opérateurs avec vos propres types.
Voici un exemple de surcharge des opérateurs d'incrémentation et de décrémentation en tant que
fonctions membres :
Dans cet exemple, la classe Counter a surchargé les opérateurs ++ et -- qui incrémentent et décrémentent
une variable membre privée appelée value_ . L' opérateur ++ est surchargé à la fois dans les formes de préfixe ( ++x ) et
de suffixe ( x++ ), et l' opérateur -- est surchargé dans les formes de préfixe ( --x ) et de suffixe ( x-- ).
Pour utiliser ces opérateurs surchargés, vous pouvez utiliser la syntaxe d'opérateur normale :
La surcharge des opérateurs d'incrémentation et de décrémentation peut être utile pour rendre votre
code plus lisible et intuitif. Cependant, vous devez être prudent lorsque vous surchargez ces opérateurs,
car cela peut être source de confusion pour les utilisateurs de votre code si les opérateurs se comportent
de manière inattendue. C'est généralement une bonne idée de surcharger ces opérateurs d'une manière
cohérente avec leur comportement standard.
Opérateurs binaires
En C++, un opérateur binaire est un opérateur qui prend deux opérandes. Certains exemples courants
d'opérateurs binaires incluent + , - , * , / et % .
Voici un exemple d'utilisation d'opérateurs binaires en C++ :
En C++, vous pouvez également surcharger les opérateurs binaires pour les types définis par l'utilisateur.
Cela vous permet de définir un comportement personnalisé pour les opérateurs lorsqu'ils sont utilisés
avec vos propres types.
Voici un exemple de surcharge de l' opérateur
Dans cet exemple, la classe
objets Vector2 .
+ en tant que fonction membre :
Vector2 a un opérateur +
surchargé qui ajoute les composants
x
et
y
des deux
Pour utiliser cet opérateur surchargé, vous pouvez utiliser la syntaxe normale de l'opérateur :
La surcharge d'opérateurs binaires peut être utile pour rendre votre code plus lisible et intuitif.
Cependant, vous devez être prudent lorsque vous surchargez des opérateurs binaires, car cela peut être
source de confusion pour les utilisateurs de votre code si les opérateurs se comportent de manière
inattendue. C'est généralement une bonne idée de surcharger les opérateurs binaires d'une manière
cohérente avec leur comportement standard.
Mission
En C++, l'opérateur d'affectation (
=
) est utilisé pour affecter une valeur à une variable.
Voici un exemple d'utilisation de l'opérateur d'affectation en C++ :
Dans la première ligne, l' opérateur = est utilisé pour initialiser la variable a à la valeur 3 . Dans la
deuxième ligne, l' opérateur = est utilisé pour attribuer une nouvelle valeur à a , en écrasant la valeur précédente.
Vous pouvez également utiliser l'opérateur d'affectation pour enchaîner les affectations, comme ceci :
Dans cet exemple, l'opérateur d'affectation est utilisé pour affecter la valeur
0
aux trois variables dans
une seule ligne de code.
Vous pouvez également utiliser l'opérateur d'affectation pour affecter la valeur d'une expression à une
variable, comme ceci :
Dans cet exemple, l' opérateur
variable c .
=
est utilisé pour affecter le résultat de l'expression
a+b
(qui est
7
) à la
L'opérateur d'affectation est une partie importante de C++ et est largement utilisé dans la plupart des
programmes. Il vous permet d'attribuer des valeurs aux variables et de modifier leurs valeurs si
nécessaire.
Appel de fonction
En C++, un appel de fonction est une expression qui appelle une fonction et passe éventuellement des
arguments à la fonction. La syntaxe d'un appel de fonction est le nom de la fonction suivi d'une liste
d'arguments entre parenthèses.
Voici un exemple d'appel de fonction en C++ :
Dans cet exemple, la fonction add prend deux arguments entiers, x et y , et renvoie leur somme sous
forme d'entier. La fonction est appelée en utilisant son nom suivi des arguments entre parenthèses. La
valeur de retour de la fonction est affectée à la variable c .
Vous pouvez également utiliser des appels de fonction dans le cadre d'expressions, comme ceci :
Dans cet exemple, l'appel de fonction add(a, b) est utilisé dans le cadre d'une expression qui multiplie la
valeur de retour par 2 . Le résultat de l'expression est alors affecté à la variable c .
Les appels de fonction sont une partie importante de C++ et sont largement utilisés dans la plupart des
programmes. Ils vous permettent de réutiliser le code et de diviser un programme volumineux en
éléments plus petits et plus faciles à gérer.
Abonnement
En C++, l'indice (également appelé indexation) est un moyen d'accéder aux éléments individuels d'un
tableau ou d'un conteneur à l'aide de l' opérateur [] .
Voici un exemple d'utilisation de l'indice pour accéder aux éléments d'un tableau en C++ :
Dans cet exemple, l' opérateur [] est utilisé pour accéder aux éléments du tableau arr . Le premier
élément du tableau a un index de 0 , le deuxième élément a un index de 1 , et ainsi de suite.
Vous pouvez également utiliser l'indice pour modifier les éléments d'un tableau :
L'abonnement est un moyen puissant et pratique d'accéder et de modifier les éléments d'un tableau ou
d'un conteneur en C++. Il est largement utilisé dans de nombreux programmes pour manipuler des
données stockées dans des tableaux et des conteneurs.
Accès membre
En C++, l'accès aux membres est un moyen d'accéder aux données membres et aux fonctions membres
d'une classe ou d'une structure à l'aide de l'extension . ou -> opérateur.
Voici un exemple d'utilisation de l'accès aux membres pour accéder aux données membres d'une classe en
C++ :
Dans cet exemple, la classe Point a deux membres de données, x_ et y_ , et deux fonctions membres, getX
et getY , qui renvoient les valeurs de ces membres de données. Les membres de données sont accessibles
à l'aide de . et les fonctions membres sont appelées à l'aide de l'opérateur . opérateur et parenthèses.
Vous pouvez également utiliser l'accès membre pour appeler les fonctions membres d'une classe :
Classes et structures
En C++, les classes et les structures sont des types définis par l'utilisateur qui vous permettent de définir
vos propres types de données personnalisés.
Une classe est un type défini par l'utilisateur qui peut contenir des données membres (variables) et des
fonctions membres (fonctions faisant partie de la classe). Les classes sont définies à l'aide du mot-clé class
, comme ceci :
Dans cet exemple, la classe Point a deux membres de données,
et getY , qui renvoient les valeurs de ces membres de données.
x_
et
y_
, et deux fonctions membres,
getX
Une structure est similaire à une classe, mais tous ses membres sont publics par défaut. Les structures
sont définies à l'aide du mot-clé struct , comme ceci :
Dans cet exemple, la structure
Point
a deux membres de données,
x
et
y
, qui sont tous deux publics.
Vous pouvez créer une instance d'une classe ou d'un struct en utilisant l' opérateur
une variable de type class ou struct, comme ceci :
new
ou en déclarant
Point p1(1, 2); // Crée une instance de Point en utilisant le constructeur
Point *p2 = nouveau Point(3, 4); // Crée une instance de Point en utilisant new
Point p3 ; // Crée une instance de Point avec le constructeur par défaut
Les classes et les structures sont une partie importante de C++ et sont largement utilisées dans de
nombreux programmes pour définir des types de données personnalisés et encapsuler des données et des
fonctionnalités.
quelle est la classe
En C++, une classe est un type défini par l'utilisateur qui peut contenir des données membres (variables)
et des fonctions membres (fonctions faisant partie de la classe). Les classes sont définies à l'aide du motclé class , comme ceci :
Dans cet exemple, la classe Point a deux membres de données,
et getY , qui renvoient les valeurs de ces membres de données.
x_
et
Vous pouvez créer une instance d'une classe en utilisant l' opérateur
type classe, comme ceci :
y_
, et deux fonctions membres,
new
getX
ou en déclarant une variable de
Point p1(1, 2); // Crée une instance de Point en utilisant le constructeur
Point *p2 = nouveau Point(3, 4); // Crée une instance de Point en utilisant new
Point p3 ; // Crée une instance de Point avec le constructeur par défaut
Les classes sont une partie importante de C++ et sont largement utilisées dans de nombreux programmes
pour définir des types de données personnalisés et encapsuler des données et des fonctionnalités.
quelle structure
En C++, une structure est un type défini par l'utilisateur qui est similaire à une classe, mais tous les
membres sont publics par défaut. Les structures sont définies à l'aide du mot-clé struct , comme ceci :
Dans cet exemple, la structure
Point
a deux membres de données,
x
et
y
, qui sont tous deux publics.
Vous pouvez créer une instance d'un struct en déclarant une variable de type struct, comme ceci :
Les structures sont souvent utilisées pour définir des structures de données simples qui n'ont pas besoin
de l'encapsulation et de la protection fournies par les classes. Cependant, les structures peuvent
également contenir des fonctions membres et peuvent être utilisées de la même manière que les classes
dans de nombreux cas.
Les structures sont une partie importante de C++ et sont largement utilisées dans de nombreux
programmes pour définir des types de données personnalisés et regrouper des données associées.
Présentation des membres du groupe
En C++, une classe est un type défini par l'utilisateur qui peut contenir des données membres (variables)
et des fonctions membres (fonctions faisant partie de la classe). Les classes sont définies à l'aide du motclé class , comme ceci :
Dans cet exemple, la classe Point a deux membres de données,
et getY , qui renvoient les valeurs de ces membres de données.
x_
et
y_
, et deux fonctions membres,
getX
Le mot-clé public dans la définition de classe spécifie que les membres qui le suivent sont accessibles
depuis l'extérieur de la classe. Cela signifie que vous pouvez accéder aux fonctions membres et aux
données membres d'une instance de la classe Point depuis l'extérieur de la classe à l'aide de . opérateur.
Le mot-clé private dans la définition de classe spécifie que les membres qui le suivent ne sont accessibles
qu'à partir de la classe. Cela signifie que vous ne pouvez pas accéder aux données membres directement
depuis l'extérieur de la classe, mais vous pouvez y accéder via les fonctions membres.
Vous pouvez créer une instance d'une classe en utilisant l' opérateur
type classe, comme ceci :
new
ou en déclarant une variable de
Les classes sont une partie importante de C++ et sont largement utilisées dans de nombreux programmes
pour définir des types de données personnalisés et encapsuler des données et des fonctionnalités.
Contrôle d'accès des membres
En C++, vous pouvez utiliser les mots clés
membres d'une classe.
public
,
private
et
protected
pour spécifier le contrôle d'accès des
Le mot-clé public spécifie que les membres qui le suivent sont accessibles depuis l'extérieur de la classe.
Cela signifie que vous pouvez accéder aux fonctions membres et aux membres de données d'une instance
de la classe depuis l'extérieur de la classe à l'aide de . opérateur.
Le mot-clé private spécifie que les membres qui le suivent ne sont accessibles qu'à partir de la classe. Cela
signifie que vous ne pouvez pas accéder aux données membres directement depuis l'extérieur de la
classe, mais vous pouvez y accéder via les fonctions membres.
Le mot-clé protected spécifie que les membres qui le suivent ne sont accessibles qu'à partir de la classe et
de ses classes dérivées. Cela signifie que vous ne pouvez pas accéder aux données membres directement
depuis l'extérieur de la classe, mais vous pouvez y accéder via les fonctions membres de la classe et de
ses classes dérivées.
Voici un exemple d'utilisation du contrôle d'accès dans une définition de classe :
Dans cet exemple, la classe Point a deux fonctions membres publiques, getX et getY , qui peuvent être
appelées depuis l'extérieur de la classe à l'aide de la classe . opérateur. Les membres de données x_ et
sont privés, ce qui signifie qu'ils ne sont accessibles qu'à partir de la classe.
Le contrôle d'accès est une partie importante de C++ et est utilisé pour spécifier quels membres d'une
classe sont accessibles depuis l'extérieur de la classe. Il vous permet d'encapsuler des données et des
fonctionnalités et de contrôler leur utilisation.
qu'est-ce qu'un ami
En C++, une fonction friend est une fonction qui a accès aux membres privés et protégés d'une classe.
Une fonction amie n'est pas une fonction membre de la classe, mais elle a accès aux détails
d'implémentation internes de la classe.
y_
Vous pouvez déclarer une fonction comme
de la classe, comme ceci :
amie
d'une classe en utilisant le mot-clé
friend
dans la définition
Dans cet exemple, la classe Point a un membre de données privé, x_ , et une fonction friend , distance , qui a
accès au membre de données x_ . La fonction de distance n'est pas une fonction membre de la classe Point ,
mais elle peut accéder aux données privées membres de la classe Point comme s'il s'agissait d'une fonction
membre.
sont utiles lorsque vous souhaitez autoriser une fonction à accéder aux données privées membres
d'une classe, mais que vous ne souhaitez pas faire de la fonction une fonction membre de la classe. Ils
sont également utilisés pour implémenter la surcharge d'opérateurs en C++.
friend
sont une partie importante de C++ et sont largement utilisées dans de nombreux programmes pour
implémenter des techniques de programmation avancées et la surcharge des opérateurs.
friend
privé
En C++, le mot clé private est utilisé pour spécifier le contrôle d'accès pour les membres d'une classe. Les
membres d'une classe qui sont déclarés comme privés ne sont accessibles que depuis l'intérieur de la
classe, et ils ne sont pas accessibles directement depuis l'extérieur de la classe.
Voici un exemple d'utilisation du mot clé
Dans cet exemple, la classe
Point
private
dans une définition de classe :
a deux fonctions membres publiques,
getX
et
getY
, qui peuvent être
appelées depuis l'extérieur de la classe à l'aide de la classe . opérateur. Les membres de données
sont privés, ce qui signifie qu'ils ne sont accessibles qu'à partir de la classe.
x_
et
y_
Le contrôle d'accès privé est utilisé pour encapsuler les données et les fonctionnalités et contrôler leur
utilisation. Il vous permet de masquer les détails d'implémentation d'une classe au code externe et de
protéger l'intégrité des données.
Le mot clé private est une partie importante de C++ et est largement utilisé dans de nombreux
programmes pour spécifier le contrôle d'accès pour les membres d'une classe.
protégé
En C++, le mot clé protected est utilisé pour spécifier le contrôle d'accès pour les membres d'une classe.
Les membres d'une classe qui sont déclarés comme protégés ne sont accessibles qu'à partir de la classe et
de ses classes dérivées, et ils ne sont pas accessibles directement depuis l'extérieur de la classe.
Voici un exemple d'utilisation du mot clé
protected
dans une définition de classe :
Dans cet exemple, la classe Point a deux fonctions membres publiques, getX et getY , qui peuvent être
appelées depuis l'extérieur de la classe à l'aide de la classe . opérateur. Les membres de données x_ et
sont protégés, ce qui signifie qu'ils ne sont accessibles qu'à partir de la classe Point et de ses classes
dérivées.
La classe ColorPoint est dérivée de la classe Point et a accès aux membres de données x_ et
ces membres de données ne sont pas accessibles depuis l'extérieur de la classe ColorPoint .
y_
y_
. Cependant,
Le contrôle d'accès protégé est utilisé pour permettre aux classes dérivées d'accéder aux données et aux
fonctionnalités de leurs classes de base, tout en masquant les détails d'implémentation du code externe.
C'est une partie importante du mécanisme d'héritage en C++ et est largement utilisé dans de nombreux
programmes pour spécifier le contrôle d'accès pour les membres d'une classe.
Publique
En C++, le mot clé public est utilisé pour spécifier le contrôle d'accès pour les membres d'une classe. Les
membres d'une classe qui sont déclarés comme public sont accessibles depuis l'extérieur de la classe, et ils
peuvent être accédés directement en utilisant le . opérateur.
Voici un exemple d'utilisation du mot clé
public
dans une définition de classe :
Dans cet exemple, la classe Point a deux fonctions membres publiques, getX et getY , qui peuvent être
appelées depuis l'extérieur de la classe à l'aide de la classe . opérateur. Les membres de données x_ et
sont privés, ce qui signifie qu'ils ne sont accessibles qu'à partir de la classe.
y_
Le contrôle d'accès public est utilisé pour spécifier quels membres d'une classe sont accessibles depuis
l'extérieur de la classe. Il vous permet d'exposer les données et les fonctionnalités d'une classe à du code
externe et de contrôler son utilisation.
Le mot clé public est une partie importante de C++ et est largement utilisé dans de nombreux
programmes pour spécifier le contrôle d'accès pour les membres d'une classe.
Initialisation des accolades
En C++, l'initialisation des accolades est un moyen d'initialiser des variables et des objets à l'aide
d'accolades {} . Il permet de spécifier les valeurs des variables ou des arguments au constructeur d'un
objet lors de sa création.
Voici quelques exemples d'utilisation de l'initialisation des accolades :
L'initialisation des accolades est préférée aux autres formes d'initialisation en C++ car elle est plus
expressive et moins sujette aux erreurs. Il est également plus flexible et vous permet d'initialiser des
variables et des objets avec une gamme plus large de valeurs et de types.
L'initialisation des accolades est une partie importante de C++ et est largement utilisée dans de
nombreux programmes pour initialiser des variables et des objets. Il est particulièrement utile lorsque
vous souhaitez spécifier des valeurs ou des arguments autres que ceux par défaut pour le constructeur
d'un objet.
Gestion de la durée de vie et des ressources des objets (RAII)
En C++, la durée de vie d'un objet fait référence à la période de temps pendant laquelle l'objet existe en
mémoire et est accessible à partir de votre code. Une bonne gestion de la durée de vie des objets est
importante car elle détermine quand les ressources sont allouées et libérées, et combien de temps les
ressources sont disponibles pour votre programme.
Une manière courante de gérer la durée de vie des objets et des ressources en C++ consiste à utiliser la
technique RAII (Resource Acquisition Is Initialization). RAII est un modèle de conception qui utilise la
durée de vie des objets pour gérer les ressources de manière sûre, efficace et sans exception.
L'idée de base du RAII est d'associer l'acquisition d'une ressource à la création d'un objet, et la libération
de la ressource à la destruction de l'objet. Cela garantit que la ressource est automatiquement libérée
lorsque l'objet sort de la portée ou est détruit, même si une exception est levée.
Voici un exemple d'utilisation de RAII pour gérer la durée de vie d'un objet et d'une ressource :
Dans cet exemple, la classe File gère la durée de vie d'un handle de fichier. Le descripteur de fichier est
acquis dans le constructeur de l' objet File et publié dans le destructeur. Cela garantit que le descripteur
de fichier est toujours correctement fermé, même si une exception est levée pendant l'utilisation du
fichier.
RAII est une partie importante de C++ et est largement utilisé dans de nombreux programmes pour gérer
la durée de vie des objets et des ressources de manière sûre et efficace. Cela aide à prévenir les fuites de
ressources et à améliorer la fiabilité et la sécurité des exceptions de votre code.
Idiome Pimpl pour l'encapsulation au moment de la compilation
En C++, l'idiome Pointer to IMPLementation (Pimpl) est un modèle de conception utilisé pour réaliser
l'encapsulation au moment de la compilation des détails d'implémentation. Il est utilisé pour masquer les
détails d'implémentation d'une classe à partir de l'interface publique, tout en permettant à la classe d'être
utilisée de manière sécurisée.
L'idée de base de l'idiome Pimpl est de définir l'interface publique d'une classe dans un fichier d'en-tête et
de définir les détails d'implémentation dans un fichier source séparé. Les détails d'implémentation sont
accessibles via un pointeur vers une classe déclarée en avant qui est définie dans le fichier
d'implémentation.
Portabilité aux limites ABI
En C++, l'Application Binary Interface (ABI) définit les conventions et les règles d'interaction entre les
différents composants logiciels au niveau binaire. Il spécifie comment les données sont disposées en
mémoire, comment les appels et les retours de fonction sont effectués, et d'autres détails de bas niveau
qui sont nécessaires pour que différents composants logiciels interagissent.
Lors de l'écriture de code C++ portable, il est important de considérer l'ABI aux frontières entre les
différents composants logiciels, tels que les bibliothèques, les exécutables et les objets partagés.
Différents compilateurs et plates-formes peuvent avoir des ABI différents, et il est important de s'assurer
que votre code est compatible avec les ABI des plates-formes que vous ciblez.
Il existe plusieurs façons d'assurer la portabilité aux limites ABI en C++ :
1. Utilisez un ABI stable : certaines plates-formes, telles que Linux et Windows, ont des ABI
stables qui sont pris en charge par plusieurs compilateurs. En utilisant une ABI stable, vous
pouvez vous assurer que votre code est compatible avec différents compilateurs et platesformes.
2. Utilisez une ABI multiplateforme : plusieurs ABI multiplateformes sont disponibles, telles que
l'ABI Itanium C++, qui sont prises en charge par plusieurs compilateurs sur différentes
plates-formes. En utilisant une ABI multiplateforme, vous pouvez vous assurer que votre code
est portable sur différentes plateformes.
3. Utilisez un système de gestion des versions : certains systèmes, tels que le système de
gestion des versions ELF sous Linux, vous permettent de spécifier différentes versions de
votre code pour différentes ABI. En utilisant un système de gestion des versions, vous pouvez
vous assurer que votre code est compatible avec différentes ABI et plates-formes.
4. Utiliser une couche de compatibilité : Certains systèmes, tels que le format Microsoft
Windows Portable Executable (PE), vous permettent de spécifier des informations de
compatibilité dans le binaire. En utilisant une couche de compatibilité, vous pouvez vous
assurer que votre code est compatible
Chapitre douze
Constructeurs
En C++, un constructeur est une fonction membre spéciale d'une classe qui est appelée lorsqu'un objet
de la classe est créé. Les constructeurs sont utilisés pour initialiser les membres de données de l'objet et
effectuer toute autre tâche requise pour configurer l'objet en vue de son utilisation.
Les constructeurs ont le même nom que la classe et n'ont pas de type de retour, pas même void. Ils sont
automatiquement appelés par le compilateur lorsqu'un objet est créé, et ils ne peuvent pas être appelés
directement depuis votre code.
Voici un exemple de classe avec un constructeur :
Dans cet exemple, la classe Point a un constructeur qui prend deux arguments, x et y , et initialise les
membres de données x_ et y_ avec ces valeurs. Le constructeur n'a pas de type de retour, et il est appelé
automatiquement par le compilateur lorsqu'un objet de la classe Point est créé.
Les constructeurs sont une partie importante de C++ et sont largement utilisés dans de nombreux
programmes pour initialiser des objets et effectuer d'autres tâches lors de leur création. Vous pouvez
définir plusieurs constructeurs dans une classe pour fournir différentes manières de créer des objets ou
pour prendre en charge
Constructeurs de copie et opérateurs d'affectation de copie
En C++, un constructeur de copie est une fonction membre spéciale d'une classe qui est appelée
lorsqu'un objet de la classe est créé en tant que copie d'un autre objet. Un opérateur d'affectation de
copie est une fonction membre spéciale qui est appelée lorsqu'un objet est affecté à un autre objet.
Les constructeurs de copie et les opérateurs d'affectation de copie sont utilisés pour effectuer une copie
complète d'un objet, ce qui signifie qu'ils créent un nouvel objet avec une copie distincte des membres de
données de l'objet d'origine. Cela est nécessaire pour garantir que le nouvel objet est indépendant de
l'objet d'origine et peut être modifié sans affecter l'objet d'origine.
Voici un exemple de classe avec un constructeur de copie et un opérateur d'affectation de copie :
Dans cet exemple, la classe Point a un constructeur de copie qui prend une référence const à un autre
objet Point et initialise les données membres du nouvel objet avec les valeurs de l'objet d'origine.
L'opérateur d'affectation de copie est défini comme un opérateur d'affectation surchargé qui effectue une
copie complète des membres de données de l'objet d'origine.
Les constructeurs de copie et les opérateurs d'affectation de copie sont une partie importante de C++ et
sont largement utilisés dans de nombreux programmes pour prendre en charge la création et l'affectation
d'objets. Ils sont nécessaires pour s'assurer que les objets sont correctement copiés et modifiés sans
affecter les objets d'origine.
Déplacer les constructeurs et déplacer les opérateurs d'affectation
En C++, un constructeur de déplacement est une fonction membre spéciale d'une classe qui est appelée
lorsqu'un objet de la classe est créé en déplaçant le contenu d'un autre objet. Un opérateur d'affectation
de déplacement est une fonction membre spéciale qui est appelée lorsqu'un objet est affecté à un autre
objet en déplaçant le contenu de l'objet d'origine.
Les constructeurs de déplacement et les opérateurs d'affectation de déplacement sont utilisés pour
effectuer un déplacement d'un objet, ce qui signifie qu'ils transfèrent le contenu de l'objet d'origine vers
le nouvel objet sans faire de copie. Ceci est plus efficace que de faire une copie car cela évite la surcharge
de copie des membres de données de l'objet.
Voici un exemple de classe avec un constructeur de déplacement et un opérateur d'affectation de
déplacement :
Dans cet exemple, la classe Point a un constructeur de déplacement qui prend une référence rvalue à un
autre objet Point et initialise les données membres du nouvel objet avec les valeurs de l'objet d'origine.
L'opérateur d'affectation de déplacement est défini comme un opérateur d'affectation surchargé qui
effectue un déplacement des membres de données de l'objet d'origine.
Les constructeurs de déplacement et les opérateurs d'affectation de déplacement sont une partie
importante de C++ et sont largement utilisés dans de nombreux programmes pour prendre en charge la
création et l'affectation efficaces d'objets. Ils sont particulièrement utiles lorsque vous travaillez avec des
objets volumineux ou des objets avec des opérations de copie coûteuses, car ils peuvent améliorer les
performances de votre code.
Constructeurs délégués
En C++, la délégation de constructeurs est une fonctionnalité qui permet à un constructeur d'une classe
d'appeler un autre constructeur de la même classe dans le cadre de son initialisation. Cela peut être utile
lorsque vous souhaitez fournir plusieurs façons de construire un objet ou lorsque vous souhaitez réutiliser
le code d'initialisation d'un constructeur dans un autre constructeur.
Pour utiliser des constructeurs délégués, vous pouvez utiliser la syntaxe : suivie du nom du constructeur
que vous souhaitez appeler et des arguments que vous souhaitez lui transmettre. Le constructeur appelé
est exécuté avant le corps du constructeur appelant, et il peut initialiser les membres de données et
effectuer d'autres tâches selon les besoins.
Voici un exemple de classe avec des constructeurs délégués :
Dans cet exemple, la classe Point a trois constructeurs : un constructeur par défaut, un constructeur à un
argument et un constructeur à deux arguments. Le constructeur par défaut et le constructeur à argument
unique utilisent des constructeurs de délégation pour initialiser les données membres de l'objet en
appelant le constructeur à deux arguments avec les arguments appropriés.
Les constructeurs délégués sont une partie importante de C++ et sont largement utilisés dans de
nombreux programmes pour fournir plusieurs façons de construire des objets et de réutiliser le code
d'initialisation. Ils peuvent améliorer la lisibilité et la maintenabilité de votre code en réduisant la
duplication et en vous permettant de centraliser les tâches d'initialisation courantes dans un seul
constructeur.
Destructeurs
En C++, un destructeur est une fonction membre spéciale d'une classe qui est appelée lorsqu'un objet de
la classe est détruit. Les destructeurs sont utilisés pour effectuer toutes les tâches nécessaires pour
nettoyer l'objet et libérer toutes les ressources qu'il contient.
Les destructeurs ont le même nom que la classe précédé d'un tilde ( ~ ) et n'ont pas d'arguments ni de
type de retour. Ils sont automatiquement appelés par le compilateur lorsqu'un objet sort de la portée ou
est supprimé, et ils ne peuvent pas être appelés directement à partir de votre code.
Voici un exemple de classe avec un destructeur :
Dans cet exemple, la classe Point a un destructeur qui n'a pas d'arguments ou de type de retour et
n'exécute aucune tâche. Le destructeur est appelé automatiquement par le compilateur lorsque l' objet
sort de la portée à la fin de main .
Les destructeurs sont une partie importante de C++ et sont largement utilisés dans de nombreux
programmes pour libérer des ressources et effectuer d'autres tâches lorsque des objets sont détruits.
Vous pouvez définir un destructeur dans une classe pour effectuer toutes les tâches requises pour
p
nettoyer l'objet avant qu'il ne soit détruit.
Aperçu des fonctions des membres
En C++, les fonctions membres sont des fonctions qui sont définies dans une classe et opèrent sur les
données membres de la classe. Ils constituent une partie importante de l'interface de classe et sont
utilisés pour fournir le comportement et les fonctionnalités de la classe.
Les fonctions membres ont plusieurs caractéristiques qui les distinguent des autres types de fonctions :
1. Les fonctions membres sont définies dans la définition de classe et ont accès aux données
privées membres de la classe. Cela leur permet d'agir sur l'état interne de l'objet et de
fournir le comportement et la fonctionnalité souhaités.
2. Les fonctions membres sont appelées à l'aide de . ou -> opérateur, selon que l'objet est une
référence ou un pointeur. Cela vous permet d'appeler la fonction membre sur un objet et
d'accéder à ses membres de données.
3. Les fonctions membres peuvent être déclarées en tant que const , ce qui signifie qu'elles ne
modifient pas les données membres de l'objet et peuvent être appelées sur un objet const.
Cela vous permet de définir des fonctions qui ne modifient pas l'état de l'objet et peuvent être
appelées à partir du contexte const.
Voici un exemple de classe avec quelques fonctions membres :
spécificateur virtuel
En C++, le spécificateur virtuel est utilisé pour déclarer une fonction membre virtuelle dans une classe.
Une fonction membre virtuelle est une fonction membre qui peut être remplacée par des classes dérivées,
leur permettant de fournir leur propre implémentation de la fonction.
Le spécificateur virtuel est utilisé dans la déclaration de la fonction membre dans la classe de base, et la
fonction est marquée comme override dans la classe dérivée pour indiquer qu'elle remplace
l'implémentation de la classe de base.
Voici un exemple de classe avec une fonction membre virtuelle :
Dans cet exemple, la classe Shape a une fonction de membre virtuel pur draw qui est déclarée avec le
spécificateur virtual et n'a pas d'implémentation. Les classes Circle et Square sont dérivées de Shape et
fournissent leurs propres implémentations de la fonction draw en la marquant comme override .
Les fonctions membres virtuelles sont une partie importante de C++ et sont largement utilisées dans de
nombreux programmes pour prendre en charge le polymorphisme et le polymorphisme d'exécution. Ils
vous permettent de définir une interface commune pour un groupe de classes associées et de fournir
différentes implémentations pour chaque classe, en fonction de son comportement et de ses
fonctionnalités spécifiques.
spécificateur de remplacement
En C++, le spécificateur de remplacement est utilisé pour indiquer qu'une fonction membre dans une classe
dérivée remplace une fonction membre virtuelle dans la classe de base. Le spécificateur de remplacement
garantit que la fonction de classe dérivée a la même signature et le même type de retour que la fonction
de classe de base, et il aide à éviter les erreurs et à améliorer la lisibilité du code.
Le spécificateur de remplacement est utilisé dans la déclaration de la fonction membre dans la classe
dérivée et doit être précédé du spécificateur virtuel dans la déclaration de la fonction de classe de base.
Voici un exemple de classe avec une fonction membre virtuelle et une fonction surchargée :
Dans cet exemple, la classe Shape a une fonction de membre virtuel pur draw qui est déclarée avec le
spécificateur virtual et n'a pas d'implémentation. La classe Circle est dérivée de Shape et fournit sa propre
implémentation de la fonction draw en la marquant comme override .
Le spécificateur de remplacement est une partie importante de C++ et est largement utilisé dans de
nombreux programmes pour indiquer qu'une fonction membre dans une classe dérivée remplace une
fonction membre virtuelle dans la classe de base. Cela permet de s'assurer que la fonction de classe
dérivée a la signature et le type de retour corrects et d'éviter les erreurs dans l'implémentation de la
classe dérivée.
table des matières
Votre guide complet étape par étape pour tout savoir sur C++
Présentation
Chapitre un
notions de base
Système de types C++
Portée
Fichiers d'en-tête
Unités de traduction et liaison
fonction principale et arguments de ligne de commande
Arrêt du programme
Valeurs L et valeurs r
Objets temporaires
Alignement
Trivial, mise en page standard et types de POD
qu'est-ce que les types de valeur
Conversions de type et sécurité de type
Conversions standards
Chapitre II
types intégrés
Types intégrés
Plages de types de données
nullpt
nullptr
bouffon
faux
vrai
__m64
__m128
__m128d
__m128i
__ptr32, __ptr64
Chapitre III
LIMITES NUMERIQUES
Limites numériques
Limites d'entiers
Limites flottantes
le quatrième chapitre
Déclarations et définitions
Classes de stockage
automatique
const
constexpr
externe
Initialiseurs
Alias et typedefs
en utilisant la déclaration
volatil
décltype
Attributs
Chapitre V
Opérateurs intégrés, priorité et association
aligner l'opérateur
Opérateur __uuidof
Opérateurs additifs : + et Adresse de l'opérateur : &
Opérateurs d'affectation
Opérateur ET au niveau du bit : &
Opérateur OU exclusif au niveau du bit : ^
Opérateur OU inclusif au niveau du bit : |
Opérateur de distribution : ()
Opérateur virgule : ,
Opérateur conditionnel : ? :
supprimer l'opérateur
Opérateurs d'égalité : == et !=
Opérateur de conversion de type explicite : ()
Opérateur d'appel de fonction : ()
Opérateur d'indirection : *
Opérateurs de décalage à gauche et à droite (>> et <<)
Opérateur ET logique : &&
Opérateur de négation logique : !
Opérateur logique OU : ||
Opérateurs d'accès membres : . et ->
Opérateurs multiplicatifs et opérateur de module
nouvel opérateur
Opérateur complément à un : ~
Opérateurs pointeur vers membre : .* et ->*
Opérateurs d'incrémentation et de décrémentation suffixés : ++ et -Opérateurs d'incrémentation et de décrémentation préfixés : ++ et -Opérateurs relationnels : <, >, <= et >=
Opérateur de résolution de portée : ::
taille de l'opérateur
Opérateur d'indice :
opérateur typeid en
Opérateurs unaires plus et négation : + et Expressions
Chapitre six
Types d'expressions
Expressions primaires
Modèles de points de suspension et variadiques
Expressions postfixées
Expressions avec opérateurs unaires
Expressions avec opérateurs binaires
Expressions constantes
Sémantique des expressions
qu'est-ce que le casting
septième chapitre
Opérateurs de fonderie
opérateur dynamic_cast
exception bad_cast
opérateur static_cast
opérateur const_cast
opérateur reinterpret_cast
Chapitre VIII
Informations sur le type d'exécution (RTTI)
exception bad_typeid
type_info classe
Déclarations
Présentation des instructions C++
Énoncés étiquetés
Énoncé d'expression
Instruction nulle
Instructions composées (Blocs)
Chapitre Neuf
Énoncés de sélection
instruction if-else
__if_exists instruction
__if_not_exists instruction
instruction switch
Instructions d'itération
tandis que la déclaration
instruction do-while
pour l'énoncé
Basé sur la plage pour l'instruction
Chapitre dix
instructions de saut
déclaration de rupture
continuer la déclaration
déclaration de retour
aller à l'instruction
Transferts de contrôle
noms
Énumérations
Syndicats
Fonctions
Fonctions avec des listes d'arguments variables
Surcharge de fonctions
Fonctions explicitement définies par défaut et supprimées
Recherche de nom dépendant de l'argument (Koenig) sur
Arguments par défaut
Fonctions en ligne
Chapitre onze
Surcharge opérateur
Règles générales de surcharge des opérateurs
Surcharger les opérateurs unaires
Surcharge des opérateurs d'incrémentation et de décrémentation
Opérateurs binaires
Devoir
Appel de fonction
Abonnement
Accès membre
Classes et structures
qu'est-ce que la classe
quelle structure
Aperçu des membres du groupe
Contrôle d'accès des membres
qu'est-ce qu'un ami
privé
protégé
publique
Initialisation des accolades
Gestion de la durée de vie et des ressources des objets (RAII)
Idiome Pimpl pour l'encapsulation au moment de la compilation
Portabilité aux limites ABI
Chapitre douze
Constructeurs
Constructeurs de copie et opérateurs d'affectation de copie
Déplacer les constructeurs et déplacer les opérateurs d'affectation
Constructeurs
Destructeurs
Vue d'ensemble des fonctions membres
spécificateur virtuel
remplacer le spécificateur