CKTIS / C++
protected — accès protégé
Le mot-clé protected contrôle l’accès aux membres d’une classe ou le type d’accès de l’héritage. Il rend les membres accessibles aux classes dérivées sans les exposer au code extérieur ordinaire, mais impose des restrictions supplémentaires sur l’expression objet utilisée pour accéder aux membres non statiques.
Version : C++23; repository compiler flag, production runtime not attested
Syntaxe
class Base {
protected:
int value = 0;
};
class Derived : protected Base {};protected: définit l’accès des déclarations de membres suivantes jusqu’au prochain spécificateur d’accès ou à la fin de la classe. Les membres et amis de la classe qui déclare ces membres y ont accès, ainsi que, sous réserve de l’accessibilité de l’héritage, les membres et amis des classes dérivées. private n’accorde pas cet accès aux classes dérivées ; public n’impose aucune restriction d’accès. Un accès interdit entraîne une erreur de compilation, et non une vérification à l’exécution.
Les membres de données et fonctions membres non statiques protégés sont soumis à une règle supplémentaire : lorsque l’accès repose sur les droits d’une classe dérivée Derived, le type de l’expression objet doit être Derived ou une classe qui en dérive. Ainsi, other.value fonctionne avec const Derived&, mais pas avec const Base&, même si l’objet réel est de type Derived. Cette vérification supplémentaire ne concerne pas les membres statiques. Lorsqu’on forme un pointeur de membre (pointer-to-member) pour un membre protégé, le qualificateur doit désigner la classe dont les droits permettent l’accès ou une classe qui en dérive. Dans Derived, utilisez donc &Derived::value, et non &Base::value. En revanche, si s est un membre de données statique protégé de Base, un membre de Derived peut former un pointeur ordinaire avec &Base::s.
Dans class Derived : protected Base, le mot-clé contrôle l’héritage : les membres public et protected de Base sont accessibles par Derived en tant que membres protected. Cela n’accorde pas l’accès aux membres privés de Base. Le code extérieur ordinaire ne peut alors pas convertir implicitement Derived* en Base* ; les membres et amis de Derived le peuvent. Cet usage diffère de celui du spécificateur protected: dans une classe.
L’exemple utilise l’héritage public pour isoler l’accès aux membres protégés. read() donne accès à la valeur au moyen d’une fonction publique, tandis que les deux instructions en commentaire illustrent un accès interdit. Cette entrée porte sur C++23 ; l’URL de la norme fournie héberge un projet de travail évolutif, et non une édition C++23 figée. L’utilisation d’une option du compilateur n’atteste pas le fonctionnement dans un environnement de production.
Exemples
#include <iostream>
class Base {
protected:
int value = 7;
};
class Derived : public Base {
public:
int read() const { return value; }
void copyFrom(const Derived& other) {
value = other.value;
}
// void copyFromBase(const Base& other) { value = other.value; }
};
int main() {
Derived first;
Derived second;
second.copyFrom(first);
std::cout << second.read() << '\n';
// std::cout << second.value << '\n';
}
Résultat
7
Le code affiché et le résultat déclaré ont été vérifiés dans un environnement isolé selon la méthode consignée dans la preuve de vérification de cette version exacte.