这段代码符合C++标准吗？

Elite

贴出相关部分的代码，
template <class T>
class TypeMessage {
    static vector<class Handler*> registry;
public:
    class Handler {
    public:
        Handler() { }
        virtual void handleEvent(const T* t) = 0;
    };
};

class On : public TypeMessage<On> {
    string comment;
public:
    On(string str) { comment = str; }
};


class Off : public TypeMessage<Off> {
    string comment;
public:
   Off( string str ) { comment = str; }
};

vector<TypeMessage<On>::Handler*> TypeMessage<On>::registry;
vector<TypeMessage<Off>::Handler*> TypeMessage<Off>::registry;
...
在VC8下编译，报错提示最后两个registry定义重复，在gcc下编译通过。
请问，这两个registry的定义是否符合C++标准？

tyc611

是正确的
应该是VC8处理有问题，我在VC9中测了一下，也没问题

Elite

多谢，在另一个论坛看到的回复是：

template <class T>
class TypeMessage {
     static vector<class Handler*> registry;
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
class Handler相当于在TypeMessage所属的namespace 引入了一个名为Handler的类，而不是你的TypeMessage<T>::Handler。在g++可以编译通过，说明g++的名字查找不标准。

我的理解是，这里的Handler对于VC8编译器来说，和下面的TypeMessage<T>::Handler没有关系，和叫HandlerB一个效果。
而在g++里，把这两者等同了。

tyc611

原帖由 Elite 于 2008-7-17 18:56 发表
多谢，在另一个论坛看到的回复是：


我的理解是，这里的Handler对于VC8编译器来说，和下面的TypeMessage::Handler没有关系，和叫HandlerB一个效果。
而在g++里，把这两者等同了。

这个回复有点扯了，Handler是内嵌类，怎能说是在TypeMessage所在名字空间引入该类？
另外，对于名字查找规则，只有VC才不遵从参数依赖查找规则（Koenig 查找），说g++的查找规则不标准有点颠倒黑白了

Elite

VC8的查找规则不了解，代码在VC9编译也是同样的错误。下面是完整代码。

1. #include <iostream>
   
2. #include <vector>
   
3. #include <string>
   
4. using namespace std;
   
5. 
   
6. template <class T>
   
7. class TypeMessage {
   
8.     static vector<class Handler*> registry;
   
9. public:
   
10.     class Handler {
    
11.     public:
    
12.         Handler() { TypeMessage<T>::registerHandler( this ); }
    
13.         virtual void handleEvent(const T* t) = 0;
    
14.     };
    
15.     void notify() {
    
16.         for(int i = 0; i < registry.size(); i++)
    
17.             registry.at(i)->handleEvent( (T*)this );
    
18.     }
    
19.     static void registerHandler(Handler* h) { registry.push_back( h ); }
    
20. };
    
21. 
    
22. class On : public TypeMessage<On> {
    
23.     string comment;
    
24. public:
    
25.     On(string str) { comment = str; }
    
26.     void start() const {  cout << "OnEvent.start - " << comment << '\n'; }
    
27. };
    
28. 
    
29. vector<TypeMessage<On>::Handler*> TypeMessage<On>::registry;
    
30. 
    
31. class Off : public TypeMessage<Off> {
    
32.     string comment;
    
33. public:
    
34.    Off( string str ) { comment = str; }
    
35.    void stop() const { cout << "OffEvent.stop - " << comment << '\n'; }
    
36. };
    
37. vector<TypeMessage<Off>::Handler*> TypeMessage<Off>::registry;
    
38. 
    
39. class MasterConsole : public On::Handler, public Off::Handler {
    
40. public:
    
41.     void handleEvent(const On* msg) {
    
42.         cout << "MasterConsole - ";
    
43.         msg->start();
    
44.     }
    
45.     void handleEvent(const Off* msg) {
    
46.         cout << "MasterConsole - ";
    
47.         msg->stop();
    
48.     }
    
49. };
    
50. 
    
51. class PowerMonitor : public On::Handler {
    
52.     public:
    
53.     void handleEvent(const On* msg){
    
54.         cout << "PowerMonitor - ";
    
55.         msg->start();
    
56.     }
    
57. };
    
58. 
    
59. int main(){
    
60.     MasterConsole mc;
    
61.     PowerMonitor pm;
    
62.     On oneEvent( " lights " ); Off thrEvent( " elevators " );
    
63.     On twoEvent( " hvac " ); Off fouEvent( " frontDoor " );
    
64. 
    
65.     oneEvent.notify();
    
66.     twoEvent.notify();
    
67.     thrEvent.notify();
    
68.     fouEvent.notify();
    
69. 
    
70.     return 0;
    
71. }
    

复制代码

void_while

vector<TypeMessage<On>::Handler*> TypeMessage<On>::registry;
vector<TypeMessage<Off>::Handler*> TypeMessage<Off>::registry;

----------------------------------------------------------------------------------------

这两句没看明白,lz能解释下么

tyc611

对了，LZ，你是用什么版本的GCC编译的，我编译通不过

另外，你应该类似地如下定义你的模板类TypeMessage：

1. 
   
2. template <class T>
   
3. class TypeMessage {
   
4. public:
   
5.     class Handler {
   
6.     public:
   
7.         Handler() { TypeMessage<T>::registerHandler( this ); }
   
8.         virtual void handleEvent(const T* t) = 0;
   
9.     };
   
10.     void notify() {
    
11.         for(int i = 0; i < registry.size(); i++)
    
12.             registry.at(i)->handleEvent( (T*)this );
    
13.     }
    
14.     static void registerHandler(Handler* h) { registry.push_back( h ); }
    
15. 
    
16. private:
    
17.     static vector<Handler*> registry;
    
18. };
    
19. 
    
20. template <typename T>
    
21. vector<typename TypeMessage<T>::Handler*> TypeMessage<T>::registry;
    

复制代码

其一，在Handler定义后定义静态成员registry，也可以通过在原程序中定义之前显示声明Handler类，此时Handler才是类中嵌套类
其二，对模板类静态成员的定义应该如上代码所示，当然你也可以显示特化它们（事实上这是编译器做的工作），比如，针对你的代码进行修改：

1. 
   
2. template<>
   
3. vector<TypeMessage<On>::Handler*> TypeMessage<On>::registry;
   
4. 
   
5. template<>
   
6. vector<TypeMessage<Off>::Handler*> TypeMessage<Off>::registry;
   

复制代码

[ 本帖最后由 tyc611 于 2008-7-17 23:27 编辑 ]

void_while

ls的兄弟能解释下么?

vector<TypeMessage<On>::Handler*> TypeMessage<On>::registry;

这样写是什么意思呢?真的没有语法错误吗?
前面是一个具体具化的vector,后面跟的是不同类型一个静态的成员变量

想不明白

[ 本帖最后由 void_while 于 2008-7-17 23:36 编辑 ]

tyc611

另外，测试了一下，在GCC中利用特化方式是不能通过连接的

tyc611

原帖由 void_while 于 2008-7-17 23:34 发表
ls的兄弟能解释下么?

vector TypeMessage::registry;

这样写是什么意思呢?真的没有语法错误吗?
前面是一个具体具化的vector,后面跟的是不同类型一个静态的成员变量

想不明白

本来应该是

1. 
   
2. template <typename T>
   
3. vector<typename TypeMessage<T>::Handler*> TypeMessage<T>::registry;
   

复制代码

它的代码相当于用On和Off两个类型去特化上面类模板的这个成员，语言标准是否允许这样做我也不清楚，关于模板规则太复杂了，也很难写得具有较好的移植性