Pourquoi les membres publics d'une classe de base deviennent-ils invisibles lorsqu'ils héritent d'un modèle de classe, et quelles sont les solutions à ce problème ?

Éviter l'invisibilité des membres publics et la surcharge du code dans les modèles de classe hérités

La programmation orientée objet repose sur l'héritage des membres de classe protégés et publics. Dans les environnements sans modèle, cet héritage est simple. Cependant, lors de l'introduction de modèles de classe, un problème fondamental se pose : les membres publics de la classe de base deviennent invisibles pour le modèle de classe dérivé.

Le problème

Considérez l'exemple suivant :

<code class="cpp">class CBase
{
public:
    int Fn1(void) { ... }
};

class CDerived : public CBase
{
public:
    int FnSum(void) { ... CBase::Fn1(); ... }
};</code>

Lors de la création de ce code, le membre Fn1() de CBase disparaît du point de vue de CDerived :

<code class="cpp">template&lt;unsigned int BYTES&gt;
class CBase
{
public:
    int Fn1(void) { ... }
};

template&lt;unsigned int BYTES&gt;
class CDerived : public CBase&lt;BYTES&gt;
{
public:
    int FnSum(void) { ... Fn1(); ... } // Error: Fn1 not found!
};</code>

Solutions

Différentes solutions existent pour résoudre ce problème :

Solution 1 (préfixe détaillé) :

<code class="cpp">int FnSum(void) {
    return CBase&lt;BYTES&gt;::Fn1() + CBase&lt;BYTES&gt;::Fn2() + CBase&lt;BYTES&gt;::Arr[0];
}</code>

Cependant, cette approche introduit une surcharge de code excessive lors du référencement de plusieurs membres.

Solution 2 (préfixe verbeux "this->") :

<code class="cpp">int FnSum(void) {
    return this-&gt;Fn1() + this-&gt;Fn2() + this-&gt;Arr[0];
}</code>

Similaire à la solution 1, mais légèrement moins verbeuse.

Solution 3 (Utilisation de l'instruction) :

<code class="cpp">using CBase&lt;BYTES&gt;::Arr;
using CBase&lt;BYTES&gt;::Fn1;
using CBase&lt;BYTES&gt;::Fn2;</code>

Cela permet un accès direct aux membres CBase sans préfixe supplémentaire.

Solution 4 (Mode permissif) :

<code class="cpp">// Compiler flags: /permissive- (MSVC), -fpermissive (GCC/Cl), -fno-implicit-templates (Clang)</code>

Désactive la conformité stricte avec C, résolvant le problème mais peut introduire des problèmes de portabilité.

Une meilleure solution

Alors que la solution 3 est plus propre que les autres, il nécessite toujours des instructions "using" répétitives. Les macros peuvent simplifier cela :

<code class="cpp">#include &lt;boost/preprocessor.hpp&gt;

#define USING_ONE(r, base, member) using base::member;

#define USING_ALL(base, ...) BOOST_PP_SEQ_FOR_EACH(USING_ONE, base, BOOST_PP_VARIADIC_TO_SEQ(__VA_ARGS__))

#define USING_CBASE(param) USING_ALL(CBase&lt;param&gt;, Arr, Fn1, Fn2, Fn3, Fn4, Fn5)</code>

Dans la classe dérivée :

<code class="cpp">USING_CBASE(BYTES); // Makes all mentioned CBase members directly accessible</code>

Cette approche réduit considérablement la surcharge et la duplication du code.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!