C++ 6ème cours Patrick Reuter maître de conférences

Aujourdhui Pointeurs Appel de fonctions

Les classes class Matrix2x2 {.. } –Définition : fichier en-tête Matrix2.2.h (avec les prototypes des méthodes/fonctions membres) –Implémentation : fichier source Matrix2x2.cpp (avec les implémentations des méthodes/fonctions membres)

#ifndef MATRIX2x2_H #define MATRIX2x2_H class Matrix2x2 { private: float _matrix[2][2]; public: // constructeur par defaut Matrix2x2(); // constructeur Matrix2x2(const float e00, const float e01, const float e10, const float e11); // destructeur par defaut ~Matrix2x2(); // Accès aux éléments float getElement(const unsigned int line, const unsigned int column) const; // Affecter les éléments void makeZero(); // Affecter les éléments void makeIdentity(); // Affecter les éléments void setElement( const unsigned int line, const unsigned int column, const float value); // Affecter les éléments void setElements( const float e00, const float e01, const float e10, const float e11); // Calculer le determinant float determinant() const; void afficher() const; Matrix2x2 addition (const Matrix2x2 matrix) const; Matrix2x2 operator+(const Matrix2x2 matrix) const; Matrix2x2 multiplication(const float k) const; Matrix2x2 operator*(const float k) const; }; #endif // define MATRIX_H Attributs ou propriétés Méthodes ou fonctions membres

#ifndef MATRIX2x2_H #define MATRIX2x2_H class Matrix2x2 { private: float _matrix[2][2]; public: // constructeur par defaut Matrix2x2(); // constructeur Matrix2x2(const float e00, const float e01, const float e10, const float e11); // destructeur par defaut ~Matrix2x2(); // Accès aux éléments float getElement(const unsigned int line, const unsigned int column) const; // Affecter les éléments void makeZero(); // Affecter les éléments void makeIdentity(); // Affecter les éléments void setElement( const unsigned int line, const unsigned int column, const float value); // Affecter les éléments void setElements( const float e00, const float e01, const float e10, const float e11); // Calculer le determinant float determinant() const; void afficher() const; Matrix2x2 addition (const Matrix2x2 matrix) const; Matrix2x2 operator+(const Matrix2x2 matrix) const; Matrix2x2 multiplication(const float k) const; Matrix2x2 operator*(const float k) const; }; #endif // define MATRIX_H Encapsulation private Propriétés et fonctions qui ne peuvent pas être accédées en dehors de la classe public Propriétés et fonctions peuvent être accédées en dehors de la classe

#ifndef MATRIX2x2_H #define MATRIX2x2_H class Matrix2x2 { private: float _matrix[2][2]; public: // constructeur par defaut Matrix2x2(); // constructeur Matrix2x2(const float e00, const float e01, const float e10, const float e11); // destructeur par defaut ~Matrix2x2(); // Accès aux éléments float getElement(const unsigned int line, const unsigned int column) const; // Affecter les éléments void makeZero(); // Affecter les éléments void makeIdentity(); // Affecter les éléments void setElement( const unsigned int line, const unsigned int column, const float value); // Affecter les éléments void setElements( const float e00, const float e01, const float e10, const float e11); // Calculer le determinant float determinant() const; void afficher() const; Matrix2x2 addition (const Matrix2x2 matrix) const; Matrix2x2 operator+(const Matrix2x2 matrix) const; Matrix2x2 multiplication(const float k) const; Matrix2x2 operator*(const float k) const; }; #endif // define MATRIX_H Constructeur est appelé lors de la création dun objet de la classe, porte le même nom que la classe Destructeur est appelé lors de la destruction dun objet de la classe, porte le même nom que la classe précédé d'un tilde ~ (explicitement par delete p.ex.)

#ifndef MATRIX2x2_H #define MATRIX2x2_H class Matrix2x2 { private: float _matrix[2][2]; public: // constructeur par defaut Matrix2x2(); // constructeur Matrix2x2(const float e00, const float e01, const float e10, const float e11); // destructeur par defaut ~Matrix2x2(); // Accès aux éléments float getElement(const unsigned int line, const unsigned int column) const; // Affecter les éléments void makeZero(); // Affecter les éléments void makeIdentity(); // Affecter les éléments void setElement( const unsigned int line, const unsigned int column, const float value); // Affecter les éléments void setElements( const float e00, const float e01, const float e10, const float e11); // Calculer le determinant float determinant() const; void afficher() const; Matrix2x2 addition (const Matrix2x2 matrix) const; Matrix2x2 operator+(const Matrix2x2 matrix) const; Matrix2x2 multiplication(const float k) const; Matrix2x2 operator*(const float k) const; }; #endif // define MATRIX_H Accesseurs Fonctions membres qui permettent daccéder aux données membres (get Mutateur Fonctions membres qui permettent de modifier les données membres (set)

Récapitulatif Types de base ( bool, unsigned char, signed char, unsigned int, float, double) Type enumerateur enum t_etat {gaz=0, solide=1, liquide=4}; Type tableau type nom_du_tableau[taille]; -structure de données la plus connu -structure homogène, chaque élément est du même type Organisation de la mémoire

Déclaration de variables int counter; float diviseur; char c; double precision; string nom; bool masculin; diviseur = 1.1; compteur = 1; Nom = « Gerhard »; // Nombre entier // Nombre à virgule flottante // Nombre à virgule flottante avec double précision // caractère // Chaîne de caractère // VRAI/FAUX

Mémoire vive Proc 64bit 2,93 GHz : 2,93 Giga-Instructions par seconde

Organisation de la mémoire char a; #0 #1 #2 #3 a #4 #5... # # #

Organisation de la mémoire char a; a = 97; #0 #1 #2 #3 a #4 #5... # # #

Organisation de la mémoire char a; a = 97; #0 #1 #2 #3 a #4 #5... # # # Comment connaître ladresse de a ? &a

Organisation de la mémoire char a; a = 97; p_a = &a;{ Sauvegarder ladresse } #0 #1 #2 #3 a #4 #5... # # # Comment connaître ladresse de a ? &a

char a; char *p_a; {4 octets, lire : pointeur vers a} a = 97; p_a = &a;{ Sauvegarder ladresse } #0 #1 #2 #3 a #4 #5... # # p_a # Comment connaître ladresse de a ? Addr(a) p_a #1.001 p_a #1.002 p_a # « p_a pointe vers a »

char a; char *p_a; {4 octets, lire : pointeur vers a} a = 97; p_a = &a;{ Sauvegarder ladresse } *p_a = 10; a = 10;{ Déréférencement } #0 #1 #2 #3 a #4 #5... # # p_a # Comment connaître ladresse de a ? &a p_a #1.001 p_a #1.002 p_a #

char *p_a; {4 octets, lire : pointeur vers a} *p_a = 10; #0 #1 #2 #3 #4 #5... # # p_a #1.000 Comment connaître ladresse de a ? &a p_a #1.001 p_a #1.002 p_a #1.003

char *p_a; {4 octets, lire : pointeur vers a} p_a = new p_a; *p_a = 10; #0 #1 #2 #3 *p_a #4 #5... # # p_a # Comment connaître ladresse de a ? &a p_a #1.001 p_a #1.002 p_a # Réserve une adresse qui tient un char Remplit p_a avec cette adresse

char *p_a; {4 octets, lire : pointeur vers a} p_a = new p_a; *p_a = 10;... delete p_a; #0 #1 #2 #3 #4 #5... # # p_a # Comment connaître ladresse de a ? &a p_a #1.001 p_a #1.002 p_a #1.003 Réserve une adresse qui tient un char Libère ladresse pointé par p_a

Variables globales et locales - la portée /* Programme expliquant la portée */ #include int carre = 10;// variable globale int sqr(int parametre) { int carre; carre = parametre * parametre; return carre; } // Debut du programme int main() { std::cout << "carre 1 :" << carre << std::endl; int x = 2; int y = sqr(x); std::cout << "carre 2 :" << carre << std::endl; int carre; carre = y; std::cout << "carre 3 :" << carre << std::endl; }

Variables globales et locales - la portée /* Programme expliquant la portée */ #include using namespace std; int carre = 10;// variable globale int sqr(int parametre) { int carre; carre = parametre * parametre; return carre; } // Debut du programme int main() { cout << "carre 1 :" << carre << endl; int x = 2; int y = sqr(x); cout << "carre 2 :" << carre << endl; int carre; carre = y; cout << "carre 3 :" << carre << endl; } Évite décrire std:: à chaque fois

Variables globales et locales - la portée /* Programme expliquant la portée */ #include int carre = 10;// variable globale int sqr(int parametre) { int carre; carre = parametre * parametre; return carre; } // Debut du programme int main() { std::cout << "carre 1 :" << carre << std::endl; int x = 2; int y = sqr(x); std::cout << "carre 2 :" << carre << std::endl; int carre; carre = y; std::cout << "carre 3 :" << carre << std::endl; }

Fonctions Déclaration dune fonction type_retour nom_de_la_fonction(type1 argument1, type2 argument2,…) { // bloc dinstruction } Appel de fonction type_retour variable_de_retour; variable_de_retour=nom_de_la_fonction(argument1, argument2,..); Prototype de la fonction type_retour nom_de_la_fonction(type1 argument1, type2 argument2,…);

Fonctions Arguments (paramètres) dune fonction –Constante surfaceDuCercle(M_PI) –Variable surfaceDuCercle(rayon) –Expression surfaceDuCercle(2+3); –Autre fonction … Valeur par défaut dune fonction type_retour nom_de_la_fonction(type1 argument1=valeur) { // bloc dinstruction } variable_de_retour = nom_de_la_fonction(); // argument 1 prend valeur; Renvoi de valeur dune fonction {.. type_retour variable_de_retour; return variable_de_retour; }

Fonctions Surcharge de fonctions int sqr(int arg1) // fonction 1 { return arg1*arg1; } float sqr(float arg1)// fonction 2 { return arg1*arg1; } int main() { int x; float y,z; x=sqr(2);// appel de la fonction 1 y=sqr(2);// appel de la fonction 2 z=sqr(2.5);// appel de la fonction 2 }

Appel de fonctions Appel par valeur Appel par référence

/* Programme expliquant la portée */ #include using namespace std; void ajouter (char parametre) { cout << "parametre : " << int(parametre) << endl; parametre += 2; // equivalent à parametre = parametre + 2 cout << "parametre : " << int(parametre) << endl; } // Debut du programme int main() { char a = 4; cout << "a :" << int(a) << endl; ajouter(a); cout << "a :" << int(a) << endl; } Appel par valeur

/* Programme expliquant la portée */ #include using namespace std; void ajouter (char parametre) { cout << "parametre : " << int(parametre) << endl; parametre += 2; cout << "parametre : " << int(parametre) << endl; } // Debut du programme int main() { char a = 4; cout << "a :" << int(a) << endl; ajouter(a); cout << "a :" << int(a) << endl; } #0 a #200 #201 #202 # # #203 #220 # #222 #

/* Programme expliquant la portée */ #include using namespace std; void ajouter (char parametre) { cout << "parametre : " << int(parametre) << endl; parametre += 2; cout << "parametre : " << int(parametre) << endl; } // Debut du programme int main() { char a = 4; cout << "a :" << int(a) << endl; ajouter(a); cout << "a :" << int(a) << endl; } #0 a #200 #201 #202 # # #203 parametre #220 # #222 # Appel par valeur

/* Programme expliquant la portée */ #include using namespace std; void ajouter (char parametre) { cout << "parametre : " << int(parametre) << endl; parametre += 2; cout << "parametre : " << int(parametre) << endl; } // Debut du programme int main() { char a = 4; cout << "a :" << int(a) << endl; ajouter(a); cout << "a :" << int(a) << endl; } #0 a #200 #201 #202 # # #203 parametre #220 # #222 # Appel par valeur

/* Programme expliquant la portée */ #include using namespace std; void ajouter (char parametre) { cout << "parametre : " << int(parametre) << endl; parametre += 2; cout << "parametre : " << int(parametre) << endl; } // Debut du programme int main() { char a = 4; cout << "a :" << int(a) << endl; ajouter(a); cout << "a :" << int(a) << endl; } #0 a #200 #201 #202 # # #203 #220 # #222 # Appel par valeur

/* Programme expliquant la portée */ #include using namespace std; void ajouter (int parametre) { cout << "parametre : " << parametre << endl; parametre += 2; cout << "parametre : " << parametre << endl; } // Debut du programme int main() { int a = 4; cout << "a :" << a << endl; ajouter(a); cout << "a :" << a << endl; } #0 #200 #201 #202 # # #203 #220 # #222 # Appel par valeur

Appel par référence /* Programme expliquant la portée */ #include using namespace std; void ajouter (char* parametre) { cout << "parametre : " << int(*parametre) << endl; (*parametre) += 2; cout << "parametre : " << int(*parametre) << endl; } // Debut du programme int main() { char a = 4; cout << "a :" << int(a) << endl; ajouter(&a); cout << "a :" << int(a) << endl; }

/* Programme expliquant la portée */ #include using namespace std; void ajouter (char* parametre) { cout << "parametre : " << int(*parametre) << endl; (*parametre) += 2; cout << "parametre : " << int(*parametre) << endl; } // Debut du programme int main() { char a = 4; cout << "a :" << int(a) << endl; ajouter(&a); cout << "a :" << int(a) << endl; } Appel par référence Parametre est un pointeur Appel par référence

/* Programme expliquant la portée */ #include using namespace std; void ajouter (char* parametre) { cout << "parametre : " << int(*parametre) << endl; (*parametre) += 2; cout << "parametre : " << int(*parametre) << endl; } // Debut du programme int main() { char a = 4; cout << "a :" << int(a) << endl; ajouter(&a); cout << "a :" << int(a) << endl; } #0 a #200 #201 #202 # # # Appel par référence

/* Programme expliquant la portée */ #include using namespace std; void ajouter (char* parametre) { cout << "parametre : " << int(*parametre) << endl; (*parametre) += 2; cout << "parametre : " << int(*parametre) << endl; } // Debut du programme int main() { char a = 4; cout << "a :" << int(a) << endl; ajouter(&a); // &a est # 200 cout << "a :" << int(a) << endl; } #0 a #200 #201 #202 # # #203 parametre #240 parametre # parametre #242 parametre # Appel par référence

/* Programme expliquant la portée */ #include using namespace std; void ajouter (char* parametre) { cout << "parametre : " << int(*parametre) << endl; (*parametre) += 2; cout << "parametre : " << int(*parametre) << endl; } // Debut du programme int main() { char a = 4; cout << "a :" << int(a) << endl; ajouter(&a); // &a est # 200 cout << "a :" << int(a) << endl; } #0 a #200 #201 #202 # # #203 parametre #240 parametre # parametre #242 parametre # Appel par référence

/* Programme expliquant la portée */ #include using namespace std; void ajouter (char* parametre) { cout << "parametre : " << int(*parametre) << endl; (*parametre) += 2; cout << "parametre : " << int(*parametre) << endl; } // Debut du programme int main() { char a = 4; cout << "a :" << int(a) << endl; ajouter(&a); // &a est # 200 cout << "a :" << int(a) << endl; } #0 a #200 #201 #202 # # #203 #240 # #242 # Appel par référence

Appel par référence (2) /* Programme expliquant la portée */ #include using namespace std; void ajouter (char& parametre) { cout << "parametre : " << int(parametre) << endl; parametre += 2; cout << "parametre : " << int(parametre) << endl; } // Debut du programme int main() { char a = 4; cout << "a :" << int(a) << endl; ajouter(a); cout << "a :" << int(a) << endl; }

Lancer de rayon Image Scene Rayon Pixel Camera Objet Pyramide Cube

class Name { private: char* _nom; public: Name(void) { _nom = 0; } ~Name(void) { delete[] _nom; } void SetName(char* n) { _nom = new char[strlen(n)+1]; strcpy(_nom,n); } void Print(void) { cout << _nom << endl; } }; Name Contact

class Name { private: char* _nom; public: Name(void) { _nom = 0; } ~Name(void) { delete[] _nom; } void SetName(char* n) { _nom = new char[strlen(n)+1]; strcpy(_nom,n); } void Print(void) { cout << _nom << endl; } }; class Contact: public Name { private: char* _addresse; public: Contact(void) { _addresse = 0; } ~Contact(void) { delete[] _addresse; } void SetAddress(char* c) { _addresse = new char[strlen(c)+1]; strcpy(_addresse,c); } void Print(void) { Name::Print(); cout << _addresse << endl; } }; int main(void) { Contact c; c.SetName("Amelie Mauresmo"); c.SetAddress("5 rue de la Tulippe, Paris"); c.Print(); }