« Langage C++/Opérateurs » : différence entre les versions
m Robot : Remplacement de texte automatisé (-%C3%A9 +é) |
m Robot : Remplacement de texte automatisé (-(<\/?)source +\1syntaxhighlight) |
||
| Ligne 26 : | Ligne 26 : | ||
| contenu = |
| contenu = |
||
< |
<syntaxhighlight lang="cpp"> |
||
int x, y; |
int x, y; |
||
x = 5; //x = 5 |
x = 5; //x = 5 |
||
y = 3; //y = 3 |
y = 3; //y = 3 |
||
x = y; //x = 3 (valeur de y) |
x = y; //x = 3 (valeur de y) |
||
</syntaxhighlight> |
|||
</source> |
|||
}} |
}} |
||
| Ligne 47 : | Ligne 47 : | ||
| contenu = |
| contenu = |
||
< |
<syntaxhighlight lang="cpp"> |
||
int x, y; |
int x, y; |
||
x = 5; |
x = 5; |
||
y = 3; |
y = 3; |
||
x += y; //x = 8 |
x += y; //x = 8 |
||
</syntaxhighlight> |
|||
</source> |
|||
}} |
}} |
||
| Ligne 68 : | Ligne 68 : | ||
| contenu = |
| contenu = |
||
< |
<syntaxhighlight lang="cpp"> |
||
int x, y; |
int x, y; |
||
x = 5; |
x = 5; |
||
y = 3; |
y = 3; |
||
x -= y; //x = 2 |
x -= y; //x = 2 |
||
</syntaxhighlight> |
|||
</source> |
|||
}} |
}} |
||
| Ligne 89 : | Ligne 89 : | ||
| contenu = |
| contenu = |
||
< |
<syntaxhighlight lang="cpp" > |
||
int x, y; |
int x, y; |
||
x = 5; |
x = 5; |
||
y = 3; |
y = 3; |
||
x *= y; //x = 15 |
x *= y; //x = 15 |
||
</syntaxhighlight> |
|||
</source> |
|||
}} |
}} |
||
| Ligne 110 : | Ligne 110 : | ||
| contenu = |
| contenu = |
||
< |
<syntaxhighlight lang="cpp"> |
||
int x, y; |
int x, y; |
||
x = 5; |
x = 5; |
||
y = 3; |
y = 3; |
||
x /= y; //x = 1 (voir l'opérateur "/") |
x /= y; //x = 1 (voir l'opérateur "/") |
||
</syntaxhighlight> |
|||
</source> |
|||
}} |
}} |
||
| Ligne 131 : | Ligne 131 : | ||
| contenu = |
| contenu = |
||
< |
<syntaxhighlight lang="cpp"> |
||
int x, y; |
int x, y; |
||
x = 5; |
x = 5; |
||
y = 3; |
y = 3; |
||
x %= y; //x = 2 (voir l'opérateur "%") |
x %= y; //x = 2 (voir l'opérateur "%") |
||
</syntaxhighlight> |
|||
</source> |
|||
}} |
}} |
||
| Ligne 149 : | Ligne 149 : | ||
| contenu = |
| contenu = |
||
< |
<syntaxhighlight lang="cpp"> |
||
int x, y, z; |
int x, y, z; |
||
x = 5; |
x = 5; |
||
y = 3; |
y = 3; |
||
z = x + y; //z = 8 |
z = x + y; //z = 8 |
||
</syntaxhighlight> |
|||
</source> |
|||
}} |
}} |
||
| Ligne 164 : | Ligne 164 : | ||
| contenu = |
| contenu = |
||
< |
<syntaxhighlight lang="cpp"> |
||
int x, y, z; |
int x, y, z; |
||
x = 5; |
x = 5; |
||
y = 3; |
y = 3; |
||
z = x - y; //z = 2 |
z = x - y; //z = 2 |
||
</syntaxhighlight> |
|||
</source> |
|||
}} |
}} |
||
| Ligne 179 : | Ligne 179 : | ||
| contenu = |
| contenu = |
||
< |
<syntaxhighlight lang="cpp"> |
||
int x, y, z; |
int x, y, z; |
||
x = 5; |
x = 5; |
||
y = 3; |
y = 3; |
||
z = x * y; //z = 15 |
z = x * y; //z = 15 |
||
</syntaxhighlight> |
|||
</source> |
|||
}} |
}} |
||
| Ligne 194 : | Ligne 194 : | ||
| contenu = |
| contenu = |
||
< |
<syntaxhighlight lang="cpp"> |
||
int x, y, z; |
int x, y, z; |
||
x = 5; |
x = 5; |
||
| Ligne 203 : | Ligne 203 : | ||
o = 3.0; |
o = 3.0; |
||
p = r / o; // p ~= 1.666666… |
p = r / o; // p ~= 1.666666… |
||
</syntaxhighlight> |
|||
</source> |
|||
En c++ la division est entière si les deux opérandes sont entiers. Si l'un des opérandes est codé sur un format réel alors le résultat sera réel. |
En c++ la division est entière si les deux opérandes sont entiers. Si l'un des opérandes est codé sur un format réel alors le résultat sera réel. |
||
| Ligne 215 : | Ligne 215 : | ||
| contenu = |
| contenu = |
||
< |
<syntaxhighlight lang="cpp"> |
||
int x, y, z; |
int x, y, z; |
||
x = 5; |
x = 5; |
||
y = 3; |
y = 3; |
||
z = x % y; // = 2 (5 / 3 => quotient 1, reste 2) |
z = x % y; // = 2 (5 / 3 => quotient 1, reste 2) |
||
</syntaxhighlight> |
|||
</source> |
|||
}} |
}} |
||
| Ligne 283 : | Ligne 283 : | ||
| contenu = |
| contenu = |
||
< |
<syntaxhighlight lang="cpp"> |
||
bool x, y; |
bool x, y; |
||
x = true; |
x = true; |
||
y = !x; // y = false |
y = !x; // y = false |
||
</syntaxhighlight> |
|||
</source> |
|||
}} |
}} |
||
| Ligne 295 : | Ligne 295 : | ||
| contenu = |
| contenu = |
||
< |
<syntaxhighlight lang="cpp"> |
||
bool x = true, y = true, z = false; |
bool x = true, y = true, z = false; |
||
bool a, b, c; |
bool a, b, c; |
||
| Ligne 301 : | Ligne 301 : | ||
b = x && z; // b = false |
b = x && z; // b = false |
||
c = x && !z; // c = true |
c = x && !z; // c = true |
||
</syntaxhighlight> |
|||
</source> |
|||
}} |
}} |
||
| Ligne 315 : | Ligne 315 : | ||
| contenu = |
| contenu = |
||
< |
<syntaxhighlight lang="cpp"> |
||
int a = 2, b = 6, c = 12, d, e; |
int a = 2, b = 6, c = 12, d, e; |
||
d = a & b ; // d = 2 |
d = a & b ; // d = 2 |
||
e = b & c ; // e = 4 |
e = b & c ; // e = 4 |
||
</syntaxhighlight> |
|||
</source> |
|||
}} |
}} |
||
| Ligne 327 : | Ligne 327 : | ||
| contenu = |
| contenu = |
||
< |
<syntaxhighlight lang="cpp"> |
||
int a = 2, b = 6, c = 12, d, e; |
int a = 2, b = 6, c = 12, d, e; |
||
d = a | b ; // d = 6 |
d = a | b ; // d = 6 |
||
e = b | c ; // e = 14 |
e = b | c ; // e = 14 |
||
</syntaxhighlight> |
|||
</source> |
|||
}} |
}} |
||
| Ligne 339 : | Ligne 339 : | ||
| contenu = |
| contenu = |
||
< |
<syntaxhighlight lang="cpp"> |
||
int a = 2, b = 6, c = 12, d, e, f; |
int a = 2, b = 6, c = 12, d, e, f; |
||
d = a ^ b ; // d = 4 |
d = a ^ b ; // d = 4 |
||
e = a ^ a ; // e = 0 |
e = a ^ a ; // e = 0 |
||
f = a ^ c ; // f = 14 |
f = a ^ c ; // f = 14 |
||
</syntaxhighlight> |
|||
</source> |
|||
}} |
}} |
||
| Ligne 352 : | Ligne 352 : | ||
| contenu = |
| contenu = |
||
< |
<syntaxhighlight lang="cpp"> |
||
int a = 2, b = -6, c = 0; |
int a = 2, b = -6, c = 0; |
||
a = ~a ; // a = -3 |
a = ~a ; // a = -3 |
||
b = ~b ; // b = 5 |
b = ~b ; // b = 5 |
||
c = ~c ; // c = -1 |
c = ~c ; // c = -1 |
||
</syntaxhighlight> |
|||
</source> |
|||
}} |
}} |
||
| Ligne 375 : | Ligne 375 : | ||
| contenu = |
| contenu = |
||
'''Syntaxe :''' |
'''Syntaxe :''' |
||
< |
<syntaxhighlight lang="cpp"> |
||
++<operande> |
++<operande> |
||
</syntaxhighlight> |
|||
</source> |
|||
}} |
}} |
||
Où ''operande'' est la valeur à incrémenter puis à renvoyer. |
Où ''operande'' est la valeur à incrémenter puis à renvoyer. |
||
| Ligne 388 : | Ligne 388 : | ||
| contenu = |
| contenu = |
||
'''Syntaxe :''' |
'''Syntaxe :''' |
||
< |
<syntaxhighlight lang="cpp"> |
||
<operande>++ |
<operande>++ |
||
</syntaxhighlight> |
|||
</source> |
|||
}} |
}} |
||
Où ''operande'' est la valeur à renvoyer puis à incrémenter. |
Où ''operande'' est la valeur à renvoyer puis à incrémenter. |
||
| Ligne 404 : | Ligne 404 : | ||
| contenu = |
| contenu = |
||
'''Syntaxe :''' |
'''Syntaxe :''' |
||
< |
<syntaxhighlight lang="cpp"> |
||
--<operande> |
--<operande> |
||
</syntaxhighlight> |
|||
</source> |
|||
}} |
}} |
||
Où ''operande'' est la valeur à décrémenter puis à renvoyer. |
Où ''operande'' est la valeur à décrémenter puis à renvoyer. |
||
| Ligne 417 : | Ligne 417 : | ||
| contenu = |
| contenu = |
||
'''Syntaxe :''' |
'''Syntaxe :''' |
||
< |
<syntaxhighlight lang="cpp"> |
||
<operande>-- |
<operande>-- |
||
</syntaxhighlight> |
|||
</source> |
|||
}} |
}} |
||
Où ''operande'' est la valeur à renvoyer puis à décrémenter. |
Où ''operande'' est la valeur à renvoyer puis à décrémenter. |
||
| Ligne 431 : | Ligne 431 : | ||
| contenu = |
| contenu = |
||
< |
<syntaxhighlight lang="cpp"> |
||
int a = 0; |
int a = 0; |
||
++a = a++; // <-- résultat indéterminé |
++a = a++; // <-- résultat indéterminé |
||
</syntaxhighlight> |
|||
</source> |
|||
}} |
}} |
||
Dans ce cas, "a" peut valoir 1 ou 2 selon comment le compilateur a traité les opérateurs. |
Dans ce cas, "a" peut valoir 1 ou 2 selon comment le compilateur a traité les opérateurs. |
||
| Ligne 442 : | Ligne 442 : | ||
| contenu = |
| contenu = |
||
< |
<syntaxhighlight lang="cpp"> |
||
int a = 0; |
int a = 0; |
||
a = a++ + ++a + a++; // <-- résultat indéterminé |
a = a++ + ++a + a++; // <-- résultat indéterminé |
||
</syntaxhighlight> |
|||
</source> |
|||
}} |
}} |
||
| Ligne 455 : | Ligne 455 : | ||
| contenu = |
| contenu = |
||
< |
<syntaxhighlight lang="cpp"> |
||
int a = 0; |
int a = 0; |
||
int b = 5; |
int b = 5; |
||
printf("%d, %d", a++, a = --b); // <-- résultat indéterminé |
printf("%d, %d", a++, a = --b); // <-- résultat indéterminé |
||
</syntaxhighlight> |
|||
</source> |
|||
}} |
}} |
||
| Ligne 472 : | Ligne 472 : | ||
| contenu = Le code ci-dessous filtre dans tab les entiers superieurs à 5 et les place dans filtered_tab. |
| contenu = Le code ci-dessous filtre dans tab les entiers superieurs à 5 et les place dans filtered_tab. |
||
< |
<syntaxhighlight lang="cpp"> |
||
int tab[10]; |
int tab[10]; |
||
| Ligne 493 : | Ligne 493 : | ||
*/ |
*/ |
||
} |
} |
||
</syntaxhighlight> |
|||
</source> |
|||
}} |
}} |
||
Version du 1 mai 2020 à 14:54
Les Opérateurs C++
Les opérateurs sont des symboles permettant d'effectuer des opérations sur des valeurs. Ils sont classés dans trois catégories.
Opérateurs d'affectation
L'opérateur d'affectation simple "="
L'opérateur d'affectation simple est "=" il signifie "affecter à".
Syntaxe :
<Destination> = <Source>; Où <Source> et <Destination> doivent être de même nature et où <Source> est une expression et <Destination> une variable ;
int x, y;
x = 5; //x = 5
y = 3; //y = 3
x = y; //x = 3 (valeur de y)
L'opérateur d'affectation additionneur "+="
L'opérateur d'affectation additionneur est "+=" il signifie "affecter en additionnant à".
Syntaxe :
<Destination> += <Source>; Où <Source> et <Destination> doivent être de même nature et où <Source> est une expression et <Destination> une variable ;
int x, y;
x = 5;
y = 3;
x += y; //x = 8
L'opérateur d'affectation soustracteur "-="
L'opérateur d'affectation soustracteur est "-=" il signifie "affecter en soustrayant à".
Syntaxe :
<Destination> -= <Source>; Où <Source> et <Destination> doivent être de même nature et où <Source> est une expression et <Destination> une variable ;
int x, y;
x = 5;
y = 3;
x -= y; //x = 2
L'opérateur d'affectation multiplicateur "*="
L'opérateur d'affectation multiplicateur est "*=" il signifie "affecter en multipliant à".
Syntaxe :
<Destination> *= <Source>; Où <Destination> et le résultat de l'opération doivent être de même nature et où <Source> est une expression et <Destination> une variable ;
int x, y;
x = 5;
y = 3;
x *= y; //x = 15
L'opérateur d'affectation diviseur "/="
L'opérateur d'affectation diviseur est "/=" il signifie "affecter en divisant à".
Syntaxe :
<Destination> /= <Source>; Où <Destination> et le résultat de l'opération doivent être de même nature et où <Source> est une expression et <Destination> une variable ;
int x, y;
x = 5;
y = 3;
x /= y; //x = 1 (voir l'opérateur "/")
L'opérateur d'affectation modulo "%="
L'opérateur d'affectation modulo est "%=" il signifie "affecter le modulo de, à".
Syntaxe :
<Destination> %= <Source>; Où <Destination> et le résultat de l'opération doivent être de même nature et où <Source> est une expression et <Destination> une variable ;
int x, y;
x = 5;
y = 3;
x %= y; //x = 2 (voir l'opérateur "%")
Les opérateurs mathématiques
Opérateur d'addition "+"
L'opérateur permettant l'addition est "+" il permet d'additionner un nombre ou le résultat numérique d’une expression à un autre.
int x, y, z;
x = 5;
y = 3;
z = x + y; //z = 8
Opérateur de soustraction "-"
L'opérateur permettant la soustraction est "-" il permet de soustraire un nombre ou le résultat numérique d’une expression à un autre.
int x, y, z;
x = 5;
y = 3;
z = x - y; //z = 2
Opérateur de multiplication "*"
L'opérateur permettant la multiplication est "*" il permet de multiplier un nombre ou le résultat numérique d’une expression à un autre.
int x, y, z;
x = 5;
y = 3;
z = x * y; //z = 15
Opérateur de division "/"
L'opérateur permettant la division est "/" il permet de diviser un nombre ou le résultat numérique d’une expression à un autre.
int x, y, z;
x = 5;
y = 3;
z = x / y; //z = 1
float r, o, p;
r = 5.0;
o = 3.0;
p = r / o; // p ~= 1.666666…
En c++ la division est entière si les deux opérandes sont entiers. Si l'un des opérandes est codé sur un format réel alors le résultat sera réel.
Opérateur de modulo "%"
L'opérateur permettant de récupérer le reste de la division entière d’un nombre ou du résultat numérique d’une expression par un autre, est "%".
int x, y, z;
x = 5;
y = 3;
z = x % y; // = 2 (5 / 3 => quotient 1, reste 2)
Les opérateurs comparatifs
Ils servent essentiellement à effectuer des tests logiques entre plusieurs valeurs numériques.
Comparateur d'égalité "=="
Le comparateur C++ d'égalité == permet de vérifier si la valeur de gauche est strictement égale à la valeur de droite.
Cela revient à faire une inversion de l'opérateur logique XOR (soit NOT XOR). Voici la table de vérité du comparateur == pour l'opération (x == y) :
| == (NOT XOR) | y = false | y = true |
|---|---|---|
| x = false | true | false |
| x = true | false | true |
Comparateur "!=" (différent de)
Le comparateur C++ différentiel "!=" permet de vérifier si la valeur de gauche est strictement différente de la valeur de droite. Cela revient à appliquer l'opérateur logique XOR.
Comparateur "<" (strictement inférieur à)
Le comparateur "<" (strictement inférieur à) permet de vérifier si la valeur numérique de gauche est strictement inférieure à la valeur numérique de droite. Cet opérateur renvoie true uniquement si la valeur numérique de gauche est strictement inférieure à la valeur numérique de droite.
Comparateur "<=" (inférieur à)
Le comparateur "<=" (inférieurs à) permet de vérifier si la valeur numérique de gauche est inférieure ou égale à la valeur numérique de droite. Cet opérateur renvoie true uniquement si la valeur numérique de gauche est inférieure ou égale à la valeur numérique de droite.
Comparateur ">=" (supérieur à)
Le comparateur ">=" (supérieur à) permet de vérifier si la valeur numérique de gauche est supérieure ou égale à la valeur numérique de droite. Cet opérateur renvoie true uniquement si la valeur numérique de gauche est supérieure ou égale à la valeur numérique de droite.
Comparateur ">" (strictement supérieur à)
Le comparateur ">" (strictement supérieur à) permet de vérifier si la valeur numérique de gauche est strictement supérieure à la valeur numérique de droite. Cet opérateur renvoie true uniquement si la valeur numérique de gauche est strictement supérieure à la valeur numérique de droite.
Opérateurs logiques
Les opérateurs logiques représentent les manipulations et comparaisons possibles que l’on peut faire sur des données de types booléen et/ou binaire.
|
Attention : les opérateurs &, | et ^ sont des opérateurs bit à bit ! Les opérateurs logiques correspondant au & et au | sont respectivement && et ||. |
Les opérateurs logiques
Cette sous-catégorie représente les opérateurs logiques que nous avons vu en introduction en leur spécifiant une syntaxe. Il est à noter que l'opérateur logique YES n'a pas de représentation en C++. En effet le C++ utilise le postulat que les opérations doivent retourner true pour être vraies. Partant de ce principe, il n'est plus nécessaire d’avoir un opérateur YES.
Opérateur "!" (NOT)
L'opérateur logique inverseur NOT a pour syntaxe en C++ le symbole "!" (point d'exclamation). Pour inverser une valeur on écrira donc en C++
bool x, y;
x = true;
y = !x; // y = false
Opérateur "&&" (AND)
Le comparateur C++ AND, représenté par "&&" (double "et commercial"), permet de vérifier si les 2 valeurs soumises sont vraies. Ce comparateur est souvent utilisé dans les tests car il permet une optimisation du code. Contrairement à l'opérateur logique "&" le comparateur "&&" teste la première valeur et si elle est false il renvoie directement false sans tester la deuxième valeur. Ce comportement permet un gain de temps sur les procédures de comparaison et permet d’éviter l'exécution d’un code qui serait invalide si le test de la première valeur renvoyait false.
bool x = true, y = true, z = false;
bool a, b, c;
a = x && y; // a = true
b = x && z; // b = false
c = x && !z; // c = true
Opérateur "||" (OR)
Le comparateur C++ OR "||" permet de vérifier si au moins une des valeurs soumises est vraie. Ce comparateur est souvent utilisé dans les tests car il permet une optimisation du code. Contrairement à l'opérateur logique "|", le comparateur "||" teste la première valeur, et si elle est à vrai, il renvoie directement true sans tester la deuxième valeur. Ce comportement permet un gain de temps sur les procédures de comparaison et permet d’éviter l'exécution d’un code qui serait invalide si le test de la première valeur renvoyait vrai.
Opérateurs bit à bit
Les opérateurs bit à bit travaillent sur les variables en s'appliquant bit à bit[1].
Opérateur "&" (AND)
L'opérateur AND a pour syntaxe en C++ le symbole "&" (l’esperluette ou et commercial). Pour effectuer un AND sur des valeurs on écrira donc en C++
int a = 2, b = 6, c = 12, d, e;
d = a & b ; // d = 2
e = b & c ; // e = 4
Opérateur "|" (OR)
L'opérateur OR a pour syntaxe en C++ le symbole "|" (la barre verticale). Pour effectuer un OR sur des valeurs on écrira donc en C++ :
int a = 2, b = 6, c = 12, d, e;
d = a | b ; // d = 6
e = b | c ; // e = 14
Opérateur "^" (XOR)
L'opérateur XOR a pour syntaxe en C++ le symbole "^" (Accent circonflexe). Pour effectuer un XOR sur des valeurs on écrira donc en C++ :
int a = 2, b = 6, c = 12, d, e, f;
d = a ^ b ; // d = 4
e = a ^ a ; // e = 0
f = a ^ c ; // f = 14
Opérateur "~" (NOT)
L'opérateur NOT a pour syntaxe en C++ le symbole "~" (tilde). Pour effectuer un NOT sur des valeurs on écrira donc en C++ :
int a = 2, b = -6, c = 0;
a = ~a ; // a = -3
b = ~b ; // b = 5
c = ~c ; // c = -1
Opérateurs unaires
En C++, il existe des opérateurs qui ne nécessitent qu'un opérande. Ils sont appelés opérateurs unaires.
Opérateurs "++" (incrémentation)
L'opérateur "++" est un peu particulier car il possède 2 formes et des effets indésirables. Je n'en parle que pour vous permettre d’éviter les cas problématiques.
Forme préfixée
Dans sa forme préfixée la théorie veut que l'opérande associé soit d’abord incrémenté puis renvoyé.
Syntaxe :
++<operande>
Où operande est la valeur à incrémenter puis à renvoyer.
Forme suffixée
Dans sa forme suffixée la théorie veut que l'opérande associé soit d’abord renvoyé puis incrémenté.
Syntaxe :
<operande>++
Où operande est la valeur à renvoyer puis à incrémenter.
Opérateurs "--" (décrémentation)
L'opérateur "--" est un peu particulier car il possède 2 formes et des effets indésirables. Je n'en parle que pour vous permettre d’éviter les cas problématiques.
Forme préfixée
Dans sa forme préfixée la théorie veut que l'opérande associé soit d’abord décrémenté puis renvoyé.
Syntaxe :
--<operande>
Où operande est la valeur à décrémenter puis à renvoyer.
Forme suffixée
Dans sa forme suffixée la théorie veut que l'opérande associé soit d’abord renvoyé puis décrémenté.
Syntaxe :
<operande>--
Où operande est la valeur à renvoyer puis à décrémenter.
Effets secondaires
En C++ il existe un effet secondaire avec certains opérateurs. Si l’on utilise plusieurs opérateurs unaires ou d'affectation dans la même ligne de commande, le résultat est indéterminé par les spécifications du langage[2]. Ce qui veut dire que le compilateur fait ce qu’il veut. En fait ce problème survient car l'opérateur lit et modifie la valeur de ses opérandes.
int a = 0;
++a = a++; // <-- résultat indéterminé
Dans ce cas, "a" peut valoir 1 ou 2 selon comment le compilateur a traité les opérateurs. Autre exemple
int a = 0;
a = a++ + ++a + a++; // <-- résultat indéterminé
Dans ce cas, "a" peut valoir 0, 1 ou 3 selon comment le compilateur a traité les opérateurs.
autre exemple :
int a = 0;
int b = 5;
printf("%d, %d", a++, a = --b); // <-- résultat indéterminé
Ici l’affichage peut avoir bien des valeurs.
Il est donc recommandé d’utiliser ces opérateurs avec précaution et d’éviter toute expression trop complexe(comme ci-dessus). D'ailleurs, de telles expressions ont plutôt tendance à rendre le code moins lisible - ce qui est l'inverse du but initial - et cache souvent une mauvaise conception.
Néanmoins, une utilisation raisonnable de ces opérateurs permet de rendre un code plus concis, sans perdre en lisibilité.
Le code ci-dessous filtre dans tab les entiers superieurs à 5 et les place dans filtered_tab.
int tab[10];
/*
initialisation de tab
*/
int filtered_tab[10];
int filtered_count = 0;
for(int i = 0; i < 10; ++i)
{
if(array[i] > 5)
filtered_array[filtered_count++] = array[i];
/* au lieu de
if(array[i] > 5
{
filtered_array[filtered_count] = array[i];
filtered_count++;
}
*/
}
Références
- ↑ https://www.miniwebtool.com/bitwise-calculator/?data_type=10&number1=6&number2=12&operator=OR
- ↑ Programmer en langage C++, Claude Delannoy, 2011
Voir aussi
- Priorités des opérateurs sur Wikilivres
