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

使用转发声明避免循环依赖。

class terminal;

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

通过 推测此方法根据 C++ 标准未定义。
@Ben Voight 指出：

C++03 标准第 17.6.4.8 节说：

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

无论< code>std::vectorf(); 是 std::vector 的一个实例化，正在讨论此处如果那里的答案证明了这一点。那么这个答案没有用，我将删除它，否则它仍然有效。

Answer 2

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

不过，我并不完全确定这是否适用于您的情况，因为您只声明了一个返回类型不完整的函数，这是允许的。请参阅詹姆斯提出的问题；希望我们能在那里得到明确的答案。

---

只需前向声明terminal：

class terminal;

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

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

Answer 3

Base 类不需要了解 Derived 类的任何信息。这是面向对象设计的一个重要原则。您可以将基类更改为：

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

现在，first() 返回指向基类的指针向量。通过多态性，每个指针实际上都可以指向派生类。请注意，我将其更改为使用指针。如果您将其更改为简单的 vector ，则不起作用。

或者，如果您确实需要基类知道派生类的存在，您可以向前声明派生类：

#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

我认为奇怪的重复模板模式可以让你摆脱这个：

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 ，您只需 typedefterminal 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