是否继承了静态字段？

当继承静态成员时，它们是整个层次结构的静态成员，还是仅仅是该类的静态成员，例如:

class SomeClass
{
public:
SomeClass(){total++;}
static int total;
};


class SomeDerivedClass: public SomeClass
{
public:
SomeDerivedClass(){total++;}
};


int main()
{
SomeClass A;
SomeClass B;
SomeDerivedClass C;
return 0;
}

在所有三个实例中总共是3个，或者 SomeClass是2个，SomeDerivedClass是1个？

66718 次浏览
小开

3 in all three instances.

And for your other question, it looks like you really just need a const variable instead of static. It may be more self-explanatory to provider a virtual function that returns the variable you need which is overridden in derived classes.

Unless this code is called in a critical path where performance is necessary, always opt for the more intuitive code.

小开
最佳答案

3 in all cases, since the static int total inherited by SomeDerivedClass is exactly the one in SomeClass, not a distinct variable.

Edit: actually 4 in all cases, as @ejames spotted and pointed out in his answer, which see.

Edit: the code in the second question is missing the int in both cases, but adding it makes it OK, i.e.:

class A
{
public:
static int MaxHP;
};
int A::MaxHP = 23;


class Cat: A
{
public:
static const int MaxHP = 100;
};

works fine and with different values for A::MaxHP and Cat::MaxHP -- in this case the subclass is "not inheriting" the static from the base class, since, so to speak, it's "hiding" it with its own homonymous one.

小开

Yes, the derived class would contain the same static variable, i.e. - they would all contain 3 for total (assuming that total was initialized to 0 somewhere).

小开

The answer is actually four in all cases, since the construction of SomeDerivedClass will cause the total to be incremented twice.

Here is a complete program (which I used to verify my answer):

#include <iostream>
#include <string>


using namespace std;


class SomeClass
{
public:
SomeClass() {total++;}
static int total;
void Print(string n) { cout << n << ".total = " << total << endl; }
};


int SomeClass::total = 0;


class SomeDerivedClass: public SomeClass
{
public:
SomeDerivedClass() {total++;}
};


int main(int argc, char ** argv)
{
SomeClass A;
SomeClass B;
SomeDerivedClass C;


A.Print("A");
B.Print("B");
C.Print("C");


return 0;
}

And the results:

A.total = 4
B.total = 4
C.total = 4
小开

It is 4 because when the derived object is created, the derived class constructor calls the base class constructor.
So the value of the static variable is incremented twice.

小开

SomeClass() constructor is being called automatically when SomeDerivedClass() is called, this is a C++ rule. That's why the total is incremented once per each SomeClass object, and then twice for SomeDerivedClass object. 2x1+2=4

小开 
#include<iostream>
using namespace std;


class A
{
public:
A(){total++; cout << "A() total = "<< total << endl;}
static int total;
};


int A::total = 0;


class B: public A
{
public:
B(){total++; cout << "B() total = " << total << endl;}
};


int main()
{
A a1;
A a2;
B b1;


return 0;
}

It would be:

A() total = 1
A() total = 2
A() total = 3
B() total = 4

提交答案