这个模板写的到底有什么问题？为什么老是报重复定义？

abcbuzhiming

这是我接受的一个代码，试图做一个对象工厂，把类名传入对象工厂，让工厂制造对象

工厂类声明
ClassFactory.h

1. #ifndef __CLASSFACTORY_H__
   
2. #define __CLASSFACTORY_H__
   
3. 
   
4. #include <string>
   
5. #include <map>
   
6. 
   
7. typedef void* (*FactoryMethod)(void);
   
8. //class Registry;
   
9. 
   
10. 
    
11. 
    
12. /*
    
13.   * 这个类是用来存储<name, create object function>对,
    
14.   * 也就是个对象工厂.
    
15.   */
    
16. class ClassFactory
    
17. {
    
18. public:
    
19.      static ClassFactory forName(std::string name);
    
20.      
    
21. public:
    
22.      void* newInstance(void);
    
23.      
    
24. private:
    
25.      friend class Registry;
    
26.      static bool registerClass(std::string name, FactoryMethod method);
    
27.      
    
28. private:
    
29.      static std::map<std::string, FactoryMethod> registry;   
    
30.      std::string name;
    
31.      
    
32.      explicit ClassFactory(std::string n) : name(n)
    
33.      {};
    
34. };
    
35. 
    
36. 
    
37. class Registry
    
38. {
    
39. public:
    
40.      Registry(const char* name, FactoryMethod method)
    
41.      {
    
42.          ClassFactory::registerClass(name, method);
    
43.      };
    
44. };
    
45. 
    
46. /*
    
47.   *  mixed template, generate new instance for every class.
    
48.   */
    
49. 
    
50. /*
    
51.   * static member, initiliazed before enter into main()
    
52.   * call Class::registerClass by ctor of Registry
    
53.   */
    
54. template <class T, const char name[]>
    
55. class Registed
    
56. {
    
57. public:
    
58.         static void* newInstance(void)
    
59.         {
    
60.                 return new T();
    
61.         };
    
62. 
    
63. protected:
    
64.         Registed()
    
65.         {
    
66.                 const Registry& dummy = r;
    
67.         };
    
68. 
    
69. private:
    
70.         static const Registry r;
    
71. };
    
72. template <class T, const char name[]> const Registry
    
73.         Registed<T, name>::r = Registry(name, Registed<T, name>::newInstance);      //特化
    
74. 
    
75. #define REG_CLASS(CLASS) \
    
76. char NameArray[] = #CLASS; \
    
77. class CLASS : public Registed<CLASS, NameArray>
    
78. 
    
79. 
    
80. #endif // __CLASS_H__
    

复制代码

ClassFactory.cpp

1. #include "ClassFactory.h"
   
2. 
   
3. std::map<std::string, FactoryMethod> ClassFactory::registry;
   
4. 
   
5. ClassFactory ClassFactory::forName(std::string name)
   
6. {
   
7.         return ClassFactory(name);
   
8. };
   
9. 
   
10. void* ClassFactory::newInstance(void)
    
11. {
    
12.         std::map<std::string, FactoryMethod>::const_iterator find;
    
13.         find = registry.find(name);
    
14.         if (find == registry.end())
    
15.                 return NULL;
    
16.         else
    
17.                 return (find->second)();
    
18. };
    
19. 
    
20. bool ClassFactory::registerClass(std::string name, FactoryMethod method)
    
21. {
    
22.         return registry.insert(std::make_pair(name, method)).second;
    
23. };
    

复制代码

希望用工厂类制造的一个示范类
User.h

1. #ifndef _User_H_
   
2. #define _User_H_
   
3. 
   
4. #include "cocos2d.h"
   
5. #include "ClassFactory.h"
   
6. 
   
7. USING_NS_CC;
   
8. 
   
9. REG_CLASS(User)
   
10. {
    
11. public:
    
12.         User(){};
    
13.         void test();
    
14. 
    
15. };
    
16. 
    
17. #endif
    

复制代码

User.cpp

1. #include "User.h"
   
2. 
   
3. void User::test(){
   
4.         CCLog("User test");
   
5. }

复制代码

现在最古怪的问题在于，如果在任何其它地方引用了User.h，编译器就会报错
error LNK2005: "char * NameArray" (?NameArray@@3PADA) 已经在 xxxxxx.obj 中定义(xxxxx是引用User.h)的源码文件名
，根源在于ClassFactory.h里有这么一段宏

1. #define REG_CLASS(CLASS) \
   
2. char NameArray[] = #CLASS; \
   
3. class CLASS : public Registed<CLASS, NameArray>

复制代码

为什么这段宏会造成这个问题？

其次是请解释一下该头文件里这段代码到底干了什么

1. template <class T, const char name[]> const Registry
   
2.         Registed<T, name>::r = Registry(name, Registed<T, name>::newInstance);

复制代码

myworkstation

回复 1# abcbuzhiming


    char NameArray[] = #CLASS; 是在头文件中定义的，REG_CLASS(User)，拉展开来就是char NameArray[] = “User”，这是个定义，所以每个包含User.h的cpp文件都定义了char NameArray[] = “User”，引用几次就定义了几个，这违返了ODR原则，最终导致相同符号多于一次的定义。所以你不能这么去定义NameArray。

至于

1.     template <class T, const char name[]> const Registry
   
2.             Registed<T, name>::r = Registry(name, Registed<T, name>::newInstance);

复制代码

则是模板类静态数据成员的初始化。

myworkstation

这是个简单的模板类静态数据成员的初始化的代码，你可能容易理解一些。

1. template<class T> class X {
   
2. static T s;
   
3. };
   
4. template<class T> T X<T>::s = 0;

复制代码

Aquester

myworkstation 发表于 2013-08-23 17:35
回复 1# abcbuzhiming

用static修饰一下，限定NameArray范围

myworkstation

回复 4# Aquester
这引出了一个有趣的问题，2003的标准中说这个特性将来要废弃（global static)，结果到11标准的时候这个特性反而又被允许了（不再是废弃状态），主要原因是如果废弃将引与有C的严重不兼容以及链接器在处理不具名的命名空间的模板实例化时符号处理会引入额外的负担。

   

cxytz01

1.     template <class T, const char name[]> const Registry
   
2.             Registed<T, name>::r = Registry(name, Registed<T, name>::newInstance);

复制代码

举例
class Abc {
    static const int i;
}

const int Abc::i = 0;   // const 变量需要初始化

-------------------------------------------------------------------
static const Registry r; 是属于类模板的static const数据成员，需要初始化。
因此需要
在类外
const Registry Registed::r = Registry(name, Registed<T, name>::newInstance);
又由于Registed是模板类，所以
template <class T, const char name[]> const Registry Registed<T, name>::r = Registry(name, Registed<T, name>::newInstance);

cxytz01

myworkstation 发表于 2013-08-23 23:06
回复 4# Aquester
这引出了一个有趣的问题，2003的标准中说这个特性将来要废弃（global static)，结果到1 ...

你说的c++ 2003标准是指<<c++ primer 4edtion>>中的版本吗？
这本书内是建议使用unname namespace来替global static。

c++11提示了恢复static， 有没有链接看看？

abcbuzhiming

myworkstation 发表于 2013-08-23 17:35
回复 1# abcbuzhiming
挀栀愀爀 NameArray[] = #CLASS; 是在头文件中定义的，REG_CLASS(User)，拉展开来就是char NameArray[] = “User”，这是个定义，所以每个包含User.h的cpp文件都定义了char NameArray[] = “User”，引用几次就定义了几个，这违返了ODR原则，最终导致相同符号多于一次的定义。所以你不能这么去定义NameArray。

嗯，看懂了，等于重复定义了一个全局char数组，我的本意是想把类名作为字符串传入类工厂，不能这么定义的话，该怎么写这段宏？

myworkstation

回复 7# cxytz01


    C++ 03:
[C++03: 7.3.1.1/2]: The use of the static keyword is deprecated when declaring objects in a namespace scope (see annex D); the unnamed-namespace provides a superior alternative.

  C++ 11 proposed and accepted for n3296 :


    ID: FI 6
    Ref: D.2 [depr.static] ¶ Paragraph 1
    Comment: The use of static in namespace scope should not be deprecated. Anonymous namespaces are not a sufficient replacement for the functionality.
    Proposed Resolution: Strike [depr.static] completely.
    Owner: CWG
    Issue: 1012
    Disposition: ACCEPTED


链接：
http://www.open-std.org/jtc1/sc2 ... 2011/n3296.html#FI6

myworkstation

回复 8# abcbuzhiming


    4楼Aquester说的static是个方法，这样就使得每一个引用了user.h的cpp具有一个NameArray的实例（NameArray此时linkage 是internal），具体的说虽然都可以使用NameArray，但NameArray并不是同一个对象，只是内容相同的不同对象。另外你可以试试用define去定义NameArray。