有没有办法知道C+中的模板中有什么样的函数+；？ 我试图用模板重写用java编写的C++代码。这里有一个例子

代码如下所示：

class IBookUpdatedHandler {
public:
    virtual ~IBookUpdatedHandler() {}
    virtual void updateBook(int bookIndex)=0;
};

class IBookFiredHandler {
public:
    virtual ~IBookUpdatedHandler() {}
    virtual void fireBook(int bookIndex)=0;
};


template <typename T>
class Dispatcher {
private:
    list<T> listeners;
    const char* methodName;

public:
    Dispatcher(const char* name) {
        this->methodName = name;
    }

    void add(T listener) {
        listeners.push_back(listener);
    }

    void dispatch() {
        // listeners loop
        for(typename list<T>::iterator pos = listeners.begin(); pos != listeners.end(); pos++)
        {
            // i don't know what is in the box .. (list<T>)..
            // call ..
            // listener could have (*pos)->do_somethig() ?
        }
    }
};

Dispatcher<IBookUpdatedHandler*> *dispatcher = new Dispatcher<IBookUpdatedHandler*>("updateBook");
Dispatcher<IBookFiredHandler*> *dispatcher = new Dispatcher<IBookFiredHandler*>("fireBook");

类IBookUpdatedHandler{
公众：
虚拟~IBookUpdatedHandler（）{}
虚拟void更新电子书（int bookIndex）=0；
};
类IBookFiredHandler{
公众：
虚拟~IBookUpdatedHandler（）{}
虚拟无效fireBook（int bookIndex）=0；
};
模板
类调度器{
私人：
列出听众名单；
const char*methodName；
公众：
调度器（常量字符*名称）{
此->方法名=名称；
}
空添加（T侦听器）{
监听器。推回（监听器）；
}
无效分派（）{
//侦听器循环
for（typename list:：iterator pos=listeners.begin（）；pos！=listeners.end（）；pos++）
{
//我不知道盒子里有什么…（列表）。。
//打电话给。。
//侦听器可以有（*pos）->do_something（）？
}
}
};
Dispatcher*Dispatcher=new Dispatcher（“更新电子书”）；
调度员*调度员=新调度员（“fireBook”）；

< >我想在<代码>调度（）/>代码>函数中调用<代码>更新> <代码> > <代码> <代码>，但是，在C++中，我认为没有办法知道类型名中的内容。

---

<强>是否存在java的“C++代码”> GETMease< /C> > <强> > /p> < p>您可以尝试使用类型来检查。
但是C++中与java一样的强大反射，你可以看到具体的实现。

---

无论如何，我不确定我是否正确理解了您的问题。

您可以尝试使用检查类型。
但是C++中与java一样的强大反射，你可以看到具体的实现。

---

无论如何，我不确定我是否正确理解了你的问题。

这个问题有点相关，接受的答案应该足够了，I。E在代码中定义一种解析器。或者你可以使用

这个问题有点相关，接受的答案应该足够了，即。E在代码中定义一种解析器。或者，您可以使用

您不能像在Java中那样在运行时选择函数。您可以使用

dynamic\u cast

确定对象的类型，然后调用适当的函数

我认为更好的解决方案是让两个类共享相同的功能：

class IBookGenericHandler {
public:
    virtual void genericBook(int bookIndex)=0;
};

class IBookUpdatedHandler:public IBookGenericHandler {
public:
    virtual ~IBookUpdatedHandler() {}
    virtual void updateBook(int bookIndex)=0;
    virtual void genericBook(int bookIndex) { updateBook(bookIndex) }
};

class IBookFiredHandler:public IBookGenericHandler {
public:
    virtual ~IBookUpdatedHandler() {}
    virtual void fireBook(int bookIndex)=0;
    virtual void genericBook(int bookIndex) { fireBook(bookIndex) }
};

---

然后，您可以在

for

循环中调用

genericBook

，它负责调用这两个函数中的哪一个。

您不能像在Java中那样在运行时选择函数。您可以使用

dynamic\u cast

确定对象的类型，然后调用适当的函数

我认为更好的解决方案是让两个类共享相同的功能：

class IBookGenericHandler {
public:
    virtual void genericBook(int bookIndex)=0;
};

class IBookUpdatedHandler:public IBookGenericHandler {
public:
    virtual ~IBookUpdatedHandler() {}
    virtual void updateBook(int bookIndex)=0;
    virtual void genericBook(int bookIndex) { updateBook(bookIndex) }
};

class IBookFiredHandler:public IBookGenericHandler {
public:
    virtual ~IBookUpdatedHandler() {}
    virtual void fireBook(int bookIndex)=0;
    virtual void genericBook(int bookIndex) { fireBook(bookIndex) }
};

---

然后您可以在

for

循环中调用

genericBook

，它负责调用这两个函数中的哪一个。

如果您使用的是最新标准（C++11，以前称为C++0x）的功能，我建议您使用lambda表达式和通用函数指针：

template <typename T> 
class Dispatcher { 
private: 
    std::list<T> listeners; 
    std::function<void(T)> caller;

public: 
    Dispatcher(function<void(T)> caller) : caller(caller) {} 

    void add(T listener) { 
        listeners.push_back(listener); 
    } 

    void dispatch() { 
        // listeners loop 
        for(typename std::list<T>::iterator pos = listeners.begin(); pos != listeners.end(); pos++) 
        {
            caller(*pos);
        }
    } 
}; 

Dispatcher<IBookUpdatedHandler*> *dispatcher1 = new Dispatcher<IBookUpdatedHandler*>( 
    [](IBookUpdatedHandler* p) { p->updateBook(0); } 
); 

Dispatcher<IBookFiredHandler*> *dispatcher2 = new Dispatcher<IBookFiredHandler*>( 
    [](IBookFiredHandler* p) { p->fireBook(0); } 
); 

模板
类调度程序{
私人：
std：：列出侦听器；
std：：函数调用方；
公众：
调度程序（函数调用方）：调用方（调用方）{}
void add（T侦听器）{
监听器。推回（监听器）；
} 
无效调度（）{
//侦听器循环
对于（typename std:：list:：iterator pos=listeners.begin（）；pos！=listeners.end（）；pos++）
{
主叫人（*pos）；
}
} 
}; 
调度程序*dispatcher1=新调度程序（
[]（IBookUpdatedHandler*p）{p->updateBook（0）；}
); 
调度程序*dispatcher2=新调度程序（
[]（IBookFiredHandler*p）{p->fireBook（0）；}
); 

如果你不能使用C++11，那么你可以用它来代替，但是它会变得不那么清晰

---

作为旁注，在大多数情况下，您应该使用

std:：vector

而不是

std:：list

如果您使用的是最新标准（C++11，以前称为C++0x）的功能，我建议您使用lambda表达式和通用函数指针：

template <typename T> 
class Dispatcher { 
private: 
    std::list<T> listeners; 
    std::function<void(T)> caller;

public: 
    Dispatcher(function<void(T)> caller) : caller(caller) {} 

    void add(T listener) { 
        listeners.push_back(listener); 
    } 

    void dispatch() { 
        // listeners loop 
        for(typename std::list<T>::iterator pos = listeners.begin(); pos != listeners.end(); pos++) 
        {
            caller(*pos);
        }
    } 
}; 

Dispatcher<IBookUpdatedHandler*> *dispatcher1 = new Dispatcher<IBookUpdatedHandler*>( 
    [](IBookUpdatedHandler* p) { p->updateBook(0); } 
); 

Dispatcher<IBookFiredHandler*> *dispatcher2 = new Dispatcher<IBookFiredHandler*>( 
    [](IBookFiredHandler* p) { p->fireBook(0); } 
); 

模板
类调度程序{
私人：
std：：列出侦听器；
std：：函数调用方；
公众：
调度程序（函数调用方）：调用方（调用方）{}
void add（T侦听器）{
监听器。推回（监听器）；
} 
无效调度（）{
//侦听器循环
对于（typename std:：list:：iterator pos=listeners.begin（）；pos！=listeners.end（）；pos++）
{
主叫人（*pos）；
}
} 
}; 
调度程序*dispatcher1=新调度程序（
[]（IBookUpdatedHandler*p）{p->updateBook（0）；}
); 
调度程序*dispatcher2=新调度程序（
[]（IBookFiredHandler*p）{p->fireBook（0）；}
); 

如果你不能使用C++11，那么你可以用它来代替，但是它会变得不那么清晰

---

作为旁注，在大多数情况下，您应该使用

std:：vector

而不是

std:：list

我想在dispatch（）函数中调用“updateBook”或“fireBook”

。。。什么意思？不能有两个同名变量。

我想在dispatch（）函数中调用“updateBook”或“fireBook”

。。。什么意思？不能有两个同名的变量。