模板、循环依赖、方法，天哪！

Question

背景：我正在开发一个框架，它基于现有的 Java 类模型。因此，我无法更改下面提到的循环依赖关系。

给定：

• 父子类关系
• 父包含子列表
• 用户必须能够在运行时查找列表元素类型

我在以下测试用例中对此进行了建模：

Main.cpp

#include "Parent.h"

#include <iostream>
using std::cout;
using std::endl;

int main(int argc, char* argv[])
{
    Parent parent;
    cout << Parent::getType() << endl;
    cout << parent.getChildren().getType() << endl;
    return 0;
}

Parent.h

#ifndef PARENT_H
#define PARENT_H

#include <string>

#include "Array.h"
class Child;

class Parent
{
public:
    Array<Child> getChildren()
    {
        return Array<Child>();
    }

    static std::string getType()
    {
        return "parent";
    }
};

#endif

Child.h

#ifndef CHILD_H
#define CHILD_H

#include "Parent.h"

class Child: public Parent
{
};

#endif

数组。 h

template <typename ElementType>
class Array
{
public:
    static std::string getType()
    {
        return ElementType::getType();
    }
};

1. 当我编译上面的代码时，我得到： 错误 C2027：在 return ElementType::getType();

   处使用未定义类型“Child”

2. 如果我尝试#include "Child.h"< /code> 而不是我得到的前向声明： 错误 C2504: 'Parent' : 基类未定义 at class Child: public Parent

3. 如果我尝试 Array的 Array 我得到： 错误 C2825：“ElementType”：在 return ElementType::getType();

   处后跟“::”时必须是类或命名空间；

循环依赖的产生是因为：

1. Child.h 需要了解 Parent 类
2. Parent.h 需要了解 Array 类
3. Array.h 需要了解 Child 类

有什么想法吗？

Answer 1

该错误是由于实例化模板时不存在 Child 类。

将以下内容添加到 Main 或 Parent.h 的末尾：

#include "Child.h"

这可以在 g++ 4 和 VS 2010 中正常编译。

Answer 2

解决这个问题的一种方法是将实现与接口分离。

因此，将Parent的实现放入.cpp文件中，以便编译器在编译Parent::getChildren()时可以看到Parent、Children和Array的定义。

#ifndef PARENT_H
#define PARENT_H
#include <string>
#include "Array.h"

class Child;

class Parent
{
public:
    Array<Child> getChildren();
    static std::string getType();
};

#endif

在parent.cpp中：

#include "parent.hpp"
#include "child.hpp"

Array<Child> Parent::getChildren() {
    return Array<Child>();
}

// etc.

更新：

是的，实际问题是由于在没有存在Child定义的情况下实例化Array::getType()引起的，所以我的解决方案是不完整的。

Pete Kirkham 的解决方案很好：只需将 child.hpp 包含到 main 中即可。

为了实现接口/实现分离，需要一个单独的 Array 实现文件，并显式实例化 Array 和任何其他所需的实例。这可能不是您想要的，但为了完整性，它看起来像：

在 array.hpp 中：

#ifndef ARRAY_HPP
#define ARRAY_HPP

#include <string>

template <typename ElementType>
class Array
{
public:
    static std::string getType();
};

#endif

在 array.cpp 中：

#include "array.hpp"
#include "child.hpp"

template<typename ElementType>
std::string Array<ElementType>::getType()
{
    return ElementType::getType();
}

template class Array<Child>;

Answer 3

编辑： OP 编辑​​了这个问题，以消除我和 rlbond 注意到的无限大小数据结构问题。通过此更改，现在可以使用 Array 而不是 Array，如 janm 的回答显示。

将 Array 更改为 Array，并更改 Array 类型以了解它包含指向对象而不是对象本身的指针：

New Array.h

// E.g. strip_pointer_from<Foo*>::type is Foo
template <typename T>
struct strip_pointer_from<T> {};

template <typename T>
struct strip_pointer_from<T*> {
    typedef T type;
};

template <typename ElementType>
class Array
{
public:
    static std::string getType()
    {
        return typename strip_pointer_from<ElementType>::type::getType();
    }
};

我强烈建议重新考虑 Array，不过 - 有什么方法可以使用普通的 vector 并只询问每个元素的类型？

Answer 4

也许你可以使用指向 Parent 中的 Child 的指针？
或者

#ifndef PARENT_H
#define PARENT_H

#include <string>

#include "Array.h"
class Child;

class Parent
{
public:
    Array<Child*> getChildren()
    {
        return Array<Child*>();
    }

    static std::string getType()
    {
        return "parent";
    }
};

#endif

，更一般地说，也许可以使用编译器防火墙技术（又名不透明指针，又名 PIMLP）。有关它的更多信息此处。

Answer 5

以下是我倾向于解决需要元类信息的系统中的问题的方法。另请参阅其他答案，以更直接地解决您的问题。

---

stl中使用的模式是用类型来表示类型，而不是字符串。因此 std::vector::value_type 表示存储在向量中的类型。然后由客户端代码来使用这种类型。

如果您想要对象的运行时类型，请使用具有返回该类型的虚函数的基类。对于位置的静态类型，您可以使用部分特化：

Object.h

#ifndef OBJECT_H
#define OBJECT_H

#include <string>

template <typename T>
struct type_info {
    // extend type_info<void*> to inherit defaults
    const static bool is_array = false;
};

template <typename T>
std::string type_name ( const T& )
{
    return type_info<T>::name();
};

template <typename T>
std::string type_name ()
{
    return type_info<T>::name();
};

#endif

Parent.h

#include "Object.h"
#include "Array.h"

class Child;
class Parent
{
public:
    Array<Child> getChildren() {
        return Array<Child>();
    }
};

template <>
struct type_info <Parent> : public type_info<void*> {
    static std::string name () {
        return "parent";
    }
};


#endif

Array.h

template <typename ElementType>
class Array
{
public:
    typedef ElementType value_type;
};

template <typename T>
struct type_info <Array<T > > {
    static std::string name () {
        return "Array<" + type_name<T>() + ">";
    }

    const static bool is_array = true;
};

Child.h

#ifndef CHILD_H
#define CHILD_H

#include "Parent.h"

class Child: public Parent
{
};

template <>
struct type_info <Child> : public type_info<void*> {
    static std::string name () {
        return "child";
    }
};

#endif

Main.cpp

#include "Object.h"
#include "Parent.h"
#include "Child.h"

#include <iostream>
#include <iomanip>

using std::cout;
using std::endl;
using std::boolalpha;

template<typename T> bool type_is_array (const T&) { return type_info<T>::is_array; }

int main(int argc, char* argv[])
{
    Parent parent;
    cout << type_name<Parent>() << endl;
    cout << type_name(parent.getChildren()) << endl;
    cout << boolalpha << type_is_array(parent) << endl;
    cout << boolalpha << type_is_array(parent.getChildren()) << endl;
    return 0;
}