在 C++ 中反映类的继承树？

Question

假设我在 C++ 中有以下类，我想检查它们的继承：

Vehicle

Motorcar 是 Vehicle
Aircraft 是 Vehicle

Biplane 是 Aircraft 是 Vehicle
Helicopter 是 Aircraft 是 Vehicle。

我想写一个方法getClassLineage()来做以下事情：

Biplane b;
cout << b.getClassLineage() << endl; // prints "Vehicle--Aircraft--Biplane"

Helicopter h;
cout << h.getClassLineage() << endl; // prints "Vehicle--Aircraft--Helicopter"

Motorcar m;
cout << m.getClassLineage() << endl; // prints "Vehicle--Motorcar"

似乎应该有一种简单的递归方式来做到这一点，只需在超类中编写一次，而无需在每个派生类中复制一个基本相同的方法。

假设我们愿意声明（伪代码）Helicopter.className = "Helicopter" 和 typedef Aircraft baseclass 在每个派生类中，但尽量避免复制和粘贴 getClassLineage()。

有没有优雅的写法？

（感谢您的意见！）

Answer 1

解决方案 1

如果你对修饰名没问题，那么你可以写一个免费的函数模板：

struct Vehicle {};
struct Aircraft : Vehicle { typedef Vehicle super; };
struct Helicopter : Aircraft { typedef Aircraft super; };
 
template<typename T>
string getClassLineage()
{
   static string lineage = string(typeid(T).name()) +" - " + getClassLineage<typename T::super>();
   return lineage;
}
template<>
string getClassLineage<Vehicle>()
{
   static string lineage = string(typeid(Vehicle).name());
   return lineage;
}
 
int main() {
        cout << getClassLineage<Helicopter>() << endl;
        return 0;
}

输出（修饰名称）：

10直升机 - 8飞机 - 7车辆

见ideone：http://www.ideone.com/5PoJ0

如果你愿意，你可以去掉装饰。但这将是特定于编译器的！ Here 是利用remove_decoration 函数剥离装饰的版本，然后输出变为：

直升机 - 飞机 - 车辆

顺便说一句，正如我所说，remove_decoration 函数的实现是特定于编译器的；此外，这可以用更正确的方式编写，因为我不知道 GCC 考虑的所有情况，而 mangling 是类名。但我希望你能明白基本的想法。

---

解决方案 2

如果您可以在每个派生类中重新定义函数，那么这里有一个简单的解决方案：

struct Vehicle 
{ 
   string getClassLineage() const { return "Vehicle"; } 
};
struct Aircraft : Vehicle 
{ 
   string getClassLineage() const { return Vehicle::getClassLineage()+" - Aircraft"; } 
};
struct Helicopter : Aircraft 
{ 
   string getClassLineage() const { return Aircraft::getClassLineage()+" - Helicopter "; } 
};
 
int main() {
        Helicopter heli;
        cout << heli.getClassLineage() << endl;
        return 0;
}

输出：

车辆 - 飞机 - 直升机

在 ideone 查看输出：http://www.ideone.com/Z0Tws

Answer 2

如果您想要一种类似递归的方法，您可以使用虚函数和显式作用域函数调用来实现：

struct vehicle {
   virtual std::string lineage() const { return "vehicle"; }
};
struct aircraft : vehicle {
   typedef vehicle base;
   virtual std::string lineage() const { return base::lineage() + "--aircraft"; }
};
struct biplane : aircraft {
   typedef aircraft base;
   virtual std::string lineage() const { return base::lineage() + "--biplane"; }
};
struct nieuport17 : biplane {
   typedef biplane base;
   virtual std::string lineage() const { return base::lineage() + "--nieuport17"; }
};
int main() {
   biplane b;
   aircraft const & a = b;
   std::cout << a.lineage() << std::endl;
}

它是如何工作的？当您调用v.lineage() 因为它是一个虚函数时，动态调度将进入biplane::lineage()，因为这是对象的实际类型。在该函数内部，有对其父函数的lineage() 函数的合格调用。合格的调用不使用动态调度机制，所以调用实际上会在父级执行。基本上是这样的：

a.lineage() -- dynamic dispatch -->
---> biplane::lineage() 
     \__ airplane::lineage()
         \__ vehigcle::lineage() 
          <-- std::string("vehicle")
      <-- std::string("vehicle") + "--airplane"
  <-- std::string("vehicle--airplane") + "--biplane"
<--- std::string( "vehicle--airplane--biplane" )

Answer 3

[...]但尽量避免复制和粘贴 getClassLineage()。

据我所知，这是不可能的。 C++ 本身没有反射，因此程序员必须自己完成工作。以下 C++0x 版本在 Visual Studio 2010 下工作，但我不能说对于其他编译器：

#include <string>
#include <typeinfo>
#include <iostream>

class Vehicle{
public:
        virtual std::string GetLineage(){
                return std::string(typeid(decltype(this)).name());
        }
};

class Aircraft : public Vehicle{
public:
        virtual std::string GetLineage(){
                std::string lineage = std::string(typeid(decltype(this)).name());
                lineage += " is derived from ";
                lineage += Vehicle::GetLineage();
                return lineage;
        }
};

class Biplane : public Aircraft{
public:
        virtual std::string GetLineage(){
                std::string lineage = std::string(typeid(decltype(this)).name());
                lineage += " is derived from ";
                lineage += Aircraft::GetLineage();
                return lineage;
        }
};

class Helicopter : public Aircraft{
public:
        virtual std::string GetLineage(){
                std::string lineage = std::string(typeid(decltype(this)).name());
                lineage += " is derived from ";
                lineage += Aircraft::GetLineage();
                return lineage;
        }
};

int main(){    
        Vehicle v;
        Aircraft a;
        Biplane b;
        Helicopter h;

        std::cout << v.GetLineage() << std::endl;
        std::cout << a.GetLineage() << std::endl;
        std::cout << b.GetLineage() << std::endl;
        std::cout << h.GetLineage() << std::endl;

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

输出：

class Vehicle *
class Aircraft * is derived from class Vehicle *
class Biplane * is derived from class Aircraft *
class Helicopter * is derived from class Aircraft *

ideone 的输出略有不同，它去掉了星号并在名称的开头用 P 装饰了指针，但它可以工作。有趣的事实：尝试使用 typeid(decltype(*this)).name() 导致 VS2010 的编译器崩溃。

Answer 4

您需要一个静态字段来存储血统，并且每个类都会在其自己的静态字段中附加自己的血统。

如果您正在考虑使用 typeid() 或类似的东西，它更复杂但可以避免重复 getClassLineage() 方法，请记住 name 字段属性很烦人（原因超出了我的理解）不是类的真实名称，而是一个可以是该名称或任何类型的错误名称（即未定义的表示）的字符串。

如果我们使用 Python 或任何其他基于原型的编程语言，您可以轻松应用递归方法，就像您建议的那样，其中继承是通过委托实现的，因此可以遵循“继承路径”。

#include <iostream>
#include <string>

class Vehicle {
public:
  static const std::string Lineage;

  Vehicle() {}
  virtual ~Vehicle() {}

  virtual const std::string &getClassLineage()
     { return Vehicle::Lineage; }
};

class Motorcar : public Vehicle {
public:
  static const std::string Lineage;

  Motorcar() {}
  virtual ~Motorcar() {}

  virtual const std::string &getClassLineage()
     { return Motorcar::Lineage; }
};

class Helicopter : public Vehicle {
public:
  static const std::string Lineage;

  Helicopter() {}
  virtual ~Helicopter() {}

  virtual const std::string &getClassLineage()
     { return Helicopter::Lineage; }
};

class Biplane : public Vehicle {
public:
  static const std::string Lineage;

  Biplane() {}
  virtual ~Biplane() {}

  virtual const std::string &getClassLineage()
     { return Biplane::Lineage; }
};

const std::string Vehicle::Lineage = "Vehicle";
const std::string Motorcar::Lineage = "Vehicle::Motorcar";
const std::string Helicopter::Lineage = "Vehicle::Helicopter";
const std::string Biplane::Lineage = "Vehicle::Biplane";


int main()
{
    Biplane b;
    std::cout << b.getClassLineage() << std::endl; // prints "Vehicle--Aircraft--Biplane"

    Helicopter h;
    std::cout << h.getClassLineage() << std::endl; // prints "Vehicle--Aircraft--Helicopter"

    Motorcar m;
    std::cout << m.getClassLineage() << std::endl; // prints "Vehicle--Motorcar"

    return 0;
}

Answer 5

#include <iostream>
#include <ios>
#include <iomanip>
#include <fstream>
#include <cstdio>
#include <list>
#include <sstream>

using namespace std;

static const char *strVehicle = "Vehicle";
static const char *strMotorcar = "Motorcar";
static const char *strHelicopter = "Helicopter";

class Vehicle
{
private:
  const char *ClassName;
protected:
  int Lineage;
    list<const char *> MasterList;
public:
  Vehicle(const char *name = strVehicle)
    {
        MasterList.push_back(name);
    }
  virtual ~Vehicle() {}
  virtual int getClassLineage() const
  {
    return Lineage;
  }
  string getName() const
    {
        list<const char *>::const_iterator it = MasterList.begin();
        ostringstream ss( ios_base::in | ios_base::out );
        while(it != MasterList.end())
        {
            ss << *(it++);
            if(it != MasterList.end())
                ss << " --> ";
        }
        ss << endl;
        ss << ends;
        return ss.str();
    }
};

class Motorcar : public Vehicle
{
private:
  const char *ClassName;
public:
  Motorcar(const char *name = strMotorcar)
    {
        MasterList.push_back(name);
    }
  virtual ~Motorcar() {}
  using Vehicle::getClassLineage;
  using Vehicle::getName;
};

class Helicopter : public Vehicle
{
private:
  const char *ClassName;
public:
  Helicopter(const char *name = strHelicopter)
    {
        MasterList.push_back(name);
    }
  virtual ~Helicopter() {}
  using Vehicle::getClassLineage;
  using Vehicle::getName;
};


int _tmain(int argc, _TCHAR* argv[])
{
    Helicopter h;
    Motorcar m;
    wcout << "Heli: " << h.getName().c_str() << endl;
    wcout << "Motorcar: " << m.getName().c_str() << endl;
    return 0;
}

Answer 6

如果使用typeid，则不需要硬编码字符串（类名）。您的问题的解决方案可能是：

#include <iostream>
#include <typeinfo>
using namespace std;

class Vehicle
{
public: 
    Vehicle();  
    string GetClassLineage(){return strName;}
protected:
    string strName;
};

Vehicle::Vehicle() : strName(typeid(*this).name())
{
    // trim "class "
    strName = strName.substr(strName.find(" ") + 1);
}

class Motorcar : public Vehicle
{
public: 
    Motorcar();
};

Motorcar::Motorcar()
{
    string strMyName(typeid(*this).name());
    strMyName = strMyName.substr(strMyName.find(" ") + 1);  

    strName += " -- ";  
    strName += strMyName;
}

int main()
{
    Motorcar motorcar;
    cout << motorcar.GetClassLineage() << endl;
    return 0;
}

输出：

Vehicle -- Motorcar