1

编辑：将它们声明为私有是一个错字，我修复了它：

关于另一个问题，如果我在一个类中声明了一个静态变量，然后从中派生一个类，有没有办法将静态变量声明为每个类的单独变量。IE：

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

这是否定义了两个不同的静态变量x，一个用于 A，一个用于 B，或者重新定义时会出现错误x，如果确实出现错误，如何创建两个单独的静态变量？

4

5 回答 5

2

当您使用静态变量时，明确地引用它们可能是个好主意：

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

这样，即使层次结构中“高于”你的类决定创建一个名称相似的成员，它也不会破坏你的代码。this同样，我通常在访问普通成员字段时尝试使用关键字。

更新为使用 C++ 语法。

于 2009-06-15T21:10:57.643 回答
1

这会创建两个单独的静态变量。

于 2009-06-15T20:52:08.093 回答
0

请注意，您已隐式声明这些私有：

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

这意味着变量不相互竞争。

于 2009-06-15T20:59:21.010 回答
0

如前所述，这会创建两个单独的变量：

A::x;

// and 

B::x;

实际上，如果您尝试在 B 的方法中仅使用“x”，则只会使用更接近的范围定义，直到您更精确：

#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;
}

输出：

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

有人提到可访问性可能会限制可访问性：将基变量设为私有不会使其子类可访问。但是，如果变量必须受保护或公开，请使用显式访问方法或依赖我刚刚演示的本地范围规则。

于 2009-06-15T21:04:50.827 回答
0

如果您想要一个对使用 A 的每个类都是单独的静态变量 - 您可以使用模板类。
例如 

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'
};
于 2009-06-15T21:12:34.223 回答