5.1 INTRODUCTION
C++ langage de programmation orienté objet
Le langage C++ a été crée par Bjarne Stroustrup pour intégrer les concepts de programmation objet dans le langage C à savoir :
puissance des langages orientés objets,
typage basé sur la définition de classes, d'instances et de méthodes,
définition de méthodes constructeur et destructeur,
prise en compte de l'héritage, simple ou multiple,
définition d'objets génériques.
contrôle des erreurs d'exécution possible pour le programmeur à partir de la gestion des exceptions.
Le C++ est un des langages de programmation les plus utilisés actuellement. Très efficace et performant, il est complexe donc quelquefois difficile à interpréter même si la lisibilité des programmes dépend aussi du programmeur. Enfin, ce langage est, avec le C, idéal pour ceux qui doivent assurer la portabilité de leurs programmes sources.
Le langage procédural et fonctionnel C++
Les caractéristiques du langage C++, langage procédural et fonctionnel sont les suivantes :
performances similaires à celles du langage C,
extension des fonctionnalités du langage C comme la transmission par référence, la définition d'arguments par défaut,
portabilité des fichiers sources,
contrôle d'erreur à la compilation basé sur un typage très fort.
Compatibilité C et C++
La syntaxe du langage C++ est compatible sur celle du C tout en évitant d'utiliser certaines de ses fonctionnalités grammaticalement douteuses.
Le langage C++ peut donc être considéré comme un sur-ensemble du langage C, certains programmes C devant être adaptés avec des modifications minimes.
5.2 COMMENTAIRE
Le délimiteur // permet d'insérer des commentaires dans le programme, en particulier à la droite d’une instruction.
Exemple
int valeur; // Ceci est un entier
5.3 TYPES
Types de base
On retrouve les types de base traditionnels du langage C, avec quelques évolutions : void;
unsigned char, signed char;
short int, int; long int (unsigned),
unsigned short int, unsigned int; unsigned long int, float, double, long double (non implémenté);
enum;
Nommage des agrégats
Le nommage des agrégats évite de réutiliser les mots clés struct, class, union lors de l'instanciation des variables de classe.
Exemple
struct complexe {float reel; float imaginaire; };
complexe z; // et non struct complexe z;
Type booléen et énumération Type booléen prédéfini.
Définition de constante symbolique par énumération avec contrôle de valeur.
Exemple
enum Booleen {FAUX, VRAI }; // différent de l'instruction {VRAI, FAUX};
enum COULEUR {VERT=5, ROUGE, JAUNE=9 };
// ROUGE équivaut à 6 par défaut.
COULEUR couleur = ROUGE; // couleur initialisé à 6.
couleur = -7; // incorrect
Type intégral
char, wchar_t; // caractère, caractère long
short, int, long, enum;
Type flottant float, double;
Types arithmétiques Les deux types précédents.
Types dérivés
& opérateur de référence,
* opérateur de déréférenciation,
[] tableau,
() fonction,
const qualification d'un type, d'une variable ou du comportement d'une méthode, class, struct, union types agrégat définis par le programmeur,
.* sélecteur sur objet membre (donnée ou méthode),
-> sélecteur sur pointeur.
Le type void*
Le pointeur générique void* doit toujours explicitement être converti en un pointeur d'un type non générique.
5.4 SAISIE ET AFFICHAGE ÉLÉMENTAIRE EN C++
5.4.1 Opérateurs de base
Le langage C++ utilise les flots (streams), très souples, de préférence aux fonctions traditionnelles de la bibliothèque d'entrées/sorties du langage C :
scanf, printf, fscanf, fprintf, sscanf, sprints, gets, puts, fgets, fputs, getchar, putchar, etc…
Quatre flots sont initialisés au démarrage de l'exécution :
cin et l'opérateur associé >>
cout et l'opérateur associé <<
cerr et l'opérateur associé << (non bufferisé),
clog et l'opérateur associé << (bufferisé).
Les flots utilisent le fichier en tête iostream.h.
Saisie
L'opérateur cin permet d'éviter les erreurs de saisie dues à une mauvaise utilisation de la fonction scanf comme l'illustre l'exemple ci-dessous :
int i ;
scanf("%d", i); // horreur : sur un PC sous Windows, le plantage total est possible scanf("%d",&i); // correct mais les pointeurs arrivent
Le flot cin saisit en format libre des données d'un quelconque type prédéfini sans obligation de le spécifier. L'opérateur associé >> est par définition le délimiteur syntaxique des données à saisir.
Le séparateur des données saisies est représenté par un ou (ou non exclusif) plusieurs caractères d'espacement, de tabulation ou les deux. Le caractère CR (retour chariot) est également autorisé.
Affichage
Le flot cout affiche des données d'un type prédéfini en format libre.
L’éventuel texte d'accompagnement est délimité par deux ".
L'opérateur << précède les objets à imprimer.
L'impression s'effectue de la gauche vers la droite.
La fonction endl permet de gérer le passage à la ligne
Exemple 1
#include <iostream.h>
int main() {int a,b ;
cout << "Saisir a et b : "; // affichage du message de saisie en format libre cin >> a >> b; // saisie des variables a et b
cout << "a= " << a << "\tb= " << b << endl ; // affichage et passage à la ligne }
// résultat
Saisir a et b : 2 3 a= 2 b= 3 // résultat Saisir a et b : 2 3
a= 2 b= 3
Exemple 2
/* Fonction fact */
#include <iostream.h>
unsigned long fact(unsigned n) {return ((n>1) ? n*fact(n-1) : 1); } int main()
{int i =1 ; while (i)
{cout << "Entrez un nombre : ";
if (! (cin >> i) ) break;
cout << "fact(" << n << ") = << fact(n);
} }
Remarques
L’expression cin i, retourne i si la saisie s'est déroulée correctement, 0 sinon.
Affichage de données en format libre char c='a';
int i=17;
float f=4.2;
char *s="coucou";
char *v=s;
cout << c << ' ' << i << ' '<< f << '\t' << v << ':' << *v << endl;
// résultat
a 17 4.2 0x4ab2:coucou
5.4.2 Interprétation objet des entrées/sorties
Objet et traitement associé
En programmation orientée objet, les objets contrôlent les traitements par refus ou acceptation d'un message. Dans cette dernière situation, il déclenche le traitement correspondant à chaque message accepté.
En langage C++, un message résulte de l'utilisation d'un opérateur ou d'un appel de fonction.
Les méthodes cin et cout peuvent être considérées comme des objets opérant respectivement sur les flots de données (messages) stdin et stdout.
Exemple
#include <iostream.h> // définition des objets de base de gestion des flux standards int main()
{// exemples d'objets float PrixLu;
cout << "Prix hors taxes : ";
// l'opérateur cout opère sur le message (flux standard de sortie) stdout cin >> PrixLu; // l'objet (l'opérateur) cin traite un message cout << "Prix TTC : " << PrixLu*1.196 << endl ;
// l'opérateur cout traite trois messages consécutifs
cout.width(16); // un message peut aussi être un appel de méthode width() cout << PrixLu*1.196 << endl ;
cout.width(16); // méthode de facteur de cadrage sur 16 caractères
cout.fill('*'); // méthode remplissage dans la limite du facteur de cadrage cout << PrixLu*1.196 << endl ;
return(1);
}
// résultat
Prix hors taxes : 100 Prix TTC : 119.06 119.06
***********119.06
5.5 DÉFINITION ET INSTRUCTION EXÉCUTABLE
Contrairement au langage C, en langage C++, les définitions des objets sont des instructions exécutables ce qui permet de définir une variable à n'importe quelle instruction du programme.
Exemple
#include <iostream.h>
int main()
{int t[] = {7, 4, 2, 9, 3, 6, 1, 4}; // un tableau d'entiers de dimension incomplète for (int i=0; i<8; i++) cout<<t[i]; // définition de la variable entière i
cout <<endl ;
for (i=0; i<8; i++) cout<< t[i];
cout <<endl ; }
// résultats 7 4 2 9 3 6 1 4 7 4 2 9 3 6 1 4
Remarque
Dans cet exemple, les variables définies dans la boucle for ne doivent pas être redéfinies dans une boucle du même bloc.
5.6 DÉCLARATION ET DÉFINITION
Contrairement au langage C, l'ambiguïté entre définition et déclaration est interdite.
Déclaration
En langage C++, toute déclaration de variable globale doit comporter obligatoirement le mot-clef extern, contrairement au langage C ou les déclarations sont, selon les situations, facultatives (avec des choix par défaut) ou obligatoires.
Définition
Toute variable globale doit être définie explicitement une et une seule fois dans le programme et déclarée explicitement au moins une fois dans chaque fichier où elle est utilisée.
5.7 OPÉRATEURS SPÉCIFIQUES AU LANGAGE C++
En complément des opérateurs traditionnels du langage C, trois opérateurs ont été définis :
l'opérateur de résolution de visibilité ::, essentiel pour l'utilisation des structures et des classes,
l'opérateur d'allocation dynamique d'instances new, simple à utiliser, ne nécessitant pas de pointeur,
l'opérateur conjugué de libération de la mémoire delete.
Une nouvelle forme de transtypage (cast) est introduite : le transtypage par appel de fonction ou encore transtypage fonctionnel.
5.8 CARACTÉRISTIQUES D'UN FICHIER EN TÊTE
En C++, un fichier en tête (header) peut contenir :
des commentaires,
des déclarations de type, de constantes, de fonctions qualifiées inline (fonction en ligne),
des déclarations de données et de fonctions externes,
des types énumérés,
des directives d'inclusion,
des macro-définitions du préprocesseur (#define).
Il ne doit jamais contenir de définition de donnée, de fonction, d'agrégat de constantes.
5.9 LE SPÉCIFICATEUR CONST ET LES VARIABLES
Le spécificateur const qualifie tout type de variable pour indiquer qu'il doit rester constant après son initialisation.
Exemple
const char new_line = endl ;
const char * voyelles = "aeiouy"; // horreur du C reprise en C++
const char* format1 = "%4d\t%d << endl" ; const float pi = 3.14159265;
L'utilisation du mot clé const est une très bonne alternative à celle de l'utilisation de la directive du préprocesseur #define pour définir des constantes symboliques, la vérification de type étant effectuée dès la compilation.
En langage C++, la portée du qualificatif const est limitée au fichier courant.
5.10 COMPLÉMENT SUR LE TYPE STRUCT
Suppression de la nécessité de l’utilisation de l'instruction typedef
En C++, une instance d'une classe de type struct, union ou class est définie directement à partir de l'identificateur de la classe en omettant l'utilisation du mot clé struct, union ou class. Il n'est pas nécessaire d'utiliser le mot clé typedef du langage C.
Deux structures, même construites selon le même modèle abstrait, sont différentes.
Exemple
struct type1 {int a; int b;};
struct type2 {int a; int b;};
type1 s10, s11 type2 s20;
s11 = s10; // OK
s11 = s20; // erreur de type
Le qualificatif mutable
Cette classe de mémorisation n'existe qu'en C++.
Elle n'est utilisée que pour redéfinir les qualifications d'accès aux membres des structures.
Elle permet de passer outre la constance éventuelle d'une structure pour ce membre. Ainsi, un champ d’une structure qualifié mutable peut être modifié même si la structure est qualifiée const.
5.11 L'OPÉRATEUR DE RÉSOLUTION DE PORTÉE
Une des utilisations de l'opérateur unaire de résolution de portée :: est de démasquer un nom global masqué par un nom local.
Exemple
#include <iostream.h>
int x =1; // x variable globale int main()
{void f(); // prototype
cout << " x global " << x << endl ; f();
cout << " x global depuis la fonction main : " << x << endl ; }
void f()
{int x = 3; // masque le x global
cout << " x local avant affectation x global : " << x << endl ; ::x= 2; // affectation du x global
cout << " x local après affectation du x global : " << x << endl ; cout << " x global depuis f : " << ::x << endl ;
}
// résultats x global 1
x local avant affectation x global : 3 x local après affectation x global : 3 x global depuis f : 2
x global depuis la fonction main : 2