Cours

This page is read only. You can view the source, but not change it. Ask your administrator if you think this is wrong.
====== Introduction à la déclaration des classes ======

Une classe définissant un objet est défini comme une [[in204:cpp:syntax:struct|structure]] contenant en plus des champs de la structure des fonctions membres.

<code cpp>

struct A 
{     
    unsigned fieldA;                 // définition des champs.
    float fieldB; 
    
    bool test();                     // prototype des fonctions membres 
    void execute(int anArgument);    
};

</code>

===== Définition des fonctions membres =====

La définition de la fonction peut contenir soit l'entête de la fonction membre suivi de son code :

<code cpp>

#include <cmath>

struct Vector
{     
    double x;
    double y;

    double norm() 
    { 
        return sqrt(x*x + y*y);
    }
}

</code>

soit nous pouvons scinder la déclaration de la fonction membre en définissant au sein de la classe le prototype de la fonction membre. Le code de la fonction membre sera défini en dehors de la classe.

<code cpp>

#include <cmath>

struct Vector
{     
    double x;
    double y;

    double norm();
}

double Vector::norm() 
{ 
    return sqrt(x*x + y*y);
}

</code>


Dans ce cas, il est possible de mettre la définition du code de la fonction dans un fichier ''".h"'' ou ''".hpp"''

<code cpp>
// Fichier Vector.hpp
#ifndef VectorHPP
#define VectorHPP

#include <cmath>

struct Vector
{     
    double x;
    double y;

    double norm();
};
#endif
</code>

et le code de la fonction membre dans le fichier ''".cc"'' ou ''".cpp"'':

<code cpp>
// Fichier Vector.cpp

#include "Vector.hpp"

double Vector::norm() 
{ 
    return sqrt(x*x + y*y);
}

</code>

===== Accéder aux champs et fonctions membres d'un objet =====

Pour accéder aux champs et aux fonctions d'un objet, nous utilisons :

  * soit l'opérateur ''.'', 
  * soit l'opérateur ''->'', si nous manipulons un pointeur sur un objet.

Ainsi considérons l'objet ''Vector'' précédemment défini, nous pouvons accéder aux champs de l'objet comme suit :

<code cpp>
int main()
{
    Vector v;
    v.X = 4.3;
    v.Y = v.X + 1;
    std::cout << "La norme du vecteur ("
      << v.X << ", " << "v.Y" << ") est :" 
      << v.norm() << std:endl;
}
</code>

Si nous définissons un pointeur sur un objet de type ''Vector'', l'accès se ferait par le biais de l'opérateur ''->''.

<code cpp>
int main()
{
    Vector* v = new Vector();
    v->X = 4.3;
    v->Y = v->X + 1;
    std::cout << "La norme du vecteur ("
      << v->X << ", " << "v->Y" << ") est :" 
      << v->norm() << std:endl;
    delete v;
}
</code>



===== Différence entre ''class'' et ''struct'' =====

En fait, les classes peuvent être définies soit en utilisant le mot-clé ''struct'' soit en utilisant le mot-clé ''class''. Si on utilise le mot clé ''struct'', cela signifie que par défaut les champs et fonctions membres (que l'on appelle aussi méthodes) sont visibles de tous ([[in204:cpp:syntax:public|public]]) tandis qu'ils ne sont visibles que des fonctions membres de la classe si on utilise le mot clé ''class''.

Ainsi, écrire :

<code cpp>

struct A 
{     
    unsigned field;                 // définition des champs.
    bool test();                     // prototype des fonctions membres 
};

</code>

est équivalent à :

<code cpp>

class A 
{    
public:
    unsigned field;                 // définition des champs.
    bool test();                     // prototype des fonctions membres 
};

</code>

Par analogie, 

<code cpp>

class B 
{    
    unsigned value;                  // définition des champs.
    bool execute(int);               // prototype des fonctions membres 
};

</code>

est équivalent à :

<code cpp>

struct B 
{    
private:
    unsigned value;                  // définition des champs.
    bool execute(int);               // prototype des fonctions membres 
};

</code>

===== Les sections internes d'une classe =====

Les mots clés ''private'', ''protected'' et ''public'' modifient la visibilité des différents éléments dans une classe. Pour plus d'informations, le chapitre détaille les différents niveaux [[in204:cpp:syntax:public|d'accessibilité aux champs et membres]] notamment dans le cadre de l'héritage.

  * Un élément d'une classe est dit ''public'' s'il est accessible à la fois par les fonctions membres de la classe mais aussi par les autres fonctions (fonctions du programme ou fonctions membres d'une autre classe).

  * Un élément d'une classe est dit ''private'' s'il est accessible par les fonctions membres de la classe mais aussi par n'est pas visible par les autres fonctions (fonctions du programme ou fonctions membres d'une autre classe).

<code cpp>
class Point
{
private:
    double x;               // les champs x et y sont déclarées privées
    double y;               // ils ne pourront qu'être accédés par les méthodes       
                            // internes de la classe.
public:
    int getX() const { return x; }  // accède au champ x.             
    int getY() const { return y; }  // accède au champ y.             

}
</code>

En conséquence :

<code cpp>

int main()
{
    Point p;
    
    std::cout << "L'abcisse de p est " << p.getX() << std::endl;
        // L'accès à la méthode p est possible par ce que la fonction membre
        // getX est publique.
        
    std::cout << "L'abcisse de p est " << p.x << std::endl;
        // L'accès au champ p est impossible par ce que le champ
        // p n'est pas public.
}
        
</code>
Cours

User Tools

Site Tools

Page Tools
