Le langage C/C++
TOUHTOUH Samira
Ecole Nationale des Sciences Appliquées d’El Jadida
Les variables :
• Une variable est un identificateur qui désigne un type d’information dans un programme. Elle est située dans un endroit précis de la mémoire de la machine et représente souvent une donnée élémentaire, c’est-à-dire une valeur numérique ou un caractère.
• Les types de données de base sont les suivant : - int : valeur entière
- char : caractère simple
- float : nombre réel en virgule flottante
• Pour déclarer une variable, on précise son type suivi de son identificateur (son nom).
TYPE NOM (VALEUR); TYPE NOM = VALEUR;
• L’identificateur d’une variable est composé d’un ensemble de chiffres ou de lettres dans un ordre quelconque qui suit les règles suivantes :
- Le premier caractère doit être obligatoirement une lettre.
- Les minuscules ou les majuscules sont autorisées et considérées comme différentes.
- Le caractère (underscore ou blanc souligné) est autorisé.
- Il faut veiller à ne pas utiliser des mots-clés ou mots réservés du langage C++.
•
La déclaration d’une variable peut être assimilée à la création
en mémoire d’un contenant dont le type serait la taille (ou
dimension) et le contenu, la valeur.
•
Quand aucune valeur n’a encore été affectée à une variable,
seule sa place est réservée. Son contenu n’étant pas encore défini, il
viendra ultérieurement.
•
Au cours de la rédaction d’un programme, une variable peut être
déclarée à tout moment, toutefois, les développeurs ont pour
habitude de regrouper les déclarations, ce qui apporte une
•
Il est possible d’initialiser une variable lors de sa déclaration comme
dans :
int n = 15 ;
•
Ici, pour le compilateur, n est une variable de type int dans laquelle
il placera la valeur 15 ;
•
La déclaration précédente pourrait être remplacée par une
déclaration ordinaire (int n), suivie un peu plus loin d’une
affectation (n=15) ; la seule différence résiderait dans l’instant où n
recevrait la valeur 15.
•
Il est possible de déclarer que la valeur d’une variable ne doit pas
changer lors de l’exécution du programme. Par exemple, avec :
const int n = 20 ;
Les opérateurs arithmétiques en C++.
Présentation des opérateurs
•
Comme tous les langages, C
++dispose d’opérateurs classiques « binaires
» (c’est-à-dire portant sur deux « opérandes »), à savoir l’addition (+), la
soustraction (-), la multiplication (*) et la division (/), ainsi que d’un
opérateur « unaire » (c’est-à-dire ne portant que sur un seul opérande)
correspondant à l’opposé noté - (comme dans -n ou dans -x+y).
•
Les opérateurs binaires ne sont a priori définis que pour deux opérandes
ayant le même type parmi : int, long int, float, double et long double.
Le cast
•
Lorsque, les deus opérandes sont de type différent, le compilateur
prévoit une conversion suivant l’ordre : char > short > long >
float > double,
•
Le plus petit est automatiquement transformé dans le plus grand,
Exemple :
int a=64,b=2;
float x=1,y=2;
b=7/b;
x=7/b;
x=7/y; x=7.0/b;
x=((float)(a+1))/b;
Les priorités relatives des opérateurs
•
Lorsque plusieurs opérateurs apparaissent dans une même
expression, il est nécessaire de savoir dans quel ordre ils sont mis en
jeu.
•
En C++, comme dans les autres langages, les règles
sont naturelles et rejoignent celles de l’algèbre traditionnelle ;
•
Les opérateurs unaires + et - ont la priorité la plus élevée. On
trouve ensuite, à un même niveau, les opérateurs *, / et %. Enfin,
sur un dernier niveau, apparaissent les opérateurs binaires + et -.
En cas de priorités identiques, les calculs s’effectuent de gauche à
droite.
Les parenthèses permettent d’outrepasser ces règles de priorité,
en forçant le calcul préalable de l’expression qu’elles contiennent.
Affectation
L'opérateur d'affectation affecte une valeur à une variable.
a = 6;
Affectation composée
Quand on veut modifier la valeur d'une variable en effectuant une opération sur la valeur actuellement stockée dans cette variable, nous pouvons utiliser des opérateurs d'affectation composés:
a += b; a = a + b;
a -= 2; a = a-2; a /=b; a= a/b;
Exemple : trouver la valeur de a #include <iostream> using namespace std; int main () { int a, b=3; a = b; a+=2; cout << a; return 0; }
Les opérateurs relationnels
• Comme tout langage, C++ permet de comparer des expressions à l’aide d’opérateurs classiques de comparaison. En voici un exemple :
2 * a > b + 5
• Le résultat de la comparaison est une valeur booléenne prenant l’une des deux valeurs true ou false.
• Les expressions comparées pourront être d’un type de base quelconque et elles seront soumises aux règles de conversion.
Voici la liste des opérateurs relationnels existant en C++ :
Exemple 1: Exemple 2: a=2, b= 3, c = 6
(7 ==5) (5 > 4) (3 !=2) (6 >= 6) (5 < 5) (a == 5) (a*b >= c) (b+4 > a*c) ((b = 2) ==a)
Les opérateurs logiques (!, &&, | |)
L’opérateur ! renvoi la valeur booléenne opposée de l'évaluation de son opérande
Exemple :
!(5 == 5) !(6 <= 4) !true !false L’opérateur | | a b a | | b vrai vrai vrai vrai faux vrai faux vrai vrai faux faux faux L’opérateur &&a b a && b vrai vrai vrai vrai faux faux faux vrai faux faux faux faux
Les opérateurs conditionnels
L'opérateur conditionnel évalue une expression retournant une valeur si cette expression est vraie et une deuxième valeur si l'expression est évaluée comme fausse. Son format est le suivant:
condition ? A : B Exemple : #include <iostream> using namespace std; int main () { int a,b,c; a=2; b=7; c = (a>b) ? a : b; cout << c; return 0; }
L’opérateur virgule
L'opérateur virgule (,) est utilisé pour séparer deux ou plusieurs expressions qui sont inclus où une seule expression est attendue.
Exemple :
Opérateurs d’incrémentation et de décrémentation
Incrémentation
C’est parmi les opérations, les plus courantes en informatique. Il permet par exemple de passer du niveau 4 au niveau 5.
Int nombreLivres; // Il y a 4 livres
++ nombreLivres; // A partir d’ici, il y a 5 livres Int nombreLivres; // Il y a 4 livres
La décrémentation
La décrémentation est l’opération inverse, soustraire 1 à une variable,
Int nombreLivres(4); // il y a 4 livres
nombreLivres = nombreLivres-1; // on en enlève un, A partir d’ici, il y a 3 livres.
Int nombreLivres(4); // Il y a 4 livres dans la partie
Énoncé
Soient les déclarations suivantes : int n = 5, p = 9 ;
int a ; float x ;
Quelle est la valeur affectée aux différentes variables concernées par chacune des instructions suivantes ?
a = n < p ; (1 a = n == p ; (2 a = p % n + p > n ; (3 x = p / n ; (4 x = (float) p / n ; (5 x = (p + 0.5) / n ; (6 x = (int) (p + 0.5) / n ; (7 a = n * (p > n ? n : p) ; (8 a = n * (p < n ? n : p) ; (9
Les entrées-sorties conversationnelles de C
++Affichage à l’écran avec cout Exemple 1 :
Considérons ces instructions : Int n = 25 ;
cout << ‘’valeur : ‘’ ; cout << n ;
Elles affichent le résultat suivant : valeur : 25
• Nous avons utilisé le même opérateur << pour envoyer sur cout, d’abord une information de type chaîne, ensuite une information de type entier.
• Le rôle de l’opérateur << est manifestement différent dans les deux cas : dans le premier, il a transmis les caractères de la chaîne, dans le second, il a procédé à un « formatage » pour convertir une valeur binaire entière en une suite de caractère.
Exemple 2
• Les deux instructions peuvent se condenser en une seule : cout << ‘’ valeur : ‘’ ;
cout << n;
cout <<‘’valeur :’’ << n;
Dans un premier temps, cout reçoit la chaîne ‘’valeur’’ ;
Dans un deuxième temps, le cout <<‘ ’valeur :’’, c’est-à-dire le flot cout augmenté de ‘’valeur : ‘’, reçoit la valeur de n.
cin
Le dispositif d'entrée standard est en général le clavier. Manipulation de l'entrée standard en C++ se fait en appliquant l'opérateur d'extraction (>>) sur le flux cin. L'opérateur doit être suivie par la variable qui va stocker les données qui va être extrait du flux.
int n; cin>> n;
La première instruction déclare une variable de type int appelé n, et le second attend une entrée de cin (sur le clavier) afin de le stocker dans cette variable entière.
#include <iostream> using namespace std; int main ()
{
int i;
cout << "Entrez un entier: "; cin >> i;
cout << "La valeur saisie est : " << i <<endl;
cout << "Le double de la valeur est : " << i*2 << endl; return 0;
On peut également utiliser cin pour demander plus d'une entrée de référence : cin >> n >> p ;
est équivalent à : cin n;
Les instructions de contrôle
• Un programme est en général pas limitée à une séquence linéaire
d'instructions. Au cours de son processus, il peut répéter le code ou prendre des décisions. Pour ce faire, C++ fournit des structures de contrôle qui
servent à préciser ce qui doit être fait par notre programme, quand et dans quelles circonstances.
• Les structures de contrôle permettent, de contrôler l’exécution du programme en fonction de critères particuliers.
• Le C et le C++ disposent de toutes les structures de contrôle classique des langages de programmation comme les tests, les boucles, etc.
La structure conditionnelle if permet de réaliser un test et d’exécuter
une instruction ou non selon le résultat de ce test. Sa syntaxe est la
suivante
:
Où test est une expression dont la valeur est booléenne ou entière.
Toute valeur non nulle est considérée comme vraie. Si le test est
vrai, l’opération est exécuté. Ce peut être une instruction ou un bloc
d’instructions :
Exemple 1:
Exemple 2:
If (test) opération1; else opération2;
Nous pouvons préciser ce que nous voulons si la condition n'est pas remplie en utilisant le mot-clé else. Sa forme est :
if (x == 100)
cout << "x is 100"; else
cout << "x is not 100";
La boucle for
La structure de contrôle for est l’une des plus importantes. Elle permet de réaliser toutes sortes de boucles et, en particulier, les boucles itérant sur les valeurs d’une variable de contrôle. Sa syntaxe est la suivante :
Ce type de boucle, permet de condenser :
• une initialisation ;
• une condition ;
• une incrémentation.
for (initialisation; test ; incrémentation) opération; {
int main() {
int compteur(0);
for (compteur = 0 ; compteur < 10 ; compteur++) {
cout << compteur << endl; } return 0; } Exemple : 0 1 2 3 4 5 6 7 8 9
La boucle while
while (condition)
{ }
Tout ce qui est entre accolades sera répété tant que la condition est vérifiée.
int main() {
int age(-1); // Nombre négatif pour pouvoir entrer dans la boucle
while (age < 0) {
cout << " Entrez votre age?" << endl; cin >> age;
}
cout << "Merci d'avoir indique un age correct. Vous avez " << age << " ans" << endl;
return 0; {
• Cette boucle est très similaire à la précédente, • Mais, la condition n'est testée qu'à la fin,
• Le contenu de la boucle sera toujours lu au moins une fois. do
{
Exemple : int main() { int age(0); do {
cout << "Entrez votre age?" << endl; cin >> age;
} while (age < 0);
cout << "Merci d'avoir indique un age correct. Vous avez " << age << " ans " << endl;
return 0; }
Enoncé
Ecrire un programme qui calcule les racines carrées de nombres fournis en donnée. Il s’arrêtera lorsqu’on lui fournira la valeur 0. Il refusera les valeurs négatives. Son exécution se présentera ainsi :
donnez un nombre positif : 2 Sa racine carrée est : 1.414214 donnez un nombre positif : -1 svp positif
donnez un nombre positif : 5 sa racine carrée est : 2.236068 donnez un nombre positif : 0
Rappelons que la fonction sqrt fournit la racine carrée (double) de la valeur (double) qu’on lui donne en argument
TOUHTOUH Samira
Ecole Nationale des Sciences Appliquées d’El Jadida
Un langage de programmation
• La puissance d’un ordinateur vient du fait qu'il peut être programmé, c'est à dire que l'on peut lui donner, à l'avance, la séquence des ordres à
effectuer l'un après l'autre.
• Ces ordres, codés en binaire, sont sauvés dans un fichier nommé « exécutable » (.exe sous Windows).
• L'ordinateur ne comprenant que des ordres codés en binaire (le langage machine) peu pratiques d'emploi, des langages dits "évolués" ont été mis au point pour faciliter la programmation.
• Le C a été développé conjointement au système d'exploitation UNIX, dans les Laboratoires BELL, par Brian W Kernigham et Dennis M Ritchie, qui ont
défini en au cours des années 70, dans "The C Language", les règles de base de ce langage.
• Le but principal était de combiner une approche structurée (et donc une programmation facile) avec des possibilités proches de celles de l'assembleur tout en restant standard (c'est à dire pouvoir être implanté sur n'importe quelle machine).
• A la fin des années 80, Bjarne Stroustrup crée le C++, qui garde toutes les
possibilités du C, l'améliorant (commentaires, constantes, passage
d'arguments par adresse, arguments par défaut...) mais surtout en y ajoutant les objets (encapsulation, héritage, polymorphisme, surcharge...).
• Le C++ combine donc toutes les possibilités de la programmation
«classique» et la puissance de l'approche «objets».
• Il est très répandu, il fait partie des langages de programmation les plus utilisés sur la planète.
• Il est portable : un même code source peut théoriquement être transformé sans problème en exécutable sous Windows,
• Il existe de nombreuses bibliothèques pour le C++. Les bibliothèques sont des extensions pour le langage. De base, le C++ ne sait pas faire grand chose mais, en le combinant avec de bonnes bibliothèques, on peut créer des
programmes 3D, réseaux, audio, fenêtrés, etc.
• Il est multi paradigmes . Ce mot signifie qu'on peut programmer de différentes façons en C++ (POO).
• C'est un langage assez éloigné du binaire (et donc du fonctionnement de la machine), qui vous permet généralement de développer de façon plus
souple et rapide.
Un langage du bas niveau :
• Par opposition, un langage de bas niveau est plus proche du
fonctionnement de la machine : il demande en général un peu plus d'efforts mais vous donne aussi plus de contrôle sur ce que vous faites.
Une fois trouvé l’algorithme, programmer en C++ comporte 3 phases:
1. Editer le programme avec un éditeur de texte. 2. Compiler le programme .
3. Exécuter le programme. 4. TESTER et DEBUGGER
#include <iostream>
using namespace std;
int
main()
{
cout << “
Bonjour
" << endl;
return 0;
• iostream signifie « Input Output Stream », ce qui veut dire« Flux
d'entrée-sortie ». Dans un ordinateur , l'entrée correspond en général au
clavier ou à la souris, et la sortie à l'écran.
• Include iostream nous permet d'obtenir tout ce qu'il faut pour échanger des informations avec l'utilisateur .
• Il indique la partie de fonctionnalité que le fichier va utiliser.
• Dans la cas ou on charge plusieurs bibliothèques, Certaines fonctionnalités ont le même nom.
• Pour orienter l’ordinateur vers la fonction recherchée , namespace a été crée. Ce sont de dossiers à noms. La ligne using namespace std; indique qu’on va utiliser l’espace de noms std dans la suite du fichier code.
• C'est le cœur du programme. Les programmes, sont essentiellement
constitués de fonctions. Chaque fonction a un rôle et peut appeler d'autres fonctions pour effectuer certaines actions.
• Tous les programmes possèdent une fonction dénommée « main » qui est la fonction principale.
• Une fonction a la forme suivante : Int main ()
{ }
•
Le rôle de cout est d’afficher un message à l’écran.
•
cout est fourni par iostream. Si on inclut pas iostream au début du
programme, le compilateur ne va connaître cout
• Exemple
Il ya 3 éléments sur cette ligne :
cout
: commande l’affichage d’un message à l’écran;
‘’bonjour » : indique le message à afficher;
endl
: crée un retour à la ligne dans la console.
Il est possible de combiner plusieurs messages en une instruction :
La dernière ligne est :
Return 0;
Cette instruction clôt généralement les fonctions. La plupart des
fonctions renvoient une valeur. La fonction main renvoie 0 pour
indiquer que tout s’est bien passé
• En plus du code qui donne des instructions à l'ordinateur , il faut écrire des commentaires pour expliquer le fonctionnement de votre programme.
• Les commentaires n'ont aucun impact sur le fonctionnement de votre logiciel : en fait, le compilateur ne les lit pas et ils n'apparaissent pas dans le
programme généré. Pourtant, ces commentaires sont indispensables pour expliquer ce qu'il fait un programme.
Les commentaires courts
Pour écrire un commentaire court, sur une seule ligne, il suffit de commencer par // puis d'écrire votre commentaire.
// commentaire
Les commentaires longs
Si le commentaire tient sur plusieurs lignes, on ouvre la zone de commentaire avec /* et on ferme avec */
#include <iostream> using namespace std; int main() {
cout << “Bonjour!" << endl; return 0;
using namespace std ; /* spécifie que l’on utilise l’espace de nommage standard */
int main ( ) // début du programme = fonction main
{ // ouverture de la fonction principale
cout << "Bonjour" << endl ; // instructions terminées par ;
• Une variable est un identificateur qui désigne un type d’information dans un programme. Elle est située dans un endroit précis de la mémoire de la machine et représente souvent une donnée élémentaire, c’est-à-dire une valeur numérique ou un caractère.
• Les types de données de base sont les suivants : - int : valeur entière
- char : caractère simple
- float : nombre réel en virgule flottante
TYPE NOM (VALEUR);
TYPE NOM = VALEUR;
• L’identificateur d’une variable est composé d’un ensemble de chiffres ou de lettres dans un ordre quelconque qui suit les règles suivantes :
- Le premier caractère doit être obligatoirement une lettre.
- Les minuscules ou les majuscules sont autorisées et considérées comme différentes.
• Quand aucune valeur n’a encore été affectée à une variable, seule sa place est réservée. Son contenu n’étant pas encore défini, il viendra
ultérieurement.
• Au cours de la rédaction d’un programme, une variable peut être déclarée à tout moment, toutefois, les développeurs ont pour habitude de regrouper les déclarations, ce qui apporte une meilleure lisibilité.
• Il est possible d’initialiser une variable lors de sa déclaration comme dans :
int n = 15 ;
• Ici, pour le compilateur, n est une variable de type int dans laquelle il placera la valeur 15 ;
• La déclaration précédente pourrait être remplacée par une déclaration ordinaire (int n), suivie un peu plus loin d’une affectation (n=15) ; la seule différence résiderait dans l’instant où n recevrait la valeur 15.
• Il est possible de déclarer que la valeur d’une variable ne doit pas changer lors de l’exécution du programme. Par exemple, avec : const int n = 20 ;
• Comme tous les langages, C++ dispose d’opérateurs classiques « binaires »,
à savoir l’addition (+), la soustraction (-), la multiplication (*) et la division (/), ainsi que d’un opérateur « unaire » (c’est-à-dire ne portant que sur un seul opérande).
• Les opérateurs binaires ne sont a priori définis que pour deux opérandes ayant le même type parmi : int, long int, float, double et long double.
• Lorsque, les deus opérandes sont de type différent, le compilateur prévoit une conversion suivant l’ordre : char > short > long > float > double,
• Le plus petit est automatiquement transformé dans le plus grand,
float x=1,y=2;
Quelle est la valeur affectée aux différentes variables concernées par
chacune des instructions suivantes ?
b=7/b;
x=7/b;
x=7/y; x=7.0/b;
x=((float)(a+1))/b;
TOUHTOUH Samira
Ecole Nationale des Sciences Appliquées d’El Jadida
L’adresse d’une variable,
Lorsque une variable est déclarée, l’ordinateur réserve une place
dans la mémoire et lui donne une étiquette qui porte le nom de la
variable.
int main()
{
int a (2);
return 0;
}
La mémoire d’un ordinateur est constitué de plusieurs milliards de
cases. Chaque case a une adresse unique.
On peut accéder à une variable par deux méthodes :
- On peut passer par son nom (l'étiquette).
- On peut aussi accéder à la variable grâce à son adresse (son
numéro de case).
le symbole pour obtenir l'adresse d'une variable est l'esperluette (&)
Exemple :
#include <iostream> using namespace std; int main() { int a (2);cout << "L'adresse est : " << &a << endl; return 0;
Un pointeur est une variable qui contient l'adresse d'une
autre variable.
Un pointeur est une variable comme int et double.
Déclarer un pointeur
int *pointeur;
Pour déclarer un pointeur il faut un nom et un type.
-
Le nom et celui du variable
double *pointeurA;
//Un pointeur qui peut contenir l'adresse d'un nombre à
virgule
string *pointeurC;
//Un pointeur qui peut contenir l'adresse d'une chaîne de
Caractères
int const *pointeurE;
valeur 0
int *pointeur(0);
double *pointeurA(0);
string *pointeurC(0);
int const *pointeurE(0);
int main()
{
int a (2);
//Une variable de type int
int *ptr(0);
//Un pointeur pouvant contenir l'adresse d'un nombre entier
ptr = &a;
//On met l'adresse de 'a' dans le pointeur 'ptr'
return 0;
}
#include <iostream>
using namespace std;
int main()
{
int a(16);
int *ptr(0);
ptr = &a;
cout << "L'adresse de 'a' est : " << &a << endl;
cout << "La valeur de pointeur est : " << ptr << endl;
return 0;
int main()
{
int a(2);
int *ptr(0);
ptr= &a;
cout << "La valeur est : " << *ptr << endl;
return 0;
Lors de la déclaration d’une variable
I' ordinateur réserve une case mémoire, on parle de
l’allocation de la mémoire.
Il remplit cette case avec la valeur fournie, initialisation
int *pointeur(0);
pointeur = new int;
Une fois allouée manuellement, la variable s'utilise comme
n'importe quelle autre. On doit juste se rappeler qu'il faut y
accéder par le pointeur , en le déréférençant.
int *pointeur(0);
pointeur = new int;
*pointeur = 2; //On accède à la case mémoire pour en modifier la
valeurint *pointeur(0);
pointeur = new int;
Quels résultats fournira ce programme :
#include <iostream>
using namespace std ;
main()
{
char * ad1 ;
ad1 = "bonjour" ;
cout << ad1 << "\n" ;
ad1 = "monsieur" ;
cout << ad1 ;
}
#include <iostream>
using namespace std ;
main()
{
char * adr = "bonjour" ; /* 1 */
int i ;
for (i=0 ; i<3 ; i++) cout << adr[i] ; /* 2 */
cout << "\n" ;
i = 0 ;
while (adr[i]) cout << adr[i++] ; /* 3 */
}
L'en-tête fstream
Pour les fichiers, il faut spécifier #include <fstream>
en-haut de notre code source.
Ouvrir un fichier en écriture
Les flux sont des objets, qui contiennent des
informations concernant les fichiers.
Ils offrent beaucoup de fonctionnalité comme fermer et
#include <iostream>
#include <fstream>
using namespace std;
int main()
{
ofstream monFichier("C:/Document/fichier.txt");
//Déclaration d'un flux permettant d'écrire dans le fichier
return 0;
}
fonction c_str() lors de l'ouverture du fichier .
string const nomFichier("C:/Nanoc/scores.txt");
ofstream monFlux(nomFichier.c_str());
est plein par exemple.
ofstream monFlux("C:/Nanoc/fichier.txt");
//On essaye d'ouvrir le fichierif(monFlux) //On teste si tout est OK
{
//Tout est OK, on peut utiliser le fichier
}
else
{
cout << "ERREUR: Impossible d'ouvrir le fichier." << endl;
}
Pour pouvoir écrire à la fin d'un fichier , il faut le
spécifier lors de l'ouverture en ajoutant un deuxième
paramètre à la création du flux :
Ouvrir un fichier en lecture…
Utiliser un ifstream au lieu d'un ofstream
ifstream monFlux("C:/Nanoc/C++/fichier.txt");
//Ouverture d'un fichier en lectureif(monFlux)
{
//Tout est prêt pour la lecture.
}
else
{
cout << "ERREUR: Impossible d'ouvrir le fichier en lecture." <<
endl;
