C++ 模板化类/结构组合的好方法

模板化调用的类最有效的方法是什么？需要调用模板化结构。这是模板化的经典有序列表问题。从现在起，我的整个有序列表都可以工作（当我只是手动更改类型时）。但是，我不知道如何对这对对象（结构和类）进行模板化

基本上，我的代码是这样构造的：

struct Node {
    int* data;
    Node* next;
};

class OList {
    private:
        Node* start;
        int size;
    public:
        a bunch of manipulation functions
};

因此，我的愿望是简单地模板化结构，然后接受一个参数，该参数将模板传递到节点结构类型中。然而，我的第一次尝试是：

template<class T> 

我得到了以下错误：“非模板化的‘节点’用作模板。注意：使用OList:：template Node’表示它是模板（？？？）错误：需要在‘OList:：Node’之前加上‘typename’，因为‘OList是一个依赖范围’清除这些错误的最有效方法是什么？当注释掉这一个函数时，代码可以完美地工作

template <typename T>     // <----
struct Node {
    T* data;              // <----
    Node* next;
};

template <typename T>     // <----
class OList {
    private:
        Node<T>* start;   // <----
        int size;
    public:
        a bunch of manipulation functions
};

---

越界成员函数定义示例：

template <typename T>
class OList
{
    private:
        struct Node { T* data; };
        Node* f(Node*);
    public:
};

template <typename T>
typename OList<T>::Node* OList<T>::f(typename OList<T>::Node* p)   // see notes
{
    Node* p2 = p;    // can use Node as if inside class definition
    return p2;
}

---

这样，您可以说

NODE（int）

或

NODE（float）

来为这些类型生成

NODE\u int

和

NODE\u float

结构。使用模板时，您（通常）不需要单独定义每个专业化—使用时会隐式定义（“参数多态性”）—因此只需开始将它们用于变量ala

Node my\u Node\u for_int

您的意思是：

template <typename T>
struct Node {
    T data;
    Node* next;
};

template <typename T>
class OList {
    private:
        Node<T> start;
        int size;
    public:
};

模板
结构节点{
T数据；
节点*下一步；
};
模板
阶级集权者{
私人：
节点启动；
整数大小；
公众：
};

---

？

请在模板化后包含

节点

和

OList

的声明。“失败得很惨”甚至不能充分描述问题……您是否也制作了

OList

模板？或者只是

节点

“？我不确定这是否是一种好的做法或可能，但您可以将

节点

类放在

OList

类中并从那里开始？我将它们都制作为模板，这样我就可以将整个结构与OList的类定义放在一起？”？这将使事情变得更容易，因为那时我只需要做其中一个模板，而不是两个模板，在.h文件中声明下面的函数中，如何指定类型T？例如，我有几个函数，它们接受给定类类型的输入，然后对它们执行类定义中指定的函数。请参见上面的示例代码，了解我的目的。@Eric-“将整个结构与类放在一起”-是的，当然。。。如果

节点

没有在其他（容器）类型的实现中使用，那么这样封装会更好……啊，好的。这是有意义的，因为节点仅在类定义的上下文中使用。谢谢你的帮助；我真的很感激@Eric在类定义后重新定义成员函数。。。我在回答中加了一个例子。

template <typename T>
class OList {
    private:
        struct Node { T* data; int size; };  // <----
        Node* start;   

template <typename T>
class OList
{
    private:
        struct Node { T* data; };
        Node* f(Node*);
    public:
};

template <typename T>
typename OList<T>::Node* OList<T>::f(typename OList<T>::Node* p)   // see notes
{
    Node* p2 = p;    // can use Node as if inside class definition
    return p2;
}

typename OList<T>::Node* OList<T>::f(typename OList<T>::Node* p)

#define NODE(T)      \
struct Node ## T {   \
    T* data;         \
    Node ## T* next; \
};

template <typename T>
struct Node {
    T data;
    Node* next;
};

template <typename T>
class OList {
    private:
        Node<T> start;
        int size;
    public:
};