C++ 类方法，返回向量<子类>

Question

我在尝试为班级编写的方法时遇到了一些问题。我有班级符号和班级终端。类终端扩展类符号，但类符号的方法之一需要返回一个向量。例如：

#ifndef SYMBOL_H
#define SYMBOL_H

#include "terminal.h"
#include <vector>

using namespace std;

class symbol {
   public:
        vector<terminal> first();
        virtual void polymorphable();
};

#endif

定义了类终端：

#ifndef TERMINAL_H
#define TERMINAL_H

#include "symbol.h"

using namespace std;

class terminal: public symbol {
    // ...
};

#endif

但是，这样做时，我在构建时遇到两个错误，其中一个首先出现：定义向量函数的行上的“'terminal'：未声明的标识符”，以及“'symbol'：未定义的基类" 与终端类定义一致。

如何解决“a 需要 b”、“b 需要 a”的问题？

Answer 1

使用 Forward Declarations 避免循环依赖。

class terminal;

class symbol
{
  std::vector<terminal> first();
  // ...
};

根据 C++ 标准，有人猜测这种方法是未定义的。
@Ben Voight 指出：

C++03 标准第 17.6.4.8 节说：

“特别是，在以下情况下效果是未定义的：...如果将不完整的类型用作模板参数在实例化模板组件时，除非该组件特别允许.. .

std::vector<X> f(); 是否为std::vector<X> 实例化，正在讨论here。如果那里的答案证明是这样，那么这个答案不成立，我将删除它，否则它仍然有效。

Answer 2

编辑： 标准可能不允许以下内容（参见 cmets）。在这种情况下，您根本无法拥有适当的循环依赖：如果A 的大小取决于B 类型成员的大小，但B 的大小取决于@ 类型成员的大小987654325@，那么这样的定义根本没有意义。

不过，我不完全确定这是否适用于您的情况，因为您只声明了一个返回类型不完整的函数， 允许这样做。见服务员question by James；希望我们能在那里得到一个明确的答案。

---

只需转发声明terminal:

class terminal;

class symbol
{
  std::vector<terminal> first();
  // ...
};

您可以前向声明任何只需为 incomplete 类型的内容。不完整类型可用于形成指针、引用、函数签名。只有当该类型的变量被使用时，才需要知道完整的类型。

Answer 3

Base 类不需要知道任何关于Derived 类的信息。这是面向对象设计中的一个重要原则。您可能会将基类更改为：

class symbol {
  public:
    vector<symbol*> first();
    virtual void polymorphable();
};

现在，first() 返回一个指向基类的指针向量。使用多态性，每个指针实际上都可以指向派生类。请注意，我将其更改为使用指针。如果您将其更改为简单的vector<symbol>，那将无法正常工作。

或者，如果你真的需要基类知道派生类的存在，你可以转发声明派生类：

#ifndef SYMBOL_H
#define SYMBOL_H

#include "terminal.h"
#include <vector>

using namespace std;
class terminal;  // forward declare the existence of this class

class symbol {
  public:
    vector<terminal*> first();     // change to be a vector of pointers
                                   // to avoid issues with incomplete type
    virtual void polymorphable();
};

#endif

Answer 4

使用前向声明。

James - 注意声明与实例不同。此代码运行良好

#include <vector>

class terminal; <--- TELLING THE COMPILER MAY USE terminal in the future.

class symbol 
{        
  std::vector<terminal> first(); <--- NOTE THE COMPILER DOES NOT NEED TO KNOW HOW TO CONSTRUCT EITHER
  // ... 
};           

class terminal: public symbol  < --- TELLS COMPILER THAT terminal INHERITS symbol i.e. CONTAINING THE METHOD first
{
   int wibble; 
};  

int main()
{
    symbol s;
    return 0;
}

Als - 你是对的。

Answer 5

我认为 Curiously Recurring Template Pattern 可以让你摆脱这个：

template<typename terminal_type>
class symbol_pattern
{
   public:
        std::vector<terminal_type> first();
        virtual void polymorphable();
};

class terminal : public symbol_pattern<terminal>
{
};

typedef symbol_pattern<terminal> symbol;

Answer 6

与其让单个成员函数返回容器，不如考虑让 begin() 和 end() 函数返回一个迭代器范围，类似于标准库容器本身所做的：

class terminal;

class terminal_iterator { /* defined appropriately */

struct symbol
{
    terminal_iterator begin_terminals() const;
    terminal_iterator end_terminals() const;
};

如果您在某个地方已经有一个std::vector<terminal> 来进行迭代，您可以只使用typedef terminal const* terminal_iterator;（或使用类似的typedef）并相应地定义成员函数。

如果您没有容器（即，成员函数将实现序列本身），您可以考虑编写自己的迭代器类来生成序列。

提供begin() 和end() 范围访问器有时比简单地为容器提供访问器需要更多的工作，但范围访问器提供了更大的灵活性和抽象性。

Answer 7

前向声明 + 智能指针（尽管现在这会将东西存储在堆而不是堆栈上......可能是不可取的）

#ifndef SYMBOL_H
#define SYMBOL_H

#include <vector>
#include <memory>

using namespace std;

class terminal; // Make a forward declaration like this

class symbol {
   public:
        vector<shared_ptr<terminal>> first();
        virtual void polymorphable();
};

#endif