Affectation

L’affectation est désignée par le signe = . C’est un opérateur binaire. Il a la vue suivante:

variable = opérande

L'affectation est un opérateur où la variable à la gauche prend la valeur de l’opérande à droite. Si on ajoute ; / le point virgule / à la fin de cette construction on obtient l'instruction d’affectation:
variable = opérande;

Il est possible d’affecter une valeur à plusieurs variables:
v1 = v2 = 10;
Une perte d’information est possible si les types de la variable et de l’opérande ne sont pas les mêmes.
Exemples:
int a, b ;
a = b = -3.9 ; // а et b prennent -3, au lieu de -3.9
int x;
double y ;
x = y = -3.9; // y prend -3.9, x prend -3

Formes d’affectation différentes :

Les opérateurs += , -= , *= , /=, ++, -- ont le sens suivant:

a += b XXX // a = a + b
a -= b XXX // a = a – b
a *= b XXX // a = a * b
a /= b XXX // a = a / b
a %= b XX // a = a % b
a ++ XXXX // a = a+1
++a XXXX// a = a+1
-- a XXXXX// a = a-1
a-- XXXXX // a = a-1

Si à la fin de ces constructions on ajoute ; /le point virgule/ on obtient l’instruction d’affectation.

La place des opérateurs ++ et -- / avant ou après la variable/ est très importante. Si les opérateurs sont placés avant la variable, premièrement la variable change sa valeur et après l’opérande est évalué. Si les opérateurs sont placés après la variable premièrement l’opérande est évalué et la valeur de la variаble change ensuite.

int x=5;
double y = 2.4 ;
char c = ‘A’;
cout << ++x << endl; // affiche 6
cout << y++ << endl; // affiche 2.4
cout << "y = "<< y; // affiche 3.4
cout << ++c; // affiche B

Conversion du type de l'opérande:

Il est souvent nécessaire de convertir une valeur d'un type à un autre pour le besoin d'un calcul, ou de faire participer à une même opération des objets de types différents (par exemple double et int).
Certaines conversions sont implicites, mais d'une façon générale il est préférable de les rendre explicites en préfixant l'objet à convertir par le type que l'on veut lui attribuer, entre parenthèses :

(type) opérande

Attention : la conversion de type peut occasionner une perte d'information, comme dans le cas d'une conversion double - int. Dans ce cas en effet, c'est la partie entière de la valeur qui est conservée.

Exemple:
double v = 3.6;
cout<<(int)v; // affiche 3
cout<< v; // affiche 3.6

Notez que cet opérateur ne change pas le type de la variable v. Elle reste de type double et sa valeur est 3.6.

Exemple:
char ch='*';
cout<<(int)ch; // affiche 42, le code ASCII de ‘*’
cout<<(char)65; // change 65 en char, affiche A

Opérateur conditionnel

Cet opérateur a trois opérandes. La syntaxe:

opérande1 ? opérande2 : opérande3

Si l'opérande1 n'est pas 0 , le résultat est la valeur de l'opérande2, sinon le résultat est la valeur de l'opérande3.
Exemple:
int x = -1;
x ? cout << x + 1:cout << x - 1; // affiche 0

Opérateur , /virgule/

La syntaxe:

opérande1 , opérande2

On calcule l'opérande1 puis l'opérande2 . Le résultat est la valeur de l'opérande2.