Question

我有这个：

template<class E, class P>
class ListenerInterface
{
public:
    virtual ListenerResponse handleEvent(E<P> *event) const = 0;
};

但是E和P都是带有默认模板参数的模板化类。

我得到了这个：

error: expected ')'
virtual ListenerResponse handleEvent(E<P> *event) const = 0;

使用cmake -std=c++14 -Wall -W -pedantic

Answer 1

E是一种类型，而不是类模板，因此E<P>格式不正确。

通过将E设为模板模板参数来声明template<template <class > class E, class P> class ListenerInterface { public: virtual ListenerResponse handleEvent(E<P> *event) const = 0; };：

template<class T>
class ListenerInterface
{
public:
    virtual ListenerResponse handleEvent(T* event) const = 0;
};

或者只采用一种类型简化您的界面：

Message

Answer 2

这是一个“最小，完整且可验证”的示例，它不仅演示了如何解决即时错误，还演示了如何创建实现Listener的{{1}}类，同时满足条件：

ListenerInterface和E都是带有默认模板参数的模板化类。

首先，在此示例中定义与P和P对应的类：

接下来，定义template <typename T = int> class Payload { public: Payload (const T & value) : value(value) {} const T value; }; template <typename T = Payload<>> class Event { public: Event (const T & payload) : payload(payload) {} const T payload; };和ListenerResponse：

ListenerInterface

请注意，class ListenerResponse { public: ListenerResponse (const std::string & message) : message(message) {} const std::string message; }; template <typename T> class ListenerInterface { public: virtual ListenerResponse handleEvent (T * event) const = 0; };已替换为template<class E, class P>。

现在，定义一个实现template <typename T>的{{1}}类：

Listener

然后定义一个ListenerInterface函数，将这些部分组合在一起：

template <typename T = Event<>>
class Listener : public ListenerInterface<T> {
public:
  ListenerResponse handleEvent (T * event) const {
    std::stringstream stream;
    stream << "Event payload value: " << event->payload.value;
    return ListenerResponse(stream.str());
  }
};

这是完整的程序，包括必要的main语句：

int main () {
  Payload<> payload(123);
  Event<> event(payload);
  Listener<> listener;
  ListenerResponse response = listener.handleEvent(&event);
  std::cout << response.message << std::endl;
}

将程序保存为#include，使用您指定的编译器标志对其进行编译，然后运行它以验证它是否产生预期的输出：

#include <iostream>
#include <sstream>
#include <string>

template <typename T = int>
class Payload {
public:
  Payload (const T & value) : value(value) {}
  const T value;
};

template <typename T = Payload<>>
class Event {
public:
  Event (const T & payload) : payload(payload) {}
  const T payload;
};

class ListenerResponse {
public:
  ListenerResponse (const std::string & message) : message(message) {}
  const std::string message;
};

template <typename T>
class ListenerInterface {
public:
  virtual ListenerResponse handleEvent (T * event) const = 0;
};

template <typename T = Event<>>
class Listener : public ListenerInterface<T> {
public:
  ListenerResponse handleEvent (T * event) const {
    std::stringstream stream;
    stream << "Event payload value: " << event->payload.value;
    return ListenerResponse(stream.str());
  }
};

int main () {
  Payload<> payload(123);
  Event<> event(payload);
  Listener<> listener;
  ListenerResponse response = listener.handleEvent(&event);
  std::cout << response.message << std::endl;
}

C ++模板化的类和泛型不起作用

2 个答案: