C++ et éléments finis Note de cours de DEA (version provisoire)

8 CHAPITRE 1. QUELQUES ÉLÉMENTS DE SYNTAXE
1.1 Les déclarations du C++
Les types de base du C++ sont respectivement: char, short, int, long, long long, float, double,
plus des pointeurs, ou des références sur ces types, des tableaux, des fonctions sur ces types. Le tout nous
donne une algèbre de type qui n’est pas triviale.
Voilà les principaux types généralement utilisé pour des types T,U:
déclaration Prototypage description du type en français
T * a T * un pointeur sur T
T a[10] T[10] un tableau de T composé de 10 variable de type T
T a(U) T a(U) une fonction qui a U retourne un T
T &a T &a une référence sur un objet de type T
const T a const T un objet constant de type T
T const * a T const * un pointeur sur objet constant de type T
T * const a T * const un pointeur constant sur objet de type T
T const * const a T const * const un pointeur constant sur objet constant
T * & a T * & une référence sur un pointeur sur T
T ** a T ** un pointeur sur un pointeur sur T
T * a[10] T *[10] un tableau de 10 pointeurs sur T
T (* a)[10] T (*)[10] un pointeur sur tableau de 10 T
T (* a)(U) T (*)(U) un pointeur sur une fonction U →T
T (* a[])(U) T (*[])(U) un tableau de pointeur sur des fonctions U→T
...
Remarque il n’est pas possible de construire un tableau de référence car il sera impossible à initialiser.
Exemple d’allocation d’un tableau data de ldata pointeurs de fonctions de R à valeur dans R:
R (**data)(R) = new (R (*[ldata])(R)) ;
ou encore avec déclaration et puis allocation:
R (**data)(R) ; data = new (R (*[ldata])(R)) ;
1.2 Quelques règles de programmation
Malheureusement, il est très facile de faire des erreurs de programmation, la syntaxe du C++ n’est pas
toujours simple à comprendre et comme l’expressibilité du langague est très grande, les possibilités d’erreur
sont innombrables. Mais avec un peu de rigueur, il est possible d’en éviter un grand nombre.
La plupart des erreurs sont dû à des problèmes de pointeurs (débordement de tableau, destruction multiple,
oublie de destruction), return de pointeur sur des variable locales.
Voilà quelques règles a respecté.
Régle 1 (absolue) : dans une classe avec des pointeurs et avec un destructeur, il faut que les deux opérateurs
de copie (création et affection) soient définis. Si vous considérez que ces deux opérateurs ne doivent pas
exister alors les déclarez en privé sans les définir.
class sans_copie { public:
long * p ; // un pointeur
. . .
sans_copie() ;
˜sans_copie() { delete p ;}
private:
sans_copie(const sans_copie &) ; // pas de constructeur par copie
void operator=(const sans_copie &) ; // pas d’affection par copie
} ;
Dans ce cas les deux opérateurs de copies ne sont pas programmer pour qu’une erreur à l’édition des liens
soit généré.
class avec_copie { public:
long * p ; // un pointeur
˜avec_copie() { delete p ;}