Types de données fondamentaux Les types simples (entier, réel, caractère). Représentation des données. Nombres décimaux, nombres binaires et nombres hexadécimaux. Conversion d’un nombre d’une base à une autre. Jeux de caractères. Table ASCII. Déclaration de variables simples. Initialisation de variables simples. Opérateur d’affectation. Utilisation des opérateurs arithmétiques unaires et binaires. Opérateurs d’incrémentation et de décrémentation. Expressions et instructions. Données constantes. Conversions de type automatiques ou forcées. Priorité des opérateurs.

Qu’est-ce qu’une variable ? Les programmes doivent mémoriser les données qu’ils utilisent. Pour cela, les variables et les constantes fournissent plusieurs représentations et méthodes de stockage des informations. Étapes : Déclarer et définir des variables et des constantes. Affecter des valeurs aux variables et gérer ces valeurs. Écrire le contenu d’une variable à l’écran. Une variable est un emplacement en mémoire principale destiné à recevoir une donnée. Cette zone reçoit une valeur qui peut ensuite être réutilisée. La mémoire de votre ordinateur est comparable à des cases alignées une à une. Ces emplacements sont numérotés séquentiellement; il s’agit d’adresses en mémoire. 253 254 255 256 . . . Une variable peut occuper une ou plusieurs cases. Ex. : la case d’adresse 256.

Identificateur de variable Pour identifier une variable, on utilise un identificateur pour désigner le nom de cette variable. L’identificateur doit indiquer le rôle joué par cette variable; il faut éviter d’utiliser des noms qui n’évoquent rien. Ex. : Rayon_du_cercle au lieu de x. Cela vous épargnera de devoir connaître l’adresse réelle en mémoire de celle-ci. Un identificateur est composé de lettres (en minuscule ou en majuscule) et de chiffres. Le premier caractère doit être une lettre. Le symbole _ est considéré comme une lettre. Exemple : Variable_entiere, entier1, mot_en_francais sont valides mais 1er_entier, nom.2, nom de variable, deuxième_entier et a-b ne le sont pas. Note : C distingue les majuscules et les minuscules : Nom_de_variable est différent de nom_de_variable. La longueur des identificateurs n’est pas limitée mais C distingue seulement les 31 premiers caractères (1) . Ne pas utiliser des mots clés comme identificateur de variable : int. Il est déconseillé d’utiliser le symbole _ comme premier caractère car il est souvent utilisé pour définir des variables de l’environnement C. (1) Cette limite peut changer d’un compilateur à l’autre.

Déclaration de variables Les variables utiles dans un programme doivent être déclarées. Vous devez spécifier le nom de la variable (identificateur) ainsi que son type et parfois aussi leur valeur de départ. Syntaxe : type_de_la_variable nom_d_une_variable; ou encore type_de_la_variable nom_d_une_variable = valeur_initiale; Exemple : int entier1; // entier1 est une variable entière. int entier2 = 25; // entier2 est une variable entière initialisée à 25. Grâce à ces informations, le compilateur détermine l’espace mémoire (nombre de cases) à attribuer à la variable ainsi que le type des données contenues. Par ex., l’espace mémoire pour entier1 est réservé, celui prévu pour un entier. Le compilateur en déduit aussi les opérateurs qui sont définis pour chaque variable. Ex. : L’opérateur d’addition + est défini pour des variables entières.

Principaux types de variables 1 caractère Exemple : char caractere; float nombre_decimal; long int entier = 175; Note : On peut déterminer la taille d’un type de variable sur un ordinateur ainsi : cout << "La taille d’un entier est de : "  << sizeof(int) << " octets." ;

Taille des variables Chaque emplacement en mémoire a la taille d’un octet, i.e. 8 chiffres binaires 0 ou 1 (8 bits ou BInary digiTS). La taille d’une variable dépend de son type. L’intérêt de la base 2 est qu’elle représente exactement ce que l’ordinateur reconnaît car les ordinateurs ne connaissent pas les lettres, les chiffres, les instructions ou les programmes. Note : Conversion d’un nombre binaire en base 10. 1010011 en base 2 (i.e. 10100112) équivaut en base 10 au nombre suivant : 1 x 20 + 1 x 21 + 0 x 22 + 0 x 23 + 1 x 24 + 0 x 25 + 1 x 26 ou encore 1 + 2 + 0 + 0 + 16 + 0 + 64 ce qui donne 83 en base 10 (i.e. 8310). Par conséquent, un octet peut prendre les valeurs comprises entre 0 et 255 car 111111112  25510 = 28 - 1. Une variable de type char contient 1 caractère parmi 256 caractères admissibles. Une variable de type unsigned short int contient un entier entre 0 et 216 -1= 65535.

Conversion d’un nombre décimal en base 2 Exemple : Convertir 99 en base 2. Puissance de 2 : 27 26 25 24 23 22 21 20 Valeur : 128 64 32 16 8 4 2 1 Calculer la plus grande puissance de 2 plus petit ou égal à 99 i.e. 26. 99 ≥ 26 = 64  écrire 1 et soustraire 64 de 99 ce qui donne 35. 35 ≥ 25 = 32  écrire 1 et soustraire 32 de 35 ce qui donne 3. 3 < 24 = 16  écrire 0. 3 < 23 = 8  écrire 0. 3 < 22 = 4  écrire 0. 3 ≥ 21 = 2  écrire 1 et soustraire 2 de 3 ce qui donne 1. 1 ≥ 20 = 1  écrire 1 et soustraire 1 de 1 ce qui donne 0. Résultat : 11000112.

Algorithme de conversion d’un nombre décimal en base 2 1. Lire un nombre entier n. 2. Si n est égale à 0 alors écrire le chiffre binaire 0, terminé. 3. { Calcul de la plus grande puissance de 2 inférieur ou égale à n conservée dans PUISSANCE. } 3.1 Conserver la valeur 1 dans PUISSANCE. 3.2 Tant et aussi longtemps que PUISSANCE est plus petit ou égale à n Multiplier PUISSANCE par 2. 3.3 Diviser PUISSANCE par 2. 4. Tant et aussi longtemps que PUISSANCE est différent de 0 Si n est plus grand ou égale à PUISSANCE alors écrire le chiffre binaire 1 soustrait PUISSANCE de n sinon écrire le chiffre binaire 0. Diviser PUISSANCE par 2. 4.1 4.2 5. Terminé.

Variable signée ou non signée Une variable entière peut être signée ou non. Cela permet de connaître le signe de la valeur utilisée. Lorsqu’on travaille uniquement avec des valeurs positives ou nulles, les variables entières peuvent être non signées; elles sont alors toujours positives. Note : Puisque le # d’octets est le même pour les entiers signés et les entiers non signés et puisque le signe est rangé dans le 1e bit du premier octet réservé pour la variable entière, la valeur la plus élevée que vous pouvez stocker dans une variable non signée correspond au double du nombre positif le plus élevé contenu dans une variable entière signée. Exemple : long int -2 147 483 648 à 2 147 483 647 unsigned long int 0 à 4 294 967 295.

Création de plusieurs noms de variables Vous pouvez créer plusieurs variables de même type dans une même instruction en séparant les noms par des virgules, chaque variable recevant facultativement une valeur initiale. Syntaxe : type_de_la_variable nom_d_une_variable, nom_d_une_variable, …, nom_d_une_variable; ou encore type_de_la_variable nom_d_une_variable = valeur_initiale, nom_d_une_variable = valeur_initiale, …, nom_d_une_variable = valeur_initiale; ou une combinaison des deux. Exemple : long surface, longueur, largeur; unsigned int nombre_d_etudiants_dans_la_classe, annee; int Ton_age = 21, Mon_age, Son_age = 19; // La variable Mon_age n’est pas initialisée.

Propriétés des variables entières short ou long ou unsigned : que choisir ? Cela dépend du contexte : l’entier le plus grand considéré, des entiers positifs seulement ou non. Les variables entières non signées possèdent une valeur limite; quand la valeur maximale est dépassée, le contenu de la variable est remis à zéro. #include <iostream.h> void main() { unsigned short int Limite = 65535; cout << "Limite : " << Limite << endl; Limite = Limite + 1; // On ajoute 1 au contenu de la variable Limite. cout << "Limite + 1 : " << Limite << endl; } Ex. : une variable de type int : 65535 + 1 devient 0. 11111111111111112 + 1 devient 100000000000000002. x

Propriétés des variables entières Les variables entières signées possèdent aussi une valeur limite; quand la valeur maximale est dépassée, le contenu de la variable devient sa limite inférieure. Ex. : une variable de type int : 32767 + 1 devient -32768. 01111111111111112 + 1 devient 10000000000000002. #include <iostream.h> void main() { short int Limite = 32767; cout << "Limite : " << Limite << endl; Limite = Limite + 1; // On ajoute 1 au contenu de la variable Limite. cout << "Limite + 1 : " << Limite << endl; } Si vous devez manipuler des valeurs entières d’importance en valeur absolue, vous pouvez utiliser des variables de type long (4 octets). Ex. : long Gros_nombre = 100L; Gros_nombre = Gros_nombre + 2L;

Propriétés des variables caractère La taille des variables caractère (de type char) est de 1 octet. Chaque variable caractère peut renfermer un caractère parmi un jeu de 256 caractères ASCII (« American Standard Code for Information Interchange »).

Propriétés des variables caractère On retrouve ici les 128 premiers caractères qui renferment notamment les majuscules, les minuscules, les chiffres et les signes de ponctuation. Des codes étendus sont disponibles.

Caractères et nombres Tout caractère affecté à une variable char (comme un ‘a’) correspond à un nombre entre 0 et 255. Ex. : char c = 'a'; Note : La valeur numérique 5 et le caractère ASCII '5' (valeur décimale 53) ne sont pas égaux. #include <iostream.h> // Conversion d’un code ASCII en caractère. void main() { int i; cout << "Entrez une valeur entiere entre 0 et 127" << endl; cin >> i; cout << (char) i << endl; } Conversion explicite de int à char.

Propriétés des variables réelles Des variables de type float permettent de ranger des nombres réels comme par exemple, 1.6 0.00008 7655.899 avec une précision de 6 chiffres décimaux après le point. Les nombres réels peuvent aussi être exprimés comme une valeur décimale suivie d’une puissance de 10. Cela s’avère pertinent surtout pour de petits ou grands nombres. 0.16E1 0.8E-4 0.7655899E+4 La lettre E peut être remplacée par la minuscule e indifféremment. Il existe 3 types de variables réelles : Mot clé Nombre d’octets Domaine float 4 3.4E38 (6 chiffres après le point) double 8 1.7E308 (15 chiffres après le point) long double 10 1.2E4932 (19 chiffres après le point)

Déclaration et initialisation des variables réelles Ex. : float x, y, z; float rayon = 3.2f; double Gros_nombre = 1.23E25; long double Le_plus_gros_nombre = 123.7890123L;

Définition d’un type C++ permet de créer un alias (synonyme) à un type de donnée, en utilisant le mot clé typedef. Syntaxe : typedef nom_du_type_existant alias_du_type_existant; Exemple : #include <iostream.h> typedef unsigned short int ushort; void main() { ushort Limite = 65535; cout << "Limite : " << Limite << endl; Limite = Limite + 1; // On ajoute 1 au contenu de la variable Limite. cout << "Limite + 1 : " << Limite << endl; }

Les constantes Comme les variables, les constantes sont des zones de stockage d’informations mais elles ne sont pas modifiables. Une fois créée, une constante reçoit une seule valeur durant l’exécution du programme. Deux types de constantes : 1. Les constantes littérales Une valeur définie au moment voulu dans le programme. Ex. : int Age = 18; // Age est une variable entière alors que // 18 est une constante littérale. 2. Les constantes symboliques Comme une variable, une constante symbolique est représentée par un nom. Ex. : Supposons que dans votre programme, vous avez à calculer la moyenne des résultats obtenus par les élèves de votre classe. L’une des données du problème est le nombre d’élèves de votre classe. Vous pourriez la définir comme étant une constante symbolique.

Création d’une constante symbolique : #define Utilisation de #define Méthode ancienne, désormais obsolète. Syntaxe : #define nom_de_la_constante_symbolique valeur_de_la_constante_symbolique Ex. : #define nombre_d_eleves 15 Ce n’est pas une instruction en C ou C++ mais une commande du préprocesseur(1) qui effectue une substitution de texte : chaque fois que le mot nombre_d_eleves est rencontré, il est remplacé par la constante littérale 15. La constante nombre_d_eleves n’a pas de type particulier. La constante symbolique n’est pas créée puisque la substitution se fait avant la compilation. (1) Le préprocesseur est lancé avant la compilation pour traduire toutes les commandes commençant par le signe # en commandes spéciales qui entraînent une modification dans le code source du programme. #include <iostream.h> permet d’inclure dans votre programme ce fichier en-tête.

Création d’une constante symbolique : const Utilisation de const Le mot clé const permet de créer des constantes C++ : const unsigned short int nombre_d_eleves = 15; Cela permet au compilateur de connaître et de répertorier le type de la constante. Cela permet de mettre à jour le code du programme avec aisance. Syntaxe : const type_de_la_constante_symbolique identificateur_de_la_constante_symbolique;

Création d’un type énumération Création de nouveaux types permettant de définir des variables dont les valeurs admissibles sont des constantes symboliques. À chaque constante correspond une valeur entière. Certains compilateurs exigent que les valeurs soient indiquées en ordre croissant dans une énumération. Pour déclarer une variable de type enum, le mot clé enum doit précéder la déclaration. Syntaxe : enum nom_du_nouveau_type { constante_symbolique, constante_symbolique, …, constante_symbolique }; ou encore enum nom_du_nouveau_type { constante_symbolique = valeur_de_la_constante, constante_symbolique = valeur_de_la_constante, constante_symbolique = valeur_de_la_constante }; ou une combinaison des deux.

Exemples d’un type énumération enum RVB { rouge, vert, bleu }; enum RVB couleur_primaire = vert; Exemple I : rouge, vert et bleu sont des constantes symboliques égales à 0, 1 et 2 resp. couleur_primaire est une variable de type enum RVB. Exemple II : enum Jours { dimanche = 1, lundi, mardi, mercredi, jeudi, vendredi, samedi }; enum Jours Congé = dimanche; Cela signifie que lundi vaut 2, mardi 3 et ainsi de suite. Exemple III : enum Unite_de_temps { seconde = 1, minute = 60, heure = 3600 }; Exemple IV : enum booleen { faux = 0, vrai = 1 }; En C, il n’existe pas de type booléen mais on peut le définir. En C++, le type bool existe et correspond à la définition suivante : enum bool { false = 0, true = 1 };

Opérateur d’affectation Syntaxe : identificateur_de_variable = expression; Exemple : int entier1 = 5, total; total = entier1 – 2; But : stocker la valeur d’une expression dans une variable et retourner cette valeur. La valeur retournée peut ne pas être utilisée par la suite. Note : L’opérande de gauche ne peut être une constante. Les constantes et les variables sont des expressions lesquelles peuvent être combinées entre elles par des opérateurs et former des expressions de plus en plus complexes. Ex. : int entier1 = 5, entier2, total; // revient à réaliser les étapes suivantes : total = entier2 = entier1 – 2; /* - calculer la soustraction de entier1 avec 2, - ranger le résultat 3 dans la variable entier2, - ranger le résultat 3 dans la variable total, - retourner la valeur 3. */ entier1 entier2 total entier1 entier2 total avant 5 après 5 3 3 Note : On pourrait écrire : cout << total = entier2 = entier1 – 2;

Opérateurs arithmétiques L’opérateur d’addition : + Il est défini pour des variables entières, réelles et caractères. Cela retourne le résultat de la somme. Ex. : cout << a + b; Dans le cas des variables caractères, ce sont les codes numériques de celles-ci qui sont additionnés et cela retourne le code numérique résultant. Ex. : char c = 'a'; char d = 'b'; cout << c + d << endl << c + 1 << endl << 1 + c << endl; 195 98

Débordement de capacité : opérateur d’addition #include <iostream.h> void main() { short int i = 32767; // valeur limite = 32767. i = i + 1; cout << i << endl << i+1 << endl; unsigned short int j = 65535; // valeur limite = 65535. j = j + 1; cout << j << endl << j+1 << endl; float x = 3.4E38f, y; // valeur limite = 3.4E38. y = x * 10.0f; cout << x * 10.0f << endl << y << endl; } -32768 -32767 1 1.#INF

Opérateurs arithmétiques L’opérateur de soustraction : - Il est défini pour des variables entières, réelles et caractères. Cela retourne le résultat de la soustraction. Ex. : cout << a - b; Dans le cas des variables caractères, ce sont les codes numériques de celles-ci qui sont soustraits et cela retourne le code numérique résultant. Ex. : char c = 'a'; char d = 'b'; cout << d - c << endl; 1 Note : Si le code résultant est négatif, quelle interprétation pouvons-nous en faire ?

Débordement de capacité : opérateur de soustraction #include <iostream.h> void main() { short int i = 50, j = 100, k; k = i – j; cout << k << endl; unsigned short int u = 50, v = 100, w; w = u - v; cout << w << endl; } -50 65486

Multiplication et division L’opérateur de multiplication : * Il est défini pour des variables entières, réelles et caractères. Cela retourne le résultat de la multiplication. Ex. : cout << a * b; Dans le cas des variables caractères, ce sont les codes numériques de celles-ci qui sont multipliés et cela retourne le code numérique résultant. L’opérateur de division : / Il est défini pour des variables entières, réelles et caractères. Cela retourne le résultat de la division. Ex. : cout << a / b; Dans le cas des variables caractères, ce sont les codes numériques de celles-ci qui sont divisés (division entière) et cela retourne le code numérique résultant. Ex. : char a = 'a', b = 'b'; cout << a / b; // Affichage de 0.

Division entière et modulo La division d’entiers est quelque peu différente de la division décimale. La division d’entiers ne tient pas compte du reste de la division. Pour obtenir le reste de la division entière, on utilise l’opérateur modulo %. #include <iostream.h> void main() { int i = 12, j = 7; cout << i % j << endl; int u = -12, v = 7; cout << u % v << endl; int x = 12, y = -7; cout << x % y << endl; int s = -12, t = -7; cout << s % t << endl; } 5 -5

Combinaison des opérateurs arithmétiques et d’affectation Il est courant d’ajouter une valeur à une variable, puis de renvoyer le résultat dans cette dernière. int somme = 15; int temp; temp = somme + 5; somme = temp; Plutôt lourd comme approche. On peut retrouver la même variable de chaque côté de l’opérateur d’affectation. int somme = 15; somme = somme + 5; Plus facile à gérer mais non conforme à la notation algébrique. C++ renferme aussi les opérateurs suivants : +=, -=, *=, %= et /=. Syntaxe : identificateur_de_variable += expression; Ex. : int somme = 15; somme += 5; // Le résultat est identique quoique plus difficile à lire. But : additionner la valeur d’une expression à une variable, ranger dans cette variable le résultat de la somme et retourner cette valeur. La valeur retournée peut ne pas être utilisée par la suite.

Opérateurs d’incrémentation ++ et de décrémentation -- Cela permet d’ajouter ou de soustraire 1 à une variable. int a = 5; a++; revient à écrire a = a + 1; ou encore a += 1; Ces opérateurs sont utilisés comme préfixe (l’opérateur précède la variable) ou suffixe (l’opérateur suit la variable). Mode préfixe : On incrémente la variable avant de l’utiliser. int b = ++a; // a prend d’abord la valeur 7 puis, b est initialisée à 7. Mode suffixe : On utilise la variable avant de l’incrémenter. int c = b++; // c prend d’abord la valeur de b(7) puis, b est incrémentée(8). Note : à éviter à l’intérieur d’instructions « simples ». int i = 12, j = 0, k = 0; cout << ++(++i = ++i + i++); ?!|#&?!

Priorité des opérateurs Dans l’instruction x = y - z * 5; quelle partie sera traitée en premier ? En fait, la multiplication vient avant l’addition. Tout opérateur a un niveau de priorité par rapport aux autres. La priorité est l’ordre dans lequel un programme réalise les opérations dans une formule. Si un opérateur a priorité sur un autre, il est évalué le premier. Plus le rang est bas, plus la priorité est grande (voir le tableau suivant). Pour modifier l’ordre de priorité des opérateurs, utilisez les parenthèses. x = (y – z) * 5; On peut utiliser plusieurs niveaux d’imbrication des parenthèses. Si nous avons une suite d’opérateurs binaires de même priorité, l’évaluation se fait de la gauche vers la droite. Ex. : x = y * z / w; Pour les opérateurs unaires (!, ++, --) et pour les opérateurs d’affectation (=, +=, -=, *=, /=, %=), l’évaluation se fait de droite à gauche dans l’expression. Exemple : La valeur de la forme algébrique (x – y)2 (x + 2) - 5 à conserver dans la variable z s’écrit : z = ((x – y) * (x - y)) * (x + 2) - 5; ou encore, z = -5 + (x + 2) * (z *= z = x - y);

Priorité des principaux opérateurs Rang Opérateurs 1 () 2 ! ++ -- 3 * / % 4 + - 5 < <= > >= 6 == != 7 && 8 || 9 = += -= *= /= %= Ex. : A = 5, B = 10, C = 1. Ex. : A = 5, B = 10, C = 1. X = 2 * (A + 3) * B + 4 * C; X = 2 * A + 3 * B + 4 * C; 8 10 30 4 160 4 44 164

Priorité des opérateurs

Conversions de type automatiques On peut retrouver dans une même expression des données de types différents. Pour évaluer cette expression, elles doivent être converties dans un même type de données. float x = 3.45f; int y = x + 2; Ex. : La plupart du temps, les conversions de type se font automatiquement et le programmeur n’a pas à intervenir. Celui-ci doit quand même en prévoir les conséquences. Dans l’exemple précédent, y contient la valeur 5 (une valeur tronquée). Lors d’une affectation, la donnée à droite du signe d’égalité est convertie dans le type à gauche. Il peut y avoir perte de précision dans ce cas. Par contre, ces conversions automatiques permettent de passer d’un type de plus petite taille en un type plus grand. int i = 8; float x = 12.5f; double y; cout << (y = i * x); 100 Ex. : conversion en double conversion en float

Conversions de type automatiques Règles de conversion : Une opération avec un entier et un nombre décimal entraîne la conversion de l’entier en décimal. Dans le cas d’une opération avec 2 nombres décimaux, le type de plus grande taille est choisi selon l’ordre suivant : long double, double, float. Dans le cas d’une opération avec 2 entiers, les types char et short sont convertis en int et le type de plus grande taille est choisi selon l’ordre suivant : unsigned long, long, unsigned int, int. int x; float a = 12.48f; char b = 4; cout << (x = a / b); 3 Ex. : conversion en int conversion en float char a=3, f; int b = 4; float c = 4.0f, d, e; cout << (d = a / c) << endl << (e = a / b) << endl << (f = a / c); 0.75 Ex. : conversion en float conversion en int conversion en char (0)

Conversions de type forcées Parfois, il est nécessaire de convertir une donnée dans un type différent de celui que choisirait la conversion automatique. Nous devons alors forcer la conversion. Syntaxe : ( type_de_donnée) char a=3; int b = 4; float c; cout << (c = (float) a / b); 0.75 Ex. : conversion automatique en float conversion forcée en float Note : Les contenus de a et de b demeurent inchangés; seulement les valeurs utilisées dans les calculs sont converties.

Circonférence et aire d’un cercle #include <iostream.h> void main() { const float Pi = 3.14159f; // Valeur approximative de Pi. float rayon; // Rayon du cercle. // Lecture du rayon du cercle. cout << "Entrez le rayon du cercle :" << endl; cin >> rayon; // Affichage de la circonférence du cercle. cout << "Circonference du cercle : " << 2.0f * Pi * rayon << endl; // Affichage de l'aire du cercle. cout << "Aire du cercle : " << Pi * rayon * rayon << endl; }

Distance entre un point et un plan dans l’espace à 3 dimensions Calculer la distance d d’un point P = (p1, p2, p3) à un plan défini par un point Q = (q1, q2, q3) et un vecteur normale unitaire n = (n1, n2, n3). P n |P-Q|  d Q n est unitaire d = || P – Q || cos   d = || P – Q || || n || cos  = (P - Q)  n = (P - Q)  n || n || || n || Qu’arrive-t-il si P fait partie du plan ?

Distance entre un point et un plan dans l’espace à 3 dimensions #include <iostream.h> void main() { float Px, Py, Pz; // Coordonnées du point P. float Qx, Qy, Qz; // Coordonnées d'un point Q du plan. float nx, ny, nz; // Coordonnées de la normale n au plan. // Lecture des coordonnées du point P. cout << "Coordonnées du point P : "; cin >> Px >> Py >> Pz; // Lecture des coordonnées du point Q. cout << "Coordonnées du point Q : "; cin >> Qx >> Qy >> Qz; // Lecture des coordonnées de la normale n au plan. cout << "Coordonnées du vecteur n : "; cin >> nx >> ny >> nz; // Calcul de la distance d. float d = (Px - Qx) * nx + (Py - Qy) * ny + (Pz - Qz) * nz; // Affichage du résultat. cout << "Affichage de la distance d : " << d << endl; }

Encryptage et décryptage d’un message CRYPTAGE : Action de rendre illisible des informations pour quiconque qui ne possède pas la clé de décryptage. DECRYPTAGE : Action de rendre lisible des données cryptées grâce à la clé de cryptage. Luc veut transmettre un message à Pierre sans que personne d’autres n’y ait accès. Luc veut transmettre à Pierre le caractère c codé; pour y arriver, il lui transmet plutôt les 2 caractères correspondants aux codes entiers d et e suivants : d = (a * s + b) / 256 (division entière) e = (a * s + b) % 256 (opération modulo) où a et b sont 2 constantes entières non nulles plus petites que 256. Les valeurs a et b sont connues de Luc et de Pierre. Fixons-les à a = 251, b = 247. Nous allons d’abord aider Luc et lui construire un programme qui détermine les 2 caractères obtenus après l’opération de cryptage. Nous allons ensuite aider Pierre et lui construire un programme qui détermine le caractère obtenu après l’opération de décryptage.

Programme de cryptage #include <iostream.h> void main() { const int a = 251; // Constante de cryptage. const int b = 247; // Constante de cryptage. char c; // Caractère à transmettre. char d, e; // Caractères cryptés. // Lecture du caractère que Luc veut transmettre à Pierre. cout << "Caractere a transmettre : "; cin >> c; // Déterminer les 2 caractères obtenus après l'opération de cryptage. d = (char) ((a * c + b) / 256); e = (char) ((a * c + b) % 256); // Affichage des 2 caractères obtenus après l'opération de cryptage. cout << d << " " << e << endl; }

Programme de décryptage #include <iostream.h> void main() { const int a = 251; // Constante de cryptage. const int b = 247; // Constante de cryptage. char c; // Caractère à recevoir. char d, e; // Caractères cryptés. // Lecture des 2 caractères cryptés que Pierre a reçus. cout << "Caracteres cryptes : "; cin >> d >> e; // Déterminer le caractère obtenu après l'opération de décryptage. // a * c + b = 256 * d + e. c = (char) ((256 * d + e - b) / a); // Affichage des 2 caractères obtenus après l'opération de cryptage. cout << c << endl; }

Produit de deux grands entiers Habituellement, il est impossible de multiplier directement deux entiers p et q de 6 chiffres et obtenir un résultat exact : le résultat pq a 12 chiffres. Stratégie : Exprimons p et q comme suit : p = a x 103 + b q = c x 103 + d où a, b, c et d ont 3 chiffres. On obtient alors : pq = (a x 103 + b) (c x 103 + d) = ac x 106 + (ad + bc) x 103 + bd. Nous allons alors placer la valeur de pq dans 2 entiers de 6 chiffres : Ex. : 999 999 entier1 entier2 x 998 001 998 001 000 998 001 000 998 001

Programme qui calcule le produit de 2 grands entiers #include <iostream.h> #include <iomanip.h> void main() { long int p, q, a, b, c, d, entier1, entier2; // Lecture des 2 nombres p, q. cout << "Entrez les 2 nombres : "; cin >> p >> q; // Détermination des coefficients a, b, c, d. b = p % 1000; d = q % 1000; a = p / 1000; c = q / 1000; // Détermination de entier1 et entier2. entier1 = a * c + (a * d + b * c) / 1000; entier2 = b * d + ((a * d + b * c) % 1000) * 1000; entier1 = entier1 + entier2 / 1000000; entier2 = entier2 % 1000000;

Programme qui calcule le produit de 2 grands entiers // affichage du résultat. cout << "Produit : " << setw(6) // largeur du champ d'impression. << setfill('0') // caractère de remplissage. << entier1 << entier2 << endl; }

Calcul de la racine carrée d’un entier positif Exemple : Racine carrée de 8234567 à 2 décimales près. 8, 23, 45, 67 2 8 6 9. 5 9 - 4 4 423 56 - 384 572 3945 - 5738 3396 5 7 3 9 0 54967 - 51561 340600 Solution : 2869.59 - 286925 5367500 - 5165181 202319

Algorithme qui calcule la racine carrée d’un entier positif n 1. Lire l’entier n à évaluer et m le nombre de décimales après le point. 2. Initialiser la variable entière DECIMALE à 0 et la variable entière P à 1. { Calcul dans P de la puissance de 100 la plus élevée inférieure ou égale à n. } 3. Tant et aussi longtemps que 100 * P  n alors P est multiplié par 100. Placer dans la variable entière BLOC la valeur de n / P où la division est entière. n devient n – (n / P) * P. 4. { Placer dans la variable entière RESULTAT le plus grand chiffre qui, élevé au carré est inférieur ou égale à BLOC. } 5. Pour chaque valeur de RESULTAT allant de 9 à 0 en ordre décroissant, si RESULTAT * RESULTAT  BLOC aller à l’étape 6. Soustraire à BLOC la valeur de RESULTAT * RESULTAT. 6. Placer dans la variable entière DOUBLER la valeur de RESULTAT * 2. 7. P devient P / 100. 8. 9. Si P est différent de 0 alors placer dans BLOC la valeur de l’expression BLOC*100 + n / P n devient n – (n / P) * P sinon placer dans BLOC la valeur de l’expression BLOC*100

Algorithme qui calcule la racine carrée d’un entier positif n { Placer dans la variable CHIFFRE le plus grand chiffre entre 0 et 9 dont l’expression CHIFFRE * CHIFFRE + CHIFFRE * DOUBLER * 10 est inférieur ou égale à BLOC. } 10. Soustraire à BLOC la valeur de l’expression CHIFFRE * CHIFFRE + CHIFFRE * DOUBLER * 10. 11. Multipliez par 10 la valeur de RESULTAT et ajouter la valeur de CHIFFRE. Conserver le résultat dans la variable RESULTAT. 12. 13. Si P est égale à 0 alors ajouter 1 à la variable Decimale. 14. Si Decimale est inférieure à m alors aller à l’étape 7. 15. { Affichage du résultat. } Affecter la valeur 1 à P. Pour chaque i allant de 1 à DECIMALE, multiplier P par 10. Placer dans R la valeur de RESULTAT / P + (RESULTAT % P) * (1.0 / P). Afficher la valeur réelle R.