C++ 递归c++；模板问题

假设我有一个模板类，它从源代码中获取MSG，对它们执行一些智能操作，然后将它们发送到接收器：

template <typename Source, typename Sink>
class MsgHandler
{
MsgHandler(Source* pSource)
: m_pSource(pSource)
{
  m_pSource->setHandler(this);
}
};

//Now the definition of the Source:

template <typename Handler>
class Source
{
void setHandler(Handler* pHandler)
{
  m_pHandler = pHandler;
}
};

模板
MsgHandler类
{
MsgHandler（来源*pSource）
：m_pSource（pSource）
{
m_pSource->setHandler（此）；
}
};
//现在，源的定义如下：
模板
类源
{
void setHandler（Handler*pHandler）
{
穆·芬德勒=芬德勒；
}
};

很好，但是现在我真的无法生成源或处理程序。例如：

MsgHandler<FileSource<MsgHandler<FileSource.... recursing parameters...
FileSource<MsgHandler<FileSource<MsgHandler.... same problem when trying to build a source

---

MsgHandler我不明白为什么您的
源代码需要在其处理程序上进行参数化。如果
Source
和
Handler
真的需要以您描述的方式紧密耦合，那么模板似乎并不会给您带来超出接口定义的好处。在我看来，您可以使用一个非模板的
源
类来封装
处理程序
 我不明白为什么您的
源代码
需要在其处理程序上进行参数化。如果
Source
和
Handler
真的需要以您描述的方式紧密耦合，那么模板似乎并不会给您带来超出接口定义的好处。在我看来，您可以使用一个非模板的
源
类来封装
处理程序
 看起来
处理程序不应该知道
源代码的任何信息。简单线性依赖关系如何：

template <typename Sink>
class Handler {
private:
    Sink* sink; // get this pointer in the constructor?
public:
    void handle( const Msg& m ) {
        // processing
        sink->accept( m );
    }
};

template <typename Handler>
class Source {
private:
    Handler* handler; 
public:
    void genMessage() {
        Msg m;
        // get message off the wire?
        handler->handle( m );
    }
};

模板
类处理程序{
私人：
Sink*Sink；//是否在构造函数中获取此指针？
公众：
无效句柄（const Msg&m）{
//加工
下沉->接受（m）；
}
};
模板
类源{
私人：
处理者*处理者；
公众：
void genMessage（）{
味精m；
//把消息从电线上取下来？
手柄->手柄（m）；
}
};

也可以将“处理”和“下沉”扭曲为。
看起来
处理程序不应该知道
源代码的任何信息。简单线性依赖关系如何：

template <typename Sink>
class Handler {
private:
    Sink* sink; // get this pointer in the constructor?
public:
    void handle( const Msg& m ) {
        // processing
        sink->accept( m );
    }
};

template <typename Handler>
class Source {
private:
    Handler* handler; 
public:
    void genMessage() {
        Msg m;
        // get message off the wire?
        handler->handle( m );
    }
};

模板
类处理程序{
私人：
Sink*Sink；//是否在构造函数中获取此指针？
公众：
无效句柄（const Msg&m）{
//加工
下沉->接受（m）；
}
};
模板
类源{
私人：
处理者*处理者；
公众：
void genMessage（）{
味精m；
//把消息从电线上取下来？
手柄->手柄（m）；
}
};

还可以将“handling”和“sinking”扭曲为。
您可以将模板参数用于处理程序的源参数：

class MySink;
template <template<typename Handler> class Source, typename Sink>
class MsgHandler
{
    Source<MsgHandler>* m_pSource;

    MsgHandler(Source<MsgHandler>* pSource)
    : m_pSource(pSource)
    {
      m_pSource->setHandler(this);
    }
};

//Now the definition of the Source:

template <typename Handler>
class Source
{
    void setHandler(Handler* pHandler)
    {
      m_pHandler = pHandler;
    }
};

//Now you can define variables like this
MsgHandler<Source, MySink> myHandler;

classmysink；
模板
MsgHandler类
{
来源*m_p来源；
MsgHandler（来源*pSource）
：m_pSource（pSource）
{
m_pSource->setHandler（此）；
}
};
//现在，源的定义如下：
模板
类源
{
void setHandler（Handler*pHandler）
{
穆·芬德勒=芬德勒；
}
};
//现在您可以像这样定义变量
MsgHandler myHandler；

当然，这要求MsgHandler的源参数必须是一个只有一个参数（处理程序）的模板，但如果您能够接受该约束，这将解决您的定义问题（否则您可能会（或者可能不会，具体取决于您将尝试什么）能够使用一些额外的模板foo来规避此限制（创建另一个模板，该模板将处理程序作为参数，并为相应的SourcesType创建一个typedef）

在这种情况下，最好将
typedef Source-SourceType
添加到MsgHandler中，以使调用方可以看到源实例化（而不是要求程序员猜测MsgHandler将实例化源。
可以使用模板参数作为处理程序的源参数：

class MySink;
template <template<typename Handler> class Source, typename Sink>
class MsgHandler
{
    Source<MsgHandler>* m_pSource;

    MsgHandler(Source<MsgHandler>* pSource)
    : m_pSource(pSource)
    {
      m_pSource->setHandler(this);
    }
};

//Now the definition of the Source:

template <typename Handler>
class Source
{
    void setHandler(Handler* pHandler)
    {
      m_pHandler = pHandler;
    }
};

//Now you can define variables like this
MsgHandler<Source, MySink> myHandler;

classmysink；
模板
MsgHandler类
{
来源*m_p来源；
MsgHandler（来源*pSource）
：m_pSource（pSource）
{
m_pSource->setHandler（此）；
}
};
//现在，源的定义如下：
模板
类源
{
void setHandler（Handler*pHandler）
{
穆·芬德勒=芬德勒；
}
};
//现在您可以像这样定义变量
MsgHandler myHandler；

当然，这要求MsgHandler的源参数必须是一个只有一个参数（处理程序）的模板，但如果您能够接受该约束，这将解决您的定义问题（否则您可能会（或者可能不会，具体取决于您将尝试什么）能够使用一些额外的模板foo来规避此限制（创建另一个模板，该模板将处理程序作为参数，并为相应的SourcesType创建一个typedef）

在这种情况下，最好将
typedef Source-SourceType
添加到MsgHandler中，使调用方可以看到源实例化（而不是要求程序员猜测MsgHandler将实例化源代码。
那么，处理程序是做什么的？如果我们知道这些部分做了什么，我们可以帮助您重构。您的第一个代码示例并不完全，第二个代码示例只起到了一点作用。（调用过
handleSomething
吗？）handleSomething将在收到消息时从源调用。例如，假设源是一个tcp服务器，它获取一个数据包，并使用内容调用handleSomething，消息处理程序处理该数据包，当它从源获得足够的数据来构建逻辑消息时，它将其发送到接收器。您可以想象类似的情况这是你逐行从文件中读取MSG的地方。上下文并不重要。问题完全是句法上的。这是如何实现的？不可能吗？或者有什么诀窍。我不是在寻找重构。我想知道它是否可以实现。如果你的问题是我可以定义
a
和
B
，那么答案是否定的，正如你所说的那样在你发布的错误中发现。那么，处理程序是用来做什么的？如果我们知道这些部分是什么，我们可以帮助你重构