Spécificateurs d'accès public et privé | Tutoriel C++

📖 Table des matières

1. Introduction
2. Les spécificateurs d'accès public et privé en C++
3. Exemple d'utilisation du spécificateur d'accès public
4. Différence entre les spécificateurs d'accès public et privé
5. Utilisation des spécificateurs d'accès privé pour les variables membres
6. Utilisation des spécificateurs d'accès public pour les fonctions membres
7. Fonctions getter et setter
8. L'encapsulation dans la programmation orientée objet
9. Utilisation des spécificateurs d'accès privé pour les fonctions membres
10. La dissimulation de l'information avec les fonctions membres privées
11. Conclusion

🖋️ Les spécificateurs d'accès public et privé en C++

Dans ce tutoriel, nous allons explorer la différence entre les spécificateurs d'accès public et privé en C++. Les spécificateurs d'accès public et privé sont utilisés pour modifier l'accès aux membres d'une classe.

1. Introduction

L'accès aux membres d'une classe est contrôlé par les spécificateurs d'accès. En C++, il existe deux spécificateurs d'accès couramment utilisés : public et privé. Ces spécificateurs déterminent si les membres d'une classe peuvent être utilisés à l'extérieur de la classe (public) ou s'ils sont limités à être utilisés uniquement à l'intérieur de la classe (privé).

2. Exemple d'utilisation du spécificateur d'accès public

Dans notre exemple, nous allons créer une classe Employe pour représenter les employés. Nous utiliserons le spécificateur d'accès public pour définir la variable membre name, qui sera de type string.

class Employe {
public:
    string name;
};

Grâce au spécificateur d'accès public, nous pouvons accéder à cette variable membre en dehors de la classe. Par exemple :

Employe employe1;
employe1.name = "Kevin";
cout << employe1.name << endl; // Output: Kevin

3. Différence entre les spécificateurs d'accès public et privé

La principale différence entre les spécificateurs d'accès public et privé est que les membres déclarés comme public peuvent être utilisés à l'extérieur de la classe, tandis que les membres déclarés comme privé sont uniquement accessibles à l'intérieur de la classe.

Prenons l'exemple d'une variable membre salary déclarée comme privée :

class Employe {
public:
    string name;
private:
    double salary;
};

Nous ne pouvons pas accéder directement à cette variable membre à l'extérieur de la classe :

employe1.salary = 50000; // Cette ligne générera une erreur de compilation

4. Utilisation des spécificateurs d'accès privé pour les variables membres

Les spécificateurs d'accès privé sont souvent utilisés pour les variables membres. Cela signifie que les variables membres déclarées comme privé ne peuvent être accédées qu'à l'intérieur de la classe.

Par exemple, nous pouvons définir une fonction membre getSalary() pour obtenir la valeur de la variable salary :

class Employe {
public:
    string name;
private:
    double salary;

public:
    double getSalary() {
        return salary;
    }
};

De cette manière, nous pouvons accéder à la variable salary en utilisant cette fonction membre :

employe1.setSalary(50000);
cout << employe1.getSalary(); // Output: 50000

5. Utilisation des spécificateurs d'accès public pour les fonctions membres

Les spécificateurs d'accès public permettent d'utiliser les fonctions membres en dehors de la classe. Dans notre exemple, nous avons défini une fonction setSalary() pour modifier la valeur de la variables salary :

class Employe {
public:
    string name;
private:
    double salary;

public:
    double getSalary() {
        return salary;
    }

    void setSalary(double potentialSalary) {
        if (potentialSalary < 0) {
            salary = 0;
        } else {
            salary = potentialSalary;
        }
    }
};

Ainsi, nous pouvons utilisez cette fonction pour modifier la valeur de la variable salary :

employe1.setSalary(50000);
cout << employe1.getSalary(); // Output: 50000

6. Fonctions getter et setter

Les fonctions getSalary() et setSalary() sont souvent appelées fonctions "getter" et "setter". Elles permettent de gérer l'accès à une variable membre privée et de s'assurer que les valeurs attribuées sont valides.

La fonction getSalary() renvoie simplement la valeur de la variable salary, tandis que la fonction setSalary() effectue une validation préalable avant de modifier la valeur de la variable.

class Employe {
public:
    string name;
private:
    double salary;

public:
    double getSalary() {
        return salary;
    }

    void setSalary(double potentialSalary) {
        if (potentialSalary < 0) {
            salary = 0;
        } else {
            salary = potentialSalary;
        }
    }
};

7. L'encapsulation dans la programmation orientée objet

L'encapsulation est un concept clé en programmation orientée objet. Cela signifie que les données d'une classe sont gérées et protégées par celle-ci, et que leur accès est restreint aux fonctions membres appropriées.

Dans notre exemple, la variable salary est considérée comme une information privée, car nous ne permettons pas un accès direct à cette variable depuis l'extérieur de la classe. Au lieu de cela, nous utilisons les fonctions getSalary() et setSalary() pour gérer cet accès.

L'encapsulation permet de masquer les détails de l'implémentation interne de la classe et de fournir une interface claire et contrôlée pour interagir avec celle-ci. Cela favorise la modularité, la simplicité et la réutilisabilité du code.

8. Utilisation des spécificateurs d'accès privé pour les fonctions membres

Les spécificateurs d'accès privé peuvent également être utilisés pour les fonctions membres d'une classe. Cela signifie que ces fonctions ne peuvent être appelées qu'à l'intérieur de la classe.

Par exemple, nous pouvons définir une fonction membre privée calculateBonus() pour calculer la prime annuelle d'un employé en fonction de son salaire :

class Employe {
public:
    string name;
private:
    double salary;

public:
    double getSalary() {
        return salary;
    }

    void setSalary(double potentialSalary) {
        if (potentialSalary < 0) {
            salary = 0;
        } else {
            salary = potentialSalary;
        }
    }

private:
    double calculateBonus() {
        return salary * 0.10;
    }
};

Comme cette fonction est déclarée comme privée, nous ne pouvons pas y accéder depuis l'extérieur de la classe :

employe1.calculateBonus(); // Cette ligne générera une erreur de compilation

9. La dissimulation de l'information avec les fonctions membres privées

La dissimulation de l'information, également appelée encapsulation de données, est un autre avantage de l'utilisation de fonctions membres privées. Les fonctions membres privées permettent à une classe de cacher les détails de son fonctionnement interne.

Dans notre exemple, la fonction calculateBonus() est un exemple de fonction membre privée utilisée pour dissimuler le calcul de la prime. De cette façon, la classe Employe conserve le secret de son implémentation interne.

Nous pouvons ensuite définir une fonction publique printBonus(), qui appellera la fonction membre privée calculateBonus() pour obtenir la prime et l'affichera :

class Employe {
public:
    string name;
private:
    double salary;

public:
    double getSalary() {
        return salary;
    }

    void setSalary(double potentialSalary) {
        if (potentialSalary < 0) {
            salary = 0;
        } else {
            salary = potentialSalary;
        }
    }

    void printBonus() {
        cout << "Bonus: " << calculateBonus() << endl;
    }

private:
    double calculateBonus() {
        return salary * 0.10;
    }
};

Maintenant, nous pouvons simplement appeler la fonction printBonus() pour afficher la prime de l'employé :

employe1.printBonus(); // Output: Bonus: 5000

10. Conclusion

En conclusion, les spécificateurs d'accès public et privé en C++ sont utilisés pour modifier l'accès aux membres d'une classe. Les membres déclarés comme public peuvent être utilisés à l'extérieur de la classe, tandis que les membres déclarés comme privé sont uniquement accessibles à l'intérieur de la classe.

Les spécificateurs d'accès privé sont souvent utilisés pour les variables membres, tandis que les spécificateurs d'accès public sont couramment utilisés pour les fonctions membres. Les fonctions getter et setter sont des exemples de fonctions membres utilisées pour gérer l'accès à des variables membres privées.

L'encapsulation et la dissimulation de l'information sont des concepts importants en programmation orientée objet. L'encapsulation permet de masquer les détails de l'implémentation interne d'une classe et de fournir une interface contrôlée pour interagir avec celle-ci.

J'espère que ce tutoriel vous a aidé à comprendre les spécificateurs d'accès public et privé en C++. Pour en savoir plus, vous pouvez consulter les ressources suivantes :

• cheopacourses.com