Question

EDIT: les déclarant privée a été une faute de frappe, je l'ai fixé:

relative à une autre question, si je déclarais une variable statique dans une classe, puis tirais une classe de cela, est-il possible de déclarer la variable statique individuelle par chaque classe. -À-dire:

class A:
{
public:
static int x;
};
class B:A
{
public:
const static int x;
};

ne définiront deux différentes variables statiques x, un A et un B, ou vais-je obtenir une erreur pour redéfinir x, et si je reçois une erreur, comment faire un je crée deux séparés variables statiques?

Était-ce utile?

La solution

Lorsque vous utilisez des variables statiques, il pourrait être une bonne idée de les désigner explicitement:

public class B:A
{
  public const static int x;
  public int foo()
  {
    return B::x;
  }
}

De cette façon, même si la classe « au-dessus » la vôtre dans la hiérarchie décide de créer un membre du même nom, il ne cassera pas votre code. De même, j'essaie souvent de nous le mot-clé this lorsque vous accédez à des champs membres normaux.

Mise à jour pour utiliser la syntaxe C ++.

Autres conseils

Cela crée deux variables statiques séparées.

Notez que vous avez implicitement déclaré ces partenariats privé:

class A:
{
  private:
  static int x;
};
class B:A
{
  private:
  const static int x;
};

Ce qui signifie que les variables ne sont pas en compétition les uns avec les autres.

Comme nous l'avons dit, cela crée deux variables distinctes:

A::x;

// and 

B::x;

En fait, si vous essayez d'utiliser simplement « x » dans une méthode de B, seule la définition de la portée plus sera utilisée jusqu'à ce que vous êtes plus précis:

#include <iostream>

class A
{
protected:
static int x;

public:
    A() { x = 7; }
};

int A::x = 22;

class B:A
{
static const int x = 42;

public:

    int a_x() const { return A::x; }
    int b_x() const { return B::x; }
    int my_x() const { return x; } // here we get the more local variable, that is B::x.
};

int main()
{
    B b;

    std::cout << "A::x = " << b.a_x() << std::endl;
    std::cout << "B::x = " << b.b_x() << std::endl;
    std::cout << "b's x = " << b.my_x() << std::endl;

    std::cin.ignore();
    return 0;
}

Sorties:

A::x = 7
B::x = 42
b's x = 42

Quelqu'un a mentionné que l'accessibilité pourrait limiter l'accessibilité: rendant la variable privée de base ne sera pas le rendre accessible à la classe des enfants. Cependant, si la variable doivent être protégés ou public, utiliser une méthode d'accès explicite ou invoquer la règle de portée locale, je viens de le démontrer.

Si vous voulez une variable statique qui est propre à chaque classe qui utilise A - vous pouvez utiliser une classe de modèle
. Pour exemple

template<class T> struct A
{
   A() { ++s_var; }
   static int s_var;
};

template<class T> int A<T>::s_var;

stuct B :A<B> {
  B() { ++s_var; }  // this is a different s_var than the one used by 'C' below
};

struct C : A<C> {
  C() { ++s_var; } // this is a different s_var than the one used by 'B'
};
Licencié sous: CC-BY-SA avec attribution
Non affilié à StackOverflow
scroll top