我有这个:
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
答案 0 :(得分:6)
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
答案 1 :(得分:0)
这是一个“最小,完整且可验证”的示例,它不仅演示了如何解决即时错误,还演示了如何创建实现Listener
的{{1}}类,同时满足条件:
ListenerInterface
和E
都是带有默认模板参数的模板化类。
首先,在此示例中定义与P
和P
对应的类:
E
接下来,定义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;
}