C++ “前进”；预先申报；C+中的一个类+；

我有一种情况，我想声明一个类成员函数，该函数返回一个依赖于类本身的类型。让我举个例子：

class Substring {
    private:
        string the_substring_;
    public:
        // (...)
        static SubstringTree getAllSubstring(string main_string, int min_size);
};

子字符串树的定义如下：

typedef set<Substring, Substring::Comparator> SubstringTree;

typedef集子字符串树；

我的问题是，如果我把SubstringTree定义放在SubstringTree定义之后，静态方法会说它不知道SubstringTree。如果我反转声明，那么typedef表示它不知道子字符串

---

我怎么做？提前感谢。

您可以在类中定义它：

class Substring {
    private:
        string the_substring_;
    public:
        // (...)
        typedef set<Substring, Substring::Comparator> SubstringTree;
        static SubstringTree getAllSubstring(string main_string, int min_size);
};

类子串{
私人：
将_子字符串u；
公众：
// (...)
排字子串树；
静态子字符串树getAllSubstring（字符串main\u string，int min\u size）；
};

您可以使用以下内容预先定义一个类：

class Foo;

请记住，在实际定义类之前，只能声明指向它的指针，而不能声明实例。

forward声明

class Substring;

---

我不知道这是否适用于子字符串的非指针使用。

正如您所写，简短的回答是您不能

您确实有一些相近的备选方案：

1） 在子字符串中声明子字符串树

class Substring {
public:
    class Comparator;
    typedef set< Substring, Comparator> Tree;

private:
    string the_substring_;
public:
    // (...)
    static Tree getAllSubstring(string main_string, int min_size);
};

typedef Substring::Tree SubstringTree;

类子串{
公众：
类比较器；
typedef set树；
私人：
将_子字符串u；
公众：
// (...)
静态树getAllSubstring（字符串main\u string，int min\u size）；
};
typedef Substring:：Tree SubstringTree；

2） 在子字符串外部定义比较器：

class Substring;
class SubstringComparator;
typedef set< Substring, SubstringComparator> SubstringTree;

class Substring {
public:

private:
    string the_substring_;
public:
    // (...)
    static SubstringTree getAllSubstring(string main_string, int min_size);
};

类子串；
类子串比较器；
typedef setSubstringTree；
类子串{
公众：
私人：
将_子字符串u；
公众：
// (...)
静态子字符串树getAllSubstring（字符串main\u string，int min\u size）；
};

3） 您可以使用模板延迟查找，直到有更多声明：

template <typename String>
struct TreeHelper
{
  typedef set< String, typename String::Comparator> Tree;
};

class Substring {
public:
  class Comparator;

private:
  string the_substring_;
public:
  // (...)
  static TreeHelper<Substring>::Tree getAllSubstring(string main_string
                                             , int min_size);
};

typedef TreeHelper<Substring>::Tree SubstringTree;

模板
结构树帮助器
{
typedef set树；
};
类子串{
公众：
类比较器；
私人：
将_子字符串u；
公众：
// (...)
静态TreeHelper:：Tree getAllSubstring（字符串main\u字符串
，int min_size）；
};
typedef TreeHelper:：Tree SubstringTree；

但是你必须用

Substring:：SubstringTree

引用它。。。这可能不是个坏主意。它将有助于分离全局名称空间。我甚至会使用Substring:：Tree。但是，您可以在类之外添加另一个typedef，在全局scope@Ates戈拉尔：是的，我认为

Substring:：Tree

实际上是最好的解决方案，但是

Substring:：SubstringTree

有点多余。我会选择Substring:：Tree。谢谢“预先声明”实际上被称为“向前声明”，使用正确的术语，你会更幸运，得到更好的结果。对不起，我实际上忘记了术语是什么。仔细想想，如果我知道这个词是什么，很可能我会知道如何做到我所要求的这就是为什么我们应该在回答或评论中包括“向前声明”，这样你就会知道，任何其他C++新手在这个问题上都应该知道。