TP : variables et affectations

TP : variables et affectations#

Dans la feuille précédente, nous avons effectué des calculs et observé les résultats (type, valeur). Pour écrire des programmes, nous aurons besoin de stocker les résultats intermédiaires dans des variables pour en réutiliser les valeurs.

Exercice 1#

  • Exécutez la cellule suivante :

int a;
a = 3;

Une fois que la variable a a été déclarée (int a;) et qu'on lui a affecté une valeur (a = 3), on peut afficher ou réutiliser cette valeur :

a

3
type: int

a + 1

4
type: int

a + a + a

9
type: int

On peut aussi modifier la valeur de a :

a = 5;

a

5
type: int

a = a + 1;

a

6
type: int

  • Que se passe-t-il si l'on exécute à nouveau la dernière cellule? Si on exécute alternativement les deux dernières cellules?

Quelques remarques sur Jupyter#

L'ordre dans lequel vous exécutez les cellules est important, la variable contient la dernière valeur que vous lui avez attribuée. L'ordre d'exécution des cellules est indiqué entre crochets dans la marge de gauche.

Vous aurez noté que certaines cellules finissaient par «;», d'autres non.

Exercice 2#

  • Exécutez les cellules suivantes et observez le résultat :

1 + 1

2
type: int

1 + 1;

1 + 1;
2 + 2

4
type: int

En général, toute instruction C++ doit se terminer par un «;». Par convention pour C++ dans Jupyter, si la dernière instruction d'une cellule est une expression (elle a une valeur) et si l'on omets le «;», alors cette valeur est affichée, avec son type.

Retour sur les variables#

Exercice 3#

Les cellules suivantes déclarent deux variables r et pi. Vous noterez qu'une valeur est affectée à pi dans la foulée, en mettant la déclaration et l'affectation sur la même ligne :

double pi = 3.1416;
double r;

  • Utilisez ces variables pour calculer l'aire et le périmètre d'un disque de rayon r pour les différentes valeurs données ci-dessous. Pour simplifier, vous pourrez considérer que la variable pi contient la valeur exacte du nombre bien connu. Utilisez les cellules vides pour faire vos calculs. N'oubliez pas d'exécuter aussi les cellules qui changent la valeur de r.

r = 5;

Aire :

/// BEGIN SOLUTION
pi * r * r
/// END SOLUTION

78.540000
type: double

Périmètre :

/// BEGIN SOLUTION
2 * pi * r
/// END SOLUTION

31.416000
type: double

r = 2.5;

Aire :

/// BEGIN SOLUTION
pi * r * r
/// END SOLUTION

19.635000
type: double

Périmètre :

/// BEGIN SOLUTION
2 * pi * r
/// END SOLUTION

15.708000
type: double

r = 10;

Aire :

/// BEGIN SOLUTION
pi * r * r
/// END SOLUTION

314.16000
type: double

Périmètre :

/// BEGIN SOLUTION
2 * pi * r
/// END SOLUTION

62.832000
type: double

Exercice 4#

Les cellules suivantes définissent deux variables b et c :

int b, c;

b = 5;
c = 8;

Dans les cellules vides ci-dessous, écrivez un programme qui échange les valeurs des deux variables, comme dans le TD 1. Votre programme pourra déclarer de nouvelles variables et utiliser des affectations, mais sans écrire les nombres à la main bien sûr, ce serait tricher.

Indication :

  • Une cellule peut contenir plusieurs instructions (comme ci-dessus) séparées par des points-virgules ;.

/// BEGIN SOLUTION
int temp;
/// END SOLUTION

/// BEGIN SOLUTION
temp = b;
b = c;
c = temp;
/// END SOLUTION

5
type: int

b // doit afficher 8 (ancienne valeur de c)

8
type: int

c // doit afficher 5 (ancienne valeur de b)

5
type: int

/// BEGIN HIDDEN TESTS
CHECK( b == 8 );
CHECK( c == 5 );
/// END HIDDEN TESTS

Affectations et types#

Tout à l'heure, nous avons exploré différents types de valeurs et nous venons de voir comment déclarer une variable pouvant contenir un certain type. Mais que se passe-t-il lorsque l'on affecte une valeur du mauvais type à une variable?

Exercice 5#

  • Faites-vous une opinion en observant le résultat des affectations suivantes :

int v1;

v1 = 2

2
type: int

v1 = 2.5



input_line_56

:

2

:

7

:

 





warning

: 





implicit conversion from 'double' to 'int' changes value from 2.5 to 2 [-Wliteral-conversion]





 v1 = 2.5





    ~ ^~~





2
type: int

v1 = false

0
type: int

double v2;

v2 = 5

5.0000000
type: double

v2 = 5.3

5.3000000
type: double

v2 = true

1.0000000
type: double

bool v3;

v3 = 2

true
type: bool

v3 = 0

false
type: bool

v3 = 1.5



input_line_72

:

2

:

7

:

 





warning

: 





implicit conversion from 'double' to 'bool' changes value from 1.5 to true [-Wliteral-conversion]





 v3 = 1.5





    ~ ^~~





true
type: bool

v3 = false

false
type: bool

Vous remarquez que, lorsque les types sont suffisament proches, les valeurs sont converties automatiquement au moment de l'affectation. Dans les autres cas, l'affectation déclenche une erreur.

Exercice 6#

Pour chaque expression ci-dessous, déclarez une variable du bon type et affectez-lui le résultat, puis affichez le contenu de la variable pour le vérifier.

Exemple :

1 + 2

3
type: int

int i = 1 + 2;
i

3
type: int

À vous de faire comme dans l'exemple avec les expressions ci-dessous :

2.3*9 + 5

25.700000
type: double

/// BEGIN SOLUTION
double s = 2.3*9 + 5;
s
/// END SOLUTION

25.700000
type: double

45/2 + 8 + 6

36
type: int

/// BEGIN SOLUTION
int n = 45/2 + 8 + 6;
n
/// END SOLUTION

36
type: int

9 == 3*3

true
type: bool

/// BEGIN SOLUTION
bool egalite = 9 == 3*3;
egalite
/// END SOLUTION

true
type: bool

true and 8 > 10

false
type: bool

/// BEGIN SOLUTION
bool proposition = true and 8 > 10;
proposition
/// END SOLUTION

false
type: bool

Avec cette feuille, nous avons fini notre première exploration des données en C++ : calculer des valeurs avec des expressions, comprendre les types de ces valeurs et leur influence, stocker les résultats dans des variables. Dans la feuille suivante, vous aborderez les conditions et les fonctions.

Vous pouvez maintenant fermer cette feuille; utilisez pour cela le raccourci clavier Ctrl+Maj+Q.

Contenu