我最近从Java过渡到C++,在弄清楚类继承是如何准确工作的方面遇到了一些困难。目前,我有类Weapon
和类Minigun
。Minigun
继承了类Weapon
,这意味着它应该具有Weapon
定义的方法和变量。我的问题是,我在Weapon
中有一个名为rate
的私有常量static int,以及一个返回一个称为getRate()
的整数的公共方法。getRate()
只是返回类中定义的速率变量。当Minigun
扩展Weapon
,并且我在Minigun
内部设置速率时,getRate()
方法仍然从Weapon
类返回常量,即使它是在Minigun
类上调用的。我认为它会像Java一样工作,内部方法会使用Minigun
中的修改变量。目前我必须做以下事情;
武器.h
#ifndef __WEAPON__
#define __WEAPON__
class Weapon
{
public:
virtual int getRate()
{
return rate;
}
private:
const static int rate = 0;
};
#endif
迷你枪.h
#include "Weapon.h"
#ifndef __WEAPON_MINIGUN__
#define __WEAPON_MINIGUN__
class Minigun: public Weapon
{
public:
int getRate(); // I have to define this here, and create it inside Minigun.cpp
private:
const static int rate = 30;
};
#endif
迷你枪.cpp
#include "Minigun.h"
int Minigun::getRate() // Is there a way so I do not need to type this out for every class that extends Weapon?
{
return rate;
}
Weapon
实例将从Weapon::rate
到getRate()
返回速率,Minigun
实例将返回速率Minigun::rate
。
因为方法getRate()
是虚拟的,所以Weapon
指针或对Minigun
实例的引用将返回Minigun::rate
的速率。
如果派生类中只有速率变量发生变化,那么模板类将需要比动态多态版本更少的编码。模板版本看起来像:
template<int Rate = 0>
class Weapon
{
public:
int getRate() // no need for virtual anymore
{
return rate;
}
private:
const static int rate = Rate;
};
class Minigun: public Weapon<30> {};
不要让它是静态的。例如:
#include <iostream>
class Weapon {
public:
Weapon();
virtual int Rate();
virtual void Rate(int r);
protected:
int rate;
};
Weapon::Weapon() {
rate = 10;
}
class Minigun : public Weapon {
public:
Minigun();
};
Minigun::Minigun() {
rate = 30;
}
int Weapon::Rate() {
return rate;
}
void Weapon::Rate(int r) {
rate = r;
}
int main() {
Minigun ThisGun;
Weapon AnyGun;
std::cout << ThisGun.Rate() << std::endl;
std::cout << AnyGun.Rate() << std::endl;
AnyGun.Rate(15);
std::cout << AnyGun.Rate() << std::endl;
return 0;
}
我们在基类中声明一个受保护的int。这意味着任何继承基类的派生类也将具有该变量。如果只想为该对象的所有实例共享该变量的一个实例,则只能声明变量static
。
将在派生构造函数之前调用基构造函数。您可以在派生构造函数中为该特定类型的对象重置默认值。公共函数将调用派生最多的虚拟函数。在这种情况下,我们希望Minigun
对我们的速率函数表现相同,因此我们简单地不为Minigun
实现任何函数,因此调用Weapon
函数。输出为:
30
10
15