Une classe définissant un objet est défini comme une structure contenant en plus des champs de la structure des fonctions membres.

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

Les éléments membres d'une classe peuvent être :

• des champs à l'instar des struct en C. Ces champs ont un type qui peut-être soit un type simple, soit un type structuré, tableau ou objet. Ces définitions de champs définissent les valeurs internes à l'objet.
• des fonctions membres, il s'agit de fonctions qui peuvent accédées et modifiées les valeurs internes de l'objet. Elles peuvent aussi appelées d'autres fonctions internes à l'objet.
• des constructeurs qui sont des fonctions membres particulières qui initialisent l'objet au moment de la création de l'objet.
• d'un destructeur qui est une fonction membre particulière qui est appleé au moment de la destruction de l'objet.
• des définitions de types. Ces définitions de type sont propres à l'objet.
• des définitions de valeurs constantes. Ces définitions de valeurs constantes sont propres à l'objet.
• des définitions de fonctions membres et de champs statiques qui sont partagées par tous les objets étant instance de la même classe.

Les fonctions membres accèdents directement aux éléments définis au sein de l'objet sans avoir besoin de préfixer ceux-ci soit par une référence à l'objet, soit par le nom du type de l'objet.

Pour pouvoir accéder aux champs et aux fonctions membres d'un objet à l'exception des champs et membres statiques de l'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 :

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;
}

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

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;
}

Pour accéder aux définitions de types présentes dans l'objets, nous référençons ces éléments en préfixant le nom de l'élément référencé par le nom de la classe suivit de ::.

Ainsi si nous considérons

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 (public) tandis qu'ils ne sont visibles que des fonctions membres de la classe si on utilise le mot clé class.

Ainsi, écrire :

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

est équivalent à :

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

Par analogie,

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

est équivalent à :

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

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 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).

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() { return x; }  // accède au champ x.             
    int getY() { return y; }  // accède au champ y.             
 
}

En conséquence :

int main()
{
    Point p;
 
    std::cout << "L'abcisse de p est " << p.getX() << std::endl;
        // L'accès à la méthode p est possible parce 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 parce que le champ
        // p n'est pas public.
}
 

La classe Point précédemment définie introduit deux fonctions membres qui ne font que lire le contenu des champs x et y de l'objet. Ces méthodes ne modifiant par l'objet, il peut-être ajouter le qualificateur ''const'' à ces deux méthodes.

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. Cette méthode ne modifie             
                                    // pas l'objet   
    int getY() const { return y; }  // accède au champ y.Cette méthode ne modifie             
                                    // pas l'objet                                           
 
}

Mettre le qualification const à une méthode signifie que cette méthode ne peut pas modifier l'objet. Ceci a pour conséquence :

• de n'accéder aux champs de l'objet qu'en lecture uniquement. La méthode ne peut pas affectée une nouvelle valeur à un champ.
• de ne pouvoir qu'appeler des méthodes qui ont le qualificateur const, ie. qui garantissent ne pas modifier l'objet.

Ainsi le code suivant génère une erreur à la compilation :

struct Vector 
{
...
   double getX() const { return X; }
   double getY() const {return Y; }
   void setX(double aValue) const { X = aValue; }
           // Erreur de compilation, ne peut pas modifier x.
   void setY(double aValue) { Y = aValue; }
 
   void norm() const { return sqrt(X*X + Y*Y); }   
}

De même, il n'est pas possible d'appeler une méthode qui n'est pas marquée const si l'objet a été déclaré const.

int main()
{
    const Vector& vector = Vector();
    vector.setX(3.0);    // Erreur de compilation, vector n'est pas modifiable.    
}