c operators types
Une étude complète des opérateurs en C ++ avec des exemples:
Dans ce Série de formations intensives C ++, nous avons appris les différents concepts en C ++ tels que les variables, les classes de stockage, les qualificateurs de type, etc. dans nos tutoriels précédents. Nous avons également appris comment modifier ces variables.
Pour effectuer ces modifications, nous devons effectuer des opérations sur ces variables et constantes et pour effectuer ces opérations, nous utilisons des opérateurs.
Les opérateurs sont des symboles qui agissent sur des variables ou d'autres entités appelées opérandes et effectuent des opérations mathématiques ou logiques pour modifier leurs valeurs et produire des résultats en conséquence.
Ce que vous apprendrez:
Opérateurs en C ++
Les opérateurs constituent la base de tout langage de programmation. Sans opérateurs, nous ne pouvons pas modifier ou manipuler les entités des langages de programmation et ne pouvons donc pas produire les résultats souhaités. C ++ est très riche en opérateurs intégrés dont nous parlerons en détail dans ce tutoriel.
En C ++, la plupart des opérateurs sont des opérateurs binaires, c'est-à-dire que ces opérateurs nécessitent deux opérandes pour effectuer une opération. Peu d'opérateurs comme l'opérateur ++ (incrément) sont l'opérateur unaire, ce qui signifie qu'ils n'opèrent que sur un opérande.
Il existe également un opérateur ternaire en C ++ appelé Conditional Operator qui prend trois opérandes. Nous en apprendrons davantage à ce sujet dans la dernière partie du didacticiel.
Types d'opérateurs en C ++
Les opérateurs en C ++ sont classés comme indiqué ci-dessous:
Explorons chaque type d’opérateur C ++ en détail !!
Opérateurs arithmétiques
Les opérateurs arithmétiques sont utilisés pour effectuer des opérations mathématiques de base sur les opérandes.
C ++ prend en charge les opérations arithmétiques suivantes:
| Opérateur | Binaire / unaire | Description |
|---|---|---|
| - | Unaire | Opérateur de décrémentation - diminue la valeur de l'opérande de 1 |
| + | Binaire | Ajout de deux opérandes |
| - | Binaire | Soustraction de deux opérandes |
| * | Binaire | Multiplication de deux opérandes |
| / | Binaire | Division de deux opérandes |
| % | Binaire | Opérateur de module - le résultat est le reste de la division |
| ++ | Unaire | Opérateur d'incrémentation - augmente la valeur de l'opérande de 1 |
L'exemple ci-dessous montre les cinq premiers opérateurs arithmétiques en C ++
#include #include using namespace std; int main() { int op1=3,op2=4; float op3=10.1,op4=5.4; cout<<'Operands are op1 = '< Les prochains opérateurs arithmétiques dont nous allons discuter sont ++ et -. Ceux-ci sont appelés respectivement opérateurs d'incrémentation et de décrémentation. L'opérateur d'incrémentation augmente la valeur de l'opérande de 1 tandis que l'opérateur de décrémentation diminue la valeur de l'opérande de 1.
L'expression x ++ équivaut à
x + = 1;
x = x + 1;
De même, l'expression x — équivaut à
x - = 1;
x = x-1;
Les opérateurs d'incrémentation et de décrémentation peuvent être placés en tant que préfixe ainsi que suffixe à l'opérande. En fonction de son emplacement, ces opérateurs ont une signification différente de l'évaluation d'une expression.
Lorsqu'elle est placée en tant que préfixe, l'opération d'incrémentation / décrémentation est appelée respectivement pré-incrémentation ou pré-décrémentation. Lorsqu'elle est placée comme suffixe, l'opération d'incrémentation / décrémentation est appelée respectivement comme opération post-incrémentation ou post-décrémentation.
Chaque fois que des expressions sont impliquées, en cas de pré-incrémentation ou de pré-décrémentation, l'opération (incrémentation ou décrémentation) est effectuée en premier, puis l'affectation est effectuée. Dans le cas de post-incrémentation ou post-décrémentation, l'affectation est effectuée en premier et l'opération est effectuée par la suite.
Nous pouvons mieux comprendre cela en utilisant l'exemple suivant.
#include #include using namespace std; int main() { int x=4,y; y = ++x; cout<<'PreIncrement:Value of x = '< Dans la seconde expression y = x–, la valeur de x qui est maintenant 5, sera d'abord affectée à y, puis la valeur de x sera décrémentée. Par conséquent, dans la sortie, nous pouvons voir que pour l'opération de post-décrémentation, la valeur de y est 5 tandis que x est 4.
Opérateurs logiques
Les opérateurs logiques sont utilisés pour évaluer une combinaison de conditions / contraintes pour obtenir une valeur résultante. Le résultat de l'évaluation d'une expression booléenne est Boolean qui est soit vrai soit faux.
C ++ prend en charge les opérateurs logiques suivants:
Opérateur Description 7 L-> R <<
>> Décalage au niveau du bit vers la gauche
Décalage binaire à droite && ET logique: retourne vrai si les deux conditions sont vraies sinon retourne faux. || OR logique: renvoie vrai si l'une des conditions est vraie. Renvoie false lorsque les deux conditions sont fausses. ! NON logique: annule la condition.
C ++ utilise une méthode de court-circuit pour évaluer les expressions logiques. En cela, C ++ doit évaluer uniquement la première expression / opérande de l'expression logique pour fournir le résultat. Par exemple, pour l'opérateur logique AND (&&), C ++ évalue uniquement la première expression. S'il est faux, le résultat sera faux même si la deuxième condition est vraie.
De même, pour OR logique (||), il n'évalue que la première expression. Si la première expression est vraie, le résultat sera vrai et il n'est donc pas nécessaire d'évaluer la deuxième expression.
Ci-dessous est un exemple qui montre l'utilisation des opérateurs logiques.
#include #include using namespace std; int main() int a=10, b=8,c=12,d=14; if(!(a==0)) cout<<'a is not zero'< Production:
a n'est pas nul
ET logique est vrai
OR logique est vrai
Dans le programme ci-dessus, nous avons utilisé les trois opérateurs logiques pour évaluer les expressions et imprimer les résultats.
Opérateurs relationnels
Des opérateurs relationnels ou de comparaison sont utilisés pour comparer deux opérandes. Le résultat de l'évaluation est vrai ou faux.
C ++ prend en charge les opérateurs relationnels suivants:
Opérateur Description !ERREUR! opérateur inattendu '=' Évalue si deux opérandes sont égaux. Renvoie vrai si égal sinon renvoie faux. ! = (différent de) Complète l'opérateur «égal à». Renvoie true si les opérandes ne sont pas égaux. Faux sinon. <(less than) Renvoie true si le premier opérande est inférieur à la seconde. Faux sinon. <=(less than equal to) Renvoie true si le premier opérande est inférieur ou égal au deuxième opérande. Faux sinon. > (supérieur à) Renvoie true si le premier opérande est supérieur à la seconde. Faux sinon. > = (supérieur à égal à) Renvoie true si le premier opérande est supérieur à égal au second. Faux sinon.
Consultez l'exemple de programme ci-dessous pour comprendre les opérateurs relationnels.
#include #include using namespace std; int main() { int a=10, b=8,c=12,d=14; if(a==b) cout<<'a is equal to b'< Production:
a n'est pas égal à b
c n'est pas égal à d
(a + b) inférieur / égal à (c + d)
(a-b) supérieur / égal à (d-c)
Dans le programme ci-dessus, nous voyons l'utilisation des opérateurs relationnels et la manière dont ils évaluent les expressions fournies.
Notez que nous pouvons fournir non seulement des valeurs mais également des variables et des expressions dans les instructions conditionnelles.
Opérateurs au niveau du bit
Les opérateurs binaires en C ++ fonctionnent sur les bits des opérandes fournis. Les opérateurs au niveau du bit sont appliqués uniquement aux types intégraux tels que les entiers, les caractères, etc., et non aux types de données tels que float, double, etc.
Voici les opérateurs binaires pris en charge par C ++:
Les opérateurs Description & (ET binaire) Effectue l'opération AND sur les bits de l'opérande 1 et de l'opérande 2. | (OU binaire) Effectue une opération OR sur les bits de l'opérande 1 et de l'opérande 2. ^ (XOR binaire) Effectue une opération XOR sur les bits de l'opérande 1 et de l'opérande 2. ~ (Complément binaire à un) Prend un opérande et inverse ses bits. <<( Binary left shift operator) Décale les bits du premier opérande vers la gauche vers un nombre de bits spécifié par le deuxième opérande. >> (Opérateur de décalage binaire à droite) Décale les bits du premier opérande vers la droite vers un nombre d'emplacements spécifié par le deuxième opérande.
Ces opérateurs bit à bit opèrent sur les opérandes de manière bit par bit. Les tables de vérité pour les opérations AND, OR et XOR sont données ci-dessous.
Considérons a et b comme deux bits sur lesquels les opérations AND, OR et XOR doivent être effectuées.
Les tables de vérité pour la même chose sont indiquées ci-dessous:
à b un B a | b a ^ b 0 0 0 0 0 1 0 0 1 1 0 1 0 1 1 1 1 1 1 0
Prenons un exemple pour comprendre les opérations au niveau du bit.
Soit a = 8 et b = 4
La représentation binaire de a et b est la suivante:
a = 8 1000
a = 4 0100
a & b 0000 = 0
a | b 1100 = 12
a ^ b 1100 = 12
Dans l'exemple ci-dessus, nous voyons que le ET au niveau du bit de 8 et 4 est 0. Le OU au niveau du bit de 8 et 4 est 12 et XOR au niveau du bit de 8 et 4 est également 12.
C'est la manière dont les opérations au niveau du bit sont effectuées par les opérateurs au niveau du bit.
Un exemple démontrant les opérateurs au niveau du bit.
#include #include using namespace std; int main() int a=8,b=4,c; c = a&b; cout<<'Result of & : '< Production:
Résultat de &: 0
Résultat de | : 12
Résultat de ^: 12
Résultat de<< by 2 bits: 32
Résultat de >> par 2 bits: 1
Résultat de ~: -4
Dans le programme ci-dessus, nous avons démontré l'utilisation d'opérateurs au niveau du bit et également imprimé la sortie de chacune des opérations.
Opérateurs d'affectation
L'opérateur d'affectation «=» permet d'affecter une valeur à une variable. La LHS de l'opérateur d'affectation est une variable et RHS est la valeur à affecter à la variable. La valeur du côté droit doit être du même type que celle de la variable du côté gauche.
Notez la différence entre les opérateurs «=» et «==». Le premier est l'opérateur d'affectation et le dernier est l'opérateur d'égalité.
L'opération d'affectation a lieu de droite à gauche. Outre l’opérateur d’affectation «=», il existe d’autres variantes de l’opérateur d’affectation, appelées «opérateurs d’affectation composés». Ces opérateurs effectuent une opération en plus de l'affectation.
Le tableau ci-dessous nous donne une description de ces opérateurs d'affectation.
Opérateur Description = Assigne la valeur de l'opérande RHS à l'opérande LHS + = Ajoute l'opérande RHS à l'opérande LHS et affecte le résultat dans l'opérande LHS. - = Soustrait l'opérande RHS à l'opérande LHS et attribue le résultat à l'opérande LHS * = multiplie l'opérande RHS en opérande LHS et attribue le résultat à l'opérande LHS / = divise l'opérande RHS en opérande LHS et attribue le résultat à l'opérande LHS
Comme indiqué dans le tableau ci-dessus, si x et y sont des opérandes, x + = y équivaut à x = x + y.
De même,
x - = y équivaut à x = x-y.
x * = y équivaut à x = x * y.
x / = y équivaut à x = x / y.
L'exemple de programmation ci-dessous illustre ces opérateurs d'affectation.
#include #include using namespace std; int main() { int x,y; cout<>y; x = y; cout<<'
Value of x = '< Production:
Entrez la variable d'entrée y: 4
Valeur de x = 4
a + = b: 8
c - = b: 3
a * = b: 40
b / = c: 1
Dans l'exemple ci-dessus, nous avons démontré des opérateurs d'affectation ainsi que des opérateurs d'affectation composés.
Noter: On peut aussi combiner les autres opérateurs binaires comme%,<>, &, |, ^, etc. dans des instructions d'assignation composées en plus de celles qui sont déjà démontrées.
Autres opérateurs
Jusqu'à présent, nous avons exploré tous les principaux opérateurs en C ++. Il y a d'autres opérateurs C ++ supplémentaires qui nécessitent notre attention.
Ces opérateurs comprennent:
exemple de CV pour un testeur de logiciels expérimenté
(i) taille de l'opérateur
sizeof est un opérateur unaire largement utilisé en C et C ++. Sizeof renvoie la taille de son opérande. La valeur de retour est généralement un type intégral non signé désigné par «size_t».
L'opérateur Sizeof a de nombreuses utilisations dans les langages C et C ++. Il peut être utilisé pour connaître la taille des variables, tableaux ou expressions et même pour allouer les blocs de mémoire.
(ii) Opérateur ternaire conditionnel
L'opérateur conditionnel en C ++ peut être utilisé en remplacement de l'instruction if-else.
La syntaxe générale de l'opérateur conditionnel est:
État? expression1: expression2;
Si la condition est vraie, l'expression 1 sera évaluée. Si la condition est fausse, alors expression2 sera évaluée.
Veuillez noter que expression1 et expression2 doivent être du même type de données afin d'éviter des erreurs potentielles.
Lecture suggérée => Opérateur ternaire en C #
(iii) Opérateur virgule
L'opérateur virgule représenté par un jeton «,» peut être utilisé aussi bien comme opérateur que comme séparateur.
En tant qu'opérateur, une virgule est utilisée lorsqu'il y a plus d'une expression à évaluer. Seule l'expression la plus à droite est affectée à LHS.
Par exemple,considérez l'expression suivante.
x = (y = 4, y + 1);
Dans cette expression, nous avons deux expressions sur le côté droit séparées par une virgule. Ici, la virgule agit comme un opérateur. Tout d'abord, l'expression, y = 4 sera évaluée. Ensuite, la prochaine expression y + 1 sera évaluée en utilisant le résultat de la première expression, c'est-à-dire y = 4. Ainsi, la valeur de y + 1 sera 5 et cette valeur sera affectée à x.
En tant que séparateur, une virgule peut être utilisée n'importe où pour séparer les définitions, la liste des paramètres, etc.
(iv) Opérateur d'accès aux membres
Deux opérateurs sont utilisés pour accéder aux membres individuels des classes, des structures ou des unions en C ++. Il s'agit de l'opérateur point (.) Et de l'opérateur flèche (->). Nous apprendrons ces opérateurs en détail lorsque nous apprendrons la programmation orientée objet en C ++.
L'exemple ci-dessous montre l'utilisation de sizeof, virgule et opérateur conditionnel.
#include #include using namespace std; int main() { int x,y; x = (y=3,y+4); cout<<'Value of x = '< Production:
Valeur de x = 7
La variable x est supérieure à 5
taille de (x): 4 taille de (y): 4
La capture d'écran pour le même est donnée ci-dessous.
Comme indiqué dans le programme ci-dessus, nous avons d'abord deux variables déclarées et séparées par une virgule. (virgule comme séparateur). Ensuite, nous avons un opérateur virgule avec deux expressions. Comme nous pouvons le voir dans la sortie, la valeur de l'expression la plus à droite est affectée à la variable x. Ensuite, nous démontrons l'opérateur conditionnel pour évaluer si x est inférieur à 5.
Enfin, nous démontrons l'utilisation de l'opérateur sizeof. Ici, nous utilisons l'opérateur sizeof pour obtenir la taille des variables x et y. Comme les deux sont des variables entières, la taille renvoyée est de 4 octets.
(v) Préséance et associativité des opérateurs
Nous avons déjà vu presque tous les opérateurs C ++ et nous savons qu'ils peuvent être utilisés dans des expressions pour effectuer des opérations spécifiques. Mais les expressions que nous avons vues dans les exemples sont simples et directes. Cependant, en fonction de nos besoins, les expressions ont tendance à devenir de plus en plus complexes.
Ces expressions complexes auront plus d'un opérateur et plusieurs opérandes. Dans une telle situation, nous devons évaluer quel opérateur doit être évalué en premier.
Par exemple, considérez l'expression suivante.
x = 4 + 5/3;
Ici, nous avons les opérateurs + et / et nous devons décider quelle expression sera évaluée en premier. En termes mathématiques, nous savons que la division sera effectuée avant l'addition. Ainsi, l'expression deviendra x = 4 + (5/3) = 5.
Mais lorsque le compilateur est confronté à une telle situation, nous avons également besoin d'un mécanisme similaire pour décider de l'ordre des opérations, afin qu'il puisse correctement évaluer l'expression.
Cet ordre dans lequel les opérateurs d'une expression composée sont évalués s'appelle la «préséance» de l'opérateur. C ++ a défini la priorité pour tous les opérateurs et les opérateurs avec une priorité plus élevée sont évalués en premier.
Que se passe-t-il lorsque nous avons deux opérateurs côte à côte dans une expression avec la même priorité? C'est là que l'associativité d'un opérateur entre en jeu.
L'associativité indique au compilateur s'il doit évaluer une expression dans une séquence de gauche à droite ou de droite à gauche. Ainsi, en utilisant la priorité et l'associativité d'un opérateur, nous pouvons évaluer efficacement une expression et obtenir le résultat souhaité.
C ++ fournit un tableau constitué de la priorité et de l'associativité des différents opérateurs qu'il utilise.
Ce tableau est donné ci-dessous.
Préséance / associativité Opérateur Description 1 Aucun ::
:: Opérateur de résolution de portée
(unaire)
(binaire) 2 L-> R ()
()
()
{}
taper()
taper{}
()
.
->
++
––
typeid
const_cast
dynamic_cast
réinterpréter_cast
static_cast Parenthèses
Appel de fonction
Initialisation
Initialisation uniforme (C ++ 11)
Casting fonctionnel
Distribution fonctionnelle (C ++ 11)
Indice du tableau
Accès membre depuis l'objet
Accès membre à partir de l'objet ptr
Post-incrémentation
Post-décrément
Informations sur le type d'exécution
Rejeter const
Cast avec contrôle de type à l'exécution
Cast d'un type à un autre 3 R-> L +
-
++
––
!
~
(taper)
taille de
&
*
Nouveau
Nouveau()
effacer
effacer() Unary plus
Moins unaire
Pré-incrémentation
Pré-décrémentation
NON logique
Pas au niveau du bit
Moulage de style C
Taille en octets
Adresse de
Déréférence
Allocation de mémoire dynamique
Allocation dynamique des baies
Suppression dynamique de la mémoire
Suppression de tableau dynamique 4 L-> R -> *
. * Sélecteur de pointeur de membre
Sélecteur d'objet membre 5 L-> R *
/
% Multiplication
Division
Module 6 L-> R +
- Une addition
Soustraction 8 L-> R <
<=
>
> = Comparaison inférieure à
Comparaison inférieure ou égale
Comparaison supérieure à
Comparaison supérieure ou égale 9 L-> R !ERREUR! caractère illégal '!' Égalité
Inégalité 10 L-> R & ET au niveau du bit 11 L-> R ^ XOR au niveau du bit 12 L-> R | OU au niveau du bit 13 L-> R && ET logique 14 L-> R || OU logique 15 R-> L ?:
=
* =
/ =
% =
+ =
- =
<<=
>> =
& =
| =
^ = Conditionnel (voir note ci-dessous)
Mission
Affectation de multiplication
Affectation de division
Affectation du module
Affectation d'addition
Affectation de soustraction
Affectation de décalage à gauche au niveau du bit
Affectation de décalage à droite au niveau du bit
Affectation ET au niveau du bit
Affectation OR au niveau du bit
Affectation XOR au niveau du bit 16 R-> L lancer Lancer l'expression 17 L-> R , Opérateur virgule
Remarques:
- Le niveau de priorité 1 est le niveau de priorité le plus élevé et le niveau 17 est le plus bas. Les opérateurs avec un niveau de priorité plus élevé sont évalués en premier.
- L-> R signifie associativité de gauche à droite.
- R-> L signifie associativité de droite à gauche.
Conclusion
Tout cela concerne les opérateurs en C ++.
Nous avons discuté de presque tous les opérateurs. Certains opérateurs spécifiques qui sont présents dans le tableau de priorité ci-dessus dont nous n'avons pas discuté, seront discutés en fonction des sujets que nous aborderons dans nos prochains tutoriels.
=> Voir ici pour explorer la liste complète des didacticiels C ++
lecture recommandée
- Exemples d'opérateurs arithmétiques et booléens de script shell Unix
- Opérateurs Python
- Opérateurs Nouveau / Supprimer en C ++ avec des exemples
- Types de données Python
- Instructions conditionnelles Unix: If Then Else et opérateurs relationnels
- Tutoriel Python DateTime avec des exemples
- Tutoriel d'injection HTML: types et prévention avec des exemples
- Commande Cut sous Unix avec des exemples
