MINISTERE DE L’ENSEIGNEMENT SUPERIEUR
ET DE LA RECHERCHE SCIENTIFIQUE
UNIVERSITE DE SOUSSE
Ecole Polytechnique de Sousse
Département Informatique
COURS C++
Section : 2ème Année Licence GL
ENSEIGNANT :
Kaies BEN SALAH
---Année Universitaire 2022-2023---
CH1
Apports syntaxiques de
C++ par rapport au C
ème
2 Année Licence GL
Kais ben Salah
2
\s
Apports syntaxiques de C++ par rapport au C
Dans ce premier chapitre sont exposés les «plus» et les différences du C++ par
rapport au C, sans toutefois aborder la programmation orientée objet (P.O.O.)
qui sera vue lors d’un prochain chapitre.
1- Commentaire
En C En C++
/* Un commentaire sur plusieurs ligne */ /* Un commentaire sur plusieurs lignes */
//Commentaire sur une seule ligne
Exemple
int main()
{ //déclaration
int i ;
…
return 0;
}
3
{
Apports syntaxiques de C++ par rapport au C
[Link] de constantes
◼En C++ les déclarations suivantes sont acceptées.
Exemple :
#define PI 3.14
#define PI2 3.14 * 3.14
…
float x = PI;
Remarque. En utilisant le mot clé const on peut définir des
variables constantes
Exemple :
#define M 10 //ok C/C++
const int maxarray = 255; //ok C/C++
int T [maxarray]; // Ok C++ et C
4
Apports syntaxiques de C++ par rapport au C
3. Types fondamentaux
❑ Booléen
o bool
o deux valeurs constantes de type bool : true et false
❑ Entiers de tailles différentes
o char (1 octet)
o short int ou short (2 octets)
o int (2 ou 4 octets)
o long int ou long (4 ou 8 octets)
❑ Valeurs en virgule flottante
o float (4 octets)
o double (8 octets)
o long double (10 ou plus octets)
❑ Entiers positifs
o unsigned char
o unsigned short
o unsigned int
o unsigned long 5
Apports syntaxiques de C++ par rapport au C
4. Déclaration de variables
❑ En C++, on peut déclarer les variables LOCALES au moment où on en a
besoin.
❑ Si une variable locale est déclarée au début d’un bloc, sa portée est
limitée à ce bloc.
Exemple
int main()
{
for ( int i = 0;i<10;i++ ) // la variable i est connue de toute la fonction main()
{ int j; // la variable j n’est connue que du bloc
…….;
….....;
}
return 0;
}
6
Apports syntaxiques de C++ par rapport au C
5. Les nouvelles possibilités d’Entrées/Sorties
❑ On peut utiliser en C++ les fonctions d’entrées/sorties classiques du C
(printf, scanf, puts, gets, putc, getc ...), à condition de déclarer le fichier
d’en-tête stdio.h.
❑ Il existe de nouvelles possibilités en C++, à condition de déclarer le
fichier d’en-tête iostream.h.
❑ Ces nouvelles possibilités ne nécessitent pas de FORMATAGE des
données
7
Apports syntaxiques de C++ par rapport au C
Exemple
C #include <stdio.h>
int value = 10;
printf("value = %d\n", value );
printf("donner un entier= " );
scanf("%d", &value );
printf("La nouvelle de value = %d\n", value );
C++ #include <iostream>
using namespace std;
int value = 10;
cout << "Value = "<< value << endl;
cout << “Donner un entier : ";
cin >> value;
cout << "La nouvelle de value = "<< value << endl;
8
Apports syntaxiques de C++ par rapport au C
Exemple
Écrire un programme C++ qui permet la saisie de deux entiers A et B.
Calculer puis afficher leur somme et leur produit.
#include <iostream>
using namespace std;
int main()
{
int A, B;
cout<<"donner A= ";
cin>> A;
cout<<"donner B= ";
cin>> B;
cout<< "la somme de A et B = "<<A+B<< endl;
cout<< "le produit de A et B = "<<A*B<< endl;
return 0;
} 9
Apports syntaxiques de C++ par rapport au C
6. Les conversions de type
Le C++ autorise les conversions de type entre variable de type :
char <--> int <--> float <--> double
Exemple #include<iostream>
using namespace std;
void f(int a , int b)
{
cout << "a="<<a << endl;
cout << "b="<<b << endl;
}
int main()
{
float a=25.2 ;
int b=2 ; Résultats
f(a, b) ; a=25
return 0; b=2
} 10
Apports syntaxiques de C++ par rapport au C
7- Les arguments par défaut
En C++ on peut préciser la valeur prise par défaut par un argument d’une
fonction.
Lors de l’appel à cette fonction, si on ne met pas l’argument, il prendra la
valeur par défaut, dont le cas contraire, la valeur par défaut est ignorée.
Exemple
#include<iostream>
using namespace std;
void f1(int n = 3) // par défaut le paramètre n vaut 3
{
cout << "Dans F1 n="<<n << endl;
}
void f2(int n, float x = 2.35) // par défaut le paramètre x vaut 2.35
{
cout << "Dans F2 n="<<n << endl;
cout << "Dans F2 x="<<x << endl;
} 11
Apports syntaxiques de C++ par rapport au C
void f3(char c, int n = 3, float x = 2.35) // par défaut le paramètre n vaut 3
{ // et le paramètre x vaut 2.35
cout << "Dans F3 c="<<c << endl;
cout << "Dans F3 n="<<n << endl;
cout << "Dans F3 x="<<x << endl;
}
int main()
{ char a = 0; int i = 2; float r = 5.6;
f1(i); // l’argument n vaut 2, l’initialisation par défaut est ignorée
f1(); // l’argument n prend la valeur par défaut
f2(i,r); // les initialisations par défaut sont ignorées
f2(i); // le second paramètre prend la valeur par défaut
// f2(); interdit
f3(a, i, r);// les initialisations par défaut sont ignorées
f3(a, i); // le troisième paramètre prend la valeur par défaut
f3(a); // le 2ème et le 3ème paramètres prennent les valeurs par défaut
return 0;
}
12
Apports syntaxiques de C++ par rapport au C
Résultats Dans F1 n=2
Dans F1 n=3
Dans F2 n=2
Dans F2 x=5.6
Dans F2 n=2
Dans F2 x=2.35
Dans F3 c=
Dans F3 n=2
Dans F3 x=5.6
Dans F3 c=
Dans F3 n=2
Dans F3 x=2.35
Dans F3 c=
Dans F3 n=3
Dans F3 x=2.35 13
Apports syntaxiques de C++ par rapport au C
Remarque
Les arguments dont les valeurs sont définit par défaut doivent
obligatoirement situées à la fin de la liste des arguments.
Exemple :
void f1(int x, int n=3){…}//ok
void f2 (int n=2, float x) {…}//erreur
void f3(char a, int b=2, float c){...}//erreur
//correction de f2 et f3
void f2 (float x, int n=2) {…}//ok
void f3(char a, float c, int b=2){...}//ok
14
Apports syntaxiques de C++ par rapport au C
8. La sur définition d’une fonction
Le C++ autorise la définition de fonctions différents et portant le même
nom à condition de les différencies par le type des arguments.
Exemple
#include<iostream>
using namespace std;
void test (int n=0, float x=2.3)
{
cout<<"fonction 1 avec n="<<n<<" et x= "<<x <<endl;
}
void test (float x=3.4, int n=5)
{
cout<<"fonction 2 avec n="<<n<<" et x= "<<x<<endl;
}
15
Apports syntaxiques de C++ par rapport au C
int main()
{
int i=3 ; float n=3.3 ;
test(i, n) ; //appel f1
test(n, i) ; //appel f2
test(i) ; //appel f1
test(n) ; //appel f2
//test(); erreur dans ce cas
return 0;
}
Résultats
fonction 1 avec n=3 et x= 3.3
fonction 2 avec n=3 et x= 3.3
fonction 1 avec n=3 et x= 2.3
fonction 2 avec n=5 et x= 3.3
16
Apports syntaxiques de C++ par rapport au C
9. Les opérateurs new et delete
Les 2 opérateurs new et delete remplacent les fonctions de gestion
dynamique de la mémoire malloc et free. Ils permettent donc de réserver
et de libérer une place mémoire.
Exemple 1 en C/C++ :
int *p1 , *p2 ;
p1=(int *) malloc (sizeof(int));
p2=(int *) malloc (50*sizeof(int));
…
free(p1) ;
free(p2) ;
17
Apports syntaxiques de C++ par rapport au C
Exemple 2 en C/C++ :
int *pi; float *pr ;
pi=new int; //Réservation en mémoire pour un entier
pr= new float[50]; //Réservation en mémoire pour 50 Réels
…
delete pi;
delete pr;
Remarque:
Il ne faut pas utiliser conjoignaient malloc et delete ou new et free
18
Apports syntaxiques de C++ par rapport au C
10. Notion de référence
En C l’operateur & désigne l’adresse, en C++ il peut désigner soit
l’adresse soit une référence selon le contexte. Seul le contexte de
programme permet de déterminer s’il s’agit d’une référence ou d’une
adresse.
Exemple #include<iostream>
using namespace std;
int main()
{
int n=3 ;
int &p=n ; //p et n ont la même @ mémoire
cout<< "n= "<< n <<endl;// affiche 3
cout<< "p ="<< p <<endl;// affiche 3
return 0;
}
19
Apports syntaxiques de C++ par rapport au C
11- Passage de paramètres par référence
En C un sous-programme ne peut modifier la valeur d’une variable local
passée en argument d’une fonction que si on passe l’adresse de cette
variable.
Exemple en C++
#include<iostream>
using namespace std; int main()
//Passage par Valeur {
int x=2, y=3 ;
void permutation( int a, int b)
cout<<"Avant appel x="<< x <<" y="<<y<<endl;
{ int c ;
permutation(x,y) ;
c=a ; cout<<"Apres appel x="<< x <<" y="<<y<<endl;
a=b ; return 0;
b=c ; }
}
Résultats
Avant appel x=2 y=3
Apres appel x=2 y=3 20
Apports syntaxiques de C++ par rapport au C
En C un sous-programme ne peut modifier la valeur d’une variable local
passée en argument d’une fonction que si on passe l’adresse de cette
variable.
Exemple
#include<iostream>
using namespace std; int main()
//Passage par Adresse {
void permutation(int *a,int *b) int x=2, y=3 ;
cout<<"Avant appel x="<< x <<" y="<<y<<endl;
{ int c ;
permutation(&x, &y) ;
c = *a ; cout<<"Apres appel x="<< x <<" y="<<y<<endl;
*a = *b ; return 0;
*b = c ; }
}
Résultats
Avant appel x=2 y=3
Apres appel x=3 y=2 21
Apports syntaxiques de C++ par rapport au C
Remarque : !! En C++ on préfère d’utiliser le passage par référence qui
passe par adresse.
Exemple en C++ :
#include<iostream>
using namespace std; int main()
//Passage par Réference {
void permutation(int &a,int &b) int x=2, y=3 ;
cout<<"Avant appel x="<< x <<" y="<<y<<endl;
{ int c ;
permutation(x, y) ;
c=a; cout<<"Apres appel x="<< x <<" y="<<y<<endl;
a=b; return 0;
b=c; }
}
Résultats
Avant appel x=2 y=3
Apres appel x=3 y=2 22
Les Classes
1. Introduction
❑ Les entités du monde réel sont généralement assez complexes et ne
peuvent être convenablement représentées dans les programmes a
l'aide des types scalaires. Il faut leur construire de nouveaux types
qui leurs sont adaptés.
❑ C++ met a la disposition des programmeurs un ensemble d'outils de
construction de tels types. Comme exemple de ces outils, il est
possible de citer :
✓ Les tableaux pour la représentation des ensembles d’éléments
de même type.
✓ Les structures pour la representation des entités complexes
comportant plusieurs champs.
23
Les Classes
Exemple
#include <iostream>
typedef struct
{
int jour, mois, annee;
} Date;
Date Saisir()
{
Date D;
cout<<"Donnez le jour :";
cin>>[Link];
cout<<"Donnez le mois :";
cin>>[Link];
cout<<"Donnez l'année :";
cin>>[Link];
return D;
}
24
Les Classes
void Afficher(Date D) Exécution
{ Donnez le jour :11
cout<<[Link]<<'/'<<[Link]<<'/'<<[Link]<<endl;
Donnez le mois :12
}
Donnez l’annee :2021
int main() Donnez le jour :3
{ Donnez le mois :3
Date D1,D2; Donnez l’annee :2022
D1 = Saisir(); ***** DATE 1 *****
D2 = Saisir(); 11/12/2021
cout<<"***** DATE 1 *****"<<endl; ***** DATE 2 *****
Afficher(D1); 3/3/2022
cout<<"***** DATE 2 *****"<<endl;
Afficher(D2);
return 0;
}
25
Les Classes
2. Les Classes
❑ Les deux fonctions utilisées dans le programme précédent ainsi que
la structure Date constituent des modules explicitement distincts
même si sur le plan sémantique ils sont implicitement liés.
❑ En effet les deux fonctions Saisir et Afficher s'appliquent
essentiellement à une structure de type Date.
❑ Il sera donc intéressant de définir une structure de données qui les
regroupe en une seule entité.
❑ C++ introduit un nouvel outil de construction de type de données,
appelé classe, qui étend les possibilités des structures.
26
Les Classes
Une classe est un type réunissant :
❑ Une collection de données membres appelées attributs.
❑ Une collection de fonctions membres appelées méthodes et servant
à faire des traitements sur les données membres.
CLASSE
27
Les Classes
3. Définition d’une classe
La définition d'une classe désigne la spécification des attributs et des
méthodes de la classe.
Règles syntaxiques de la définition :
❑ La définition commence par le mot-clé class.
❑ Ensuite, il y a lieu de déclarer les collections d'attributs et de
méthodes. Ces déclarations doivent être placées entre deux
accolades.
❑ La définition d'une classe se termine enfin par un point virgule.
Exemple :
class Date
{
int jour, mois, annee;
void Saisir();
void Afficher();
};
28
Les Classes
4. Instanciation d’une classe
❑ Une classe définit un nouveau type. De ce fait, il est possible de
déclarer des variables ou des constantes ayant un type classe.
❑ Ces variables et constantes sont appelées des objets ou des
instances de la classe.
❑ Le processus de création d’objets est appelé instanciation.
Exemple :
Date D; // D est un objet de type classe Date.
29
Les Classes
Remarque1: Déclaration des attributs d'une classe
❑ la définition d'une classe constitue un processus de définition de
type et non un processus de déclaration d'objet.
❑ De ce fait, il devient impossible d'initialiser un attribut au moment
de la définition d'une classe.
Exemple :
class A
{ ………
int i = 5; // Erreur
};
30
Les Classes
Remarque 2 : Type des attributs
❑ Les attributs peuvent être de n'importe quel type.
❑ Un attribut ne peut pas être du type de la classe à laquelle il
appartient
❑ Il est toutefois possible de déclarer un attribut de type pointeur
sur la classe à laquelle appartient cet attribut.
Exemple :
class A class A
{ ……… { ………
A pa; // Erreur A *pa; // OK
……… ………
}; };
31
Les Classes
5. Fonctions membres : méthodes
5.1. Déclaration d'une méthode
La déclaration des méthodes se fait suivant la même syntaxe que la
déclaration des fonctions classiques. Toutefois une méthode doit être
obligatoirement déclarée à l'intérieur d'une classe.
5.2. Définition d'une méthode
Il existe deux façons pour définir une méthode de classe :
Première façon :
Elle consiste à définir la méthode au sein même de la classe.
Exemple :
class Date
{
int jour, mois, annee;
void Saisir() {…………………}
void Afficher(){…………………}
};
32
Les Classes
Deuxième façon :
Elle consiste à :
❑ déclarer la fonction à l’intérieur de la classe,
❑ la définir ensuite à l’extérieur de la classe. Il faut pour cela indiquer
la classe d’origine de la fonction. Ceci se fait comme suit :
Syntaxe :
TypeRetour NomClasse :: Methode(type1 arg1,…, typeN argN);
❑ :: est l’opérateur de résolution de portée.
❑ NomClasse :: Methode est appelé le nom qualifié de la méthode.
33
Les Classes
Exemple :
class Date
{
int jour, mois, annee;
void Saisir();
void Afficher();
};
void Date::Afficher(){…………………} // Définition de Afficher
void Date::Saisir(){…………………} // Définition de Saisir
34
Les Classes
6. Encapsulation
❑ L'encapsulation est le mécanisme qui permet de regrouper les
données et les méthodes au sein d'une même structure (classe). Ce
mécanisme permet également à l'objet de définir le niveau de
visibilité de ses membres.
❑ Un membre visible est un membre qui est accessible à partir de
l'objet :
✓ Si le membre est un attribut alors l'accès concerne une opération
de lecture ou d'écriture de la valeur de cet attribut.
✓ Si le membre est une méthode alors l'opération d'accès consiste
en un appel de cette méthode.
35
Les Classes
6.1. Spécificateurs des droits d'accès des membres
En C++, la spécification des droits d'accès aux membres d'une classe se
fait à l'aide des trois mots-clés suivants : public, private et protected.
❑ public : le spécificateur public rend les membres d’une classe X
(attributs ou méthodes) accessibles en dehors de la classe.
❑ private : le spécificateur private restreint l’accès aux membres de la
classe (attributs et méthodes) aux méthodes de la classe
seulement.
❑ protected : protected : les accès sont autorisés dans les fonctions de
la classe et de ses descendantes (voir le chapitre d’héritage)
seulement.
Remarque1. Le mot clé protected n'est utilisé que dans le cadre de
l'héritage des classes.
36
Les Classes
Remarque 2 :
Il est possible d’utiliser au sein d’une même classe différents
spécificateurs d’accès. Ainsi, il est possible de rendre une partie de la
classe publique, et de cacher une autre partie en la qualifiant de privée.
6.2. Portée d’un spécificateur d’accès :
La portée d’un spécificateur d’accès s'étend depuis l'endroit de sa
définition jusqu'à la rencontre de la définition d'un autre spécificateur.
class X class X
{ {
private : public :
int a1; int a1;
char a2; void f1();
public : private :
void f1(); char a2;
int f2(double k); int f2(double k);
}; };
37
Les Classes
Remarque : Spécificateur d'accès par défaut
Si aucun spécificateur d’accès n’a été défini dans une classe alors les
membres de cette dernière sont qualifiés par défaut comme étant privés.
Exemple :
class X
{
int a1;
char a2;
void f1();
int f2(double k);
};
Tous les membres de la classe X sont considérés par défaut comme étant
privés.
38
Les Classes
7. Accès aux membres d'une classe
7.1. Accès de l'intérieur de la classe
❑ Les membres d'une classe sont locaux. Leur portée est définie par la
classe dans laquelle ils sont déclarés.
❑ Tout membre d'une classe est visible par les autres membres de cette
classe sans aucune considération des spécificateurs d'accès (public,
private, protected).
❑ Les attributs d’une classe sont considérés comme des variables
globales par rapport aux méthodes de cette classe. Tout attribut peut
par conséquent être utilisé par n'importe quelle méthode de sa classe.
❑ Une méthode d'une classe peut être appelée par toute autre méthode
de sa classe indépendamment de l'ordre de déclaration de ces
dernières dans la classe.
❑ Les membres peuvent être manipulés directement par leurs noms
sans avoir besoin d'aucune qualification.
39
Les Classes
Exemple :
Le fichier « DATE.h »
#ifndef DATE_H_INCLUDED
#define DATE_H_INCLUDED
class Date
{
int jour, mois, annee;
public:
void Saisir();
void Afficher();
};
#endif // DATE_H_INCLUDED
40
Les Classes
Le fichier « [Link] »
#include <iostream>
#include "DATE.h"
using namespace std;
void Date::Saisir()
{
cout<<"Donner le jour , mois et l'annee : ";
// Accès direct aux attributs par la méthode Saisir
cin>>jour>>mois>>annee;
}
void Date::Afficher()
{
cout<<jour<<'/'<<mois<<'/'<<annee<<endl;
}
41
Les Classes
Le fichier « [Link] »
#include <iostream>
#include "DATE.h"
using namespace std;
int main()
{
Date D1 , D2;
cout<<"SAISIE DE D1\n";
[Link]();
cout<<"SAISIE DE D2\n";
[Link]();
cout<<"DATE 1\n";
[Link]();
cout<<"DATE 2\n";
[Link]();
return 0;
}
42
Les Classes
7.2. Accès de l'extérieur de la classe
❑ L'utilisation d'un membre d'une classe en dehors de cette dernière
se fait généralement à partir d'une instance.
❑ Le membre doit être associé à l'objet auquel il appartient. Cette
association se fait à l'aide de l'opérateur « point » de la manière
suivante :
✓ Pour les attributs : [Link];
✓ Pour les méthodes : [Link](Paramètres effectifs);
❑Seuls les membres publics peuvent être accédés de l'extérieur d'une
classe. Les autres membres (private et protected) ne sont pas
accessibles de l'extérieur.
43
Les Classes
Exemple : class Date
{
int jour, mois;
public:
int annee ;
void Saisir();
void Afficher();
};
void main()
{
Date D; void main()
[Link] = 5; // Erreur {
[Link] = 10; // Erreur Date D;
[Link] = 2004; // OK [Link](); // OK
cout<<[Link]; // Erreur [Link](); // OK
cout<<[Link]; // Erreur }
cout<<[Link]; // OK
} 44
