Langage c++

Notification de cookies

Nous utilisons des cookies pour améliorer votre expérience. En poursuivant votre navigation sur ce site, vous acceptez l'utilisation de cookies. Plus d'informations

Spécificateurs d'accès en C++

Le masquage des données est l’une des caractéristiques importantes de la programmation orientée objet qui permet d’empêcher les fonctions d’un programme d’accéder directement à la représentation interne d’un type de classe. La restriction d'accès aux membres de la classe est spécifiée par les sections étiquetées public, private et protected au sein du corps de la classe.
Les mots-clés public, private et protected sont appelés des spécificateurs d'accès.

Une classe peut avoir plusieurs sections étiquetées public, protected ou private. Chaque section reste en vigueur jusqu'à ce qu'une autre étiquette de section ou l'accolade droite de fermeture du corps de classe soit visible. L'accès par défaut pour les membres et les classes est privé (private).

Syntaxe :
                                class Test{
                                    public:
                                        // membres publiques
                                    
                                    private:
                                        // membres privés
                                    
                                    protected:
                                        // membres protégés
                                }
                            

Les membres public

Tous les membres de la classe déclarés sous public seront disponibles pour tous. Les données membres et les fonctions membres déclarées publiques sont également accessibles aux autres classes.

Les membres publiques d'une classe sont accessibles de n’importe où dans le programme en utilisant l’opérateur d’accès direct aux membres (.) avec l’objet de cette classe.

Exemple :
                                    #include <iostream>
                                    using namespace std;
                                    
                                    class Voiture
                                    {
                                    public:
                                        int Id;
                                        int NB_roues;
                                        double vitesse;
                                        int kilometrage;
                                        void afficher()
                                        {
                                            cout << "Id= " << Id << " - "
                                                 << " Roues=" << NB_roues << " Vitesse = " << vitesse << " Kilométrage = " << kilometrage << endl;
                                        }
                                    };
                                    
                                    int main()
                                    {
                                        Voiture v1;
                                        v1.Id = 1;
                                        v1.NB_roues = 4;
                                        v1.vitesse = 250;
                                        v1.kilometrage = 20000;
                                        v1.afficher();
                                        return 0;
                                    }
                            
Id= 1 - Roues=4 Vitesse = 250 Kilométrage = 20000

Les membres private

Il est impossible d'accéder à une variable ou à une fonction membre private, ni même de la visualiser de l'extérieur de la classe. Seules les fonctions de classe et amies peuvent accéder aux membres privés.

Par défaut tous les membres d'une classe seraient privés

En pratique, nous définissons les données dans la section private et les fonctions connexes dans la section public afin qu’elles puissent être appelées de l’extérieur de la classe, comme indiqué dans le programme suivant.

Exemple :
                                    #include <iostream>
                                    using namespace std;
                                    
                                    class Voiture
                                    {
                                    private:
                                        int Id;
                                        int NB_roues;
                                        double vitesse;
                                        int kilometrage;
                                    
                                    public:
                                        void initialiser(int monid, int roues, double mavitesse, int kilo)
                                        {
                                            Id = monid;
                                            NB_roues = roues;
                                            vitesse = mavitesse;
                                            kilometrage = kilo;
                                        }
                                        void afficher()
                                        {
                                            cout << "Id= " << Id << " - "
                                                 << " Roues=" << NB_roues << " Vitesse = " << vitesse << " Kilométrage = " << kilometrage << endl;
                                        }
                                    };
                                    
                                    int main()
                                    {
                                        Voiture v1;
                                        v1.initialiser(1, 4, 250, 20000);
                                        v1.afficher();
                                        return 0;
                                    }
                            
Id= 1 - Roues=4 Vitesse = 250 Kilométrage = 20000

Les membres protected

Le spécificateur d'accès protected est similaire à celui de spécificateur d'accès private. La différence est que les membres de la classe déclarés comme protected sont inaccessibles en dehors de la classe, mais ils peuvent être accédés par n'importe quelle sous-classe (classe dérivée) de cette classe.

Nous discuterons en détail du spécificateur protected dans le cours sur l'héritage et donnerons des exemples

Partager ce cours avec tes amis :

Rédigé par M. ESSADDOUKI

Learning a new programming language is an easy thing, but the most difficult thing is how to design efficient algorithms for real-world problems, so don't be a programmer, be a problems solver.

Cours Similaires :