TP 2, Feuille 1 : valeurs, types et variables
Contents
TP 2, Feuille 1 : valeurs, types et variables#
Introduction à Jupyter et premiers calculs#
Lors de ces premières semaines de cours, nous allons travailler dans l’application web Jupyter qui permet d’exécuter du code C++
interactivement, un peu comme une super calculatrice. Plus tard, nous verrons comment créer un programme C++
indépendant en dehors de Jupyter.
Exercice
Cliquez sur la cellule suivante puis exécutez la en appuyant sur les touches
Maj+Entr
.
1 + 1
La première ligne donne le résultat du calcul. La deuxième ligne indique que ce résultat est de type entier (int
).
Techniquement parlant, le navigateur web a envoyé le contenu 1+1
de la cellule à un noyau (kernel en anglais) qui l’a compilé et exécuté, avant de renvoyer le résultat à afficher. Le noyau que nous utilisons (C++11
) permet de travailler en C++
. Il existe des noyaux pour beaucoup d’autres langages de programmation.
Modifiez l’expression dans la cellule précédente et exécutez la de nouveau.
Exercice
Utilisez la cellule suivante pour calculer la surface d’un rectangle de largeur 25 et de longueur 37.
/// BEGIN SOLUTION
25*37
/// END SOLUTION
Regardez le type du résultat. Quels autres types de variables avez-vous vus en cours ?
Refaites le calcul précédent de sorte que son type soit
double
:
/// BEGIN SOLUTION
25.*37
/// END SOLUTION
Exercice
Les lignes suivantes vous présentent des exemples de calculs. Exécutez-les en observant bien la valeur du résultat et son type.
3*(1+3) + (1+4)*(2+4)
42 / 2
42 / 5
42. / 5
42 % 5
1 + 1.
42 == 6*7
41 == 2*21
Remarque: dans les deux cellules précédentes, nous avons utilisé un double égal ==
qui sert à tester une égalité. Nous reverrons bientôt la signification du simple égal =
.
1 < 2
2 > 3
1 < 2 and 2 > 3
1 < 2 or 2 > 3
Note: pour éviter de fausses manœuvres, nous configurons de nombreuses
cellules, telles celles ci-dessus, pour qu’elles soient non modifiables.
Pour faire vos propres expérimentations ou pour prendre des notes personnelles,
vous pouvez à tout moment insérer de nouvelles cellules. Insérez maintenant
une cellule ci-dessous en utilisant le Menu Insérer
. Ensuite, utilisez
le menu Cellule
-> Type de cellule
pour en faire une cellule de texte
(Markdown
). Notez les raccourcis claviers dans les menus.
Exercice
Pour chacune des expressions suivantes, déterminez de tête le type et le résultat, et donnez votre réponse à l’endroit indiqué sous la forme type
, résultat
; puis vérifiez en exécutant la cellule.
Type : int, bool, double ?
Résultat : 7, 9, 11, 21 ?
BEGIN SOLUTION int, 11 END SOLUTION
3 * 2 + 5
Type : int, bool, double ?
Résultat : 12 ou 12.5 ?
BEGIN SOLUTION int, 12 END SOLUTION
25 / 2
Type : int, bool, double ?
Résultat : 6, 7, 6.0000, 7.0000?
BEGIN SOLUTION double, 7.0000 END SOLUTION
3.5*2
Type: int, bool, double ?
Résultat : 5, 4, 4.66667 ?
BEGIN SOLUTION double, 4.66667 END SOLUTION
14. / 3
Type : int, bool, double ?
Résultat : 3,7,21, true, false ?
BEGIN SOLUTION bool, true END SOLUTION
3*7 == 21
Type : int, bool, double ?
Résultat : 21, 25, true, false ?
BEGIN SOLUTION bool, true END SOLUTION
(3*7 == 21) and (4.2 > 5.3 or 4*4 == 8*2)
Type : int, bool, double ?
Résultat : 1, 0, true, false ?
BEGIN SOLUTION bool, false END SOLUTION
true and false
Type : int, bool, double ?
Résultat : 1, 0, true, false ?
BEGIN SOLUTION bool, false END SOLUTION
true or false
Type : int, bool, double ?
Résultat : 1, 0, true, false ?
BEGIN SOLUTION bool, true END SOLUTION
(false and false) or true
Type : int, bool, double ?
Résultat : 1, 0, true, false ?
BEGIN SOLUTION bool, false END SOLUTION
false and (false or true)
Variables#
Jusqu’à présent, nous avons effectué des calculs et observé le résultat. Pour écrire des programmes, nous aurons besoin de stocker le résultat dans une variable. Exécutez la cellule suivante.
int a = 3;
Une fois que la variable a
a été déclarée et qu’on lui a assigné une valeur, on peut afficher ou réutiliser cette valeur:
a
a + 1
a + a + a
On peut aussi modifier la valeur de a
:
a = 5;
a
a = a + 1;
a
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. Exécutez les cellules suivantes et observez le résultat:
1 + 1
1 + 1;
1 + 1;
2 + 2
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.
Retour sur les variables#
Exercice
Les cellules suivantes définissent deux variables r
et pi
. 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 (considérer que 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
.
double pi = 3.1415;
double r;
r = 5;
Aire:
/// BEGIN SOLUTION
pi * r * r
/// END SOLUTION
Périmètre:
/// BEGIN SOLUTION
2 * pi * r
/// END SOLUTION
r = 2.5;
Aire:
/// BEGIN SOLUTION
pi * r * r
/// END SOLUTION
Périmètre:
/// BEGIN SOLUTION
2 * pi * r
/// END SOLUTION
r = 10;
Aire:
/// BEGIN SOLUTION
pi * r * r
/// END SOLUTION
Périmètre:
/// BEGIN SOLUTION
2 * pi * r
/// END SOLUTION
Exercice
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
b // doit afficher 8 (ancienne valeur de c)
c // doit afficher 5 (ancienne valeur de b)
/// 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 assigne une valeur du mauvais type à une variable ?
Exercice
Faites-vous une opinion en observant le résultat des affectations suivantes.
int v1;
v1 = 2
v1 = 2.5
v1 = false
double v2;
v2 = 5
v2 = 5.3
v2 = true
bool v3;
v3 = 2
v3 = 0
v3 = 1.5
v3 = false
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
Pour chaque expression ci-dessous, déclarez une variable du bon type et assignez-lui le résultat, puis affichez le contenu de la variable pour le vérifier
Exemple :
1 + 2
int i = 1 + 2;
i
A vous de faire comme dans l’exemple avec les expressions ci-dessous:
2.3*9 + 5
/// BEGIN SOLUTION
double s = 2.3*9 + 5;
s
/// END SOLUTION
45/2 + 8 + 6
/// BEGIN SOLUTION
int n = 45/2 + 8 + 6;
n
/// END SOLUTION
9 == 3*3
/// BEGIN SOLUTION
bool egalite = 9 == 3*3;
egalite
/// END SOLUTION
true and 8 > 10
/// BEGIN SOLUTION
bool proposition = true and 8 > 10;
proposition
/// END SOLUTION
Bravo, vous avez terminé la première feuille de l’exercice 2.
Vous pouvez maintenant passer à la deuxième feuille!