【求助】模板实例化时选择特化版本的问题

syncpk99

1. //
   
2. // Copyright (C) 2004-2008 Maciej Sobczak, Stephen Hutton
   
3. // Distributed under the Boost Software License, Version 1.0.
   
4. // (See accompanying file LICENSE_1_0.txt or copy at
   
5. // http://www.boost.org/LICENSE_1_0.txt)
   
6. //
   
7. 
   
8. #ifndef SOCI_USE_TYPE_H_INCLUDED
   
9. #define SOCI_USE_TYPE_H_INCLUDED
   
10. 
    
11. #include "soci-backend.h"
    
12. #include "type-ptr.h"
    
13. #include "exchange-traits.h"
    
14. 
    
15. #include <string>
    
16. #include <vector>
    
17. 
    
18. namespace soci
    
19. {
    
20. 
    
21. namespace details
    
22. {
    
23. 
    
24. class statement_impl;
    
25. 
    
26. // this is intended to be a base class for all classes that deal with
    
27. // binding input data (and OUT PL/SQL variables)
    
28. class SOCI_DECL use_type_base
    
29. {
    
30. public:
    
31.     virtual ~use_type_base() {}
    
32. 
    
33.     virtual void bind(statement_impl & st, int & position) = 0;
    
34.     virtual void pre_use() = 0;
    
35.     virtual void post_use(bool gotData) = 0;
    
36.     virtual void clean_up() = 0;
    
37. 
    
38.     virtual std::size_t size() const = 0;  // returns the number of elements
    
39. };
    
40. 
    
41. typedef type_ptr<use_type_base> use_type_ptr;
    
42. 
    
43. class SOCI_DECL standard_use_type : public use_type_base
    
44. {
    
45. public:
    
46.     standard_use_type(void * data, exchange_type type,
    
47.         bool readOnly, std::string const & name = std::string())
    
48.         : data_(data), type_(type), ind_(NULL),
    
49.         readOnly_(readOnly), name_(name), backEnd_(NULL) {}
    
50.     standard_use_type(void * data, exchange_type type, indicator & ind,
    
51.         bool readOnly, std::string const & name = std::string())
    
52.         : data_(data), type_(type), ind_(&ind),
    
53.         readOnly_(readOnly), name_(name), backEnd_(NULL) {}
    
54. 
    
55.     virtual ~standard_use_type();
    
56.     virtual void bind(statement_impl & st, int & position);
    
57.     std::string get_name() const {return name_;}
    
58.     virtual void * get_data() {return data_;}
    
59. 
    
60.     // conversion hook (from arbitrary user type to base type)
    
61.     virtual void convert_to_base() {}
    
62.     virtual void convert_from_base() {}
    
63. 
    
64. protected:
    
65.     virtual void pre_use();
    
66. 
    
67. private:
    
68.     virtual void post_use(bool gotData);
    
69.     virtual void clean_up();
    
70.     virtual std::size_t size() const { return 1; }
    
71. 
    
72.     void * data_;
    
73.     exchange_type type_;
    
74.     indicator * ind_;
    
75.     bool readOnly_;
    
76.     std::string name_;
    
77. 
    
78.     standard_use_type_backend * backEnd_;
    
79. };
    
80. 
    
81. class SOCI_DECL vector_use_type : public use_type_base
    
82. {
    
83. public:
    
84.     vector_use_type(void * data, exchange_type type,
    
85.         std::string const & name = std::string())
    
86.         : data_(data), type_(type), ind_(NULL),
    
87.         name_(name), backEnd_(NULL) {}
    
88. 
    
89.     vector_use_type(void * data, exchange_type type,
    
90.         std::vector<indicator> const & ind,
    
91.         std::string const & name = std::string())
    
92.         : data_(data), type_(type), ind_(&ind),
    
93.         name_(name), backEnd_(NULL) {}
    
94. 
    
95.     ~vector_use_type();
    
96. 
    
97. private:
    
98.     virtual void bind(statement_impl & st, int & position);
    
99.     virtual void pre_use();
    
100.     virtual void post_use(bool) { /* nothing to do */ }
     
101.     virtual void clean_up();
     
102.     virtual std::size_t size() const;
     
103. 
     
104.     void * data_;
     
105.     exchange_type type_;
     
106.     std::vector<indicator> const * ind_;
     
107.     std::string name_;
     
108. 
     
109.     vector_use_type_backend * backEnd_;
     
110. 
     
111.     virtual void convert_to_base() {}
     
112. };
     
113. 
     
114. // implementation for the basic types (those which are supported by the library
     
115. // out of the box without user-provided conversions)
     
116. 
     
117. template <typename T>
     
118. class use_type : public standard_use_type
     
119. {
     
120. public:
     
121.     use_type(T & t, std::string const & name = std::string())
     
122.         : standard_use_type(&t,
     
123.             static_cast<exchange_type>(exchange_traits<T>::x_type),
     
124.             false, name) {}
     
125.     use_type(T const & t, std::string const & name = std::string())
     
126.         : standard_use_type(const_cast<T *>(&t),
     
127.             static_cast<exchange_type>(exchange_traits<T>::x_type),
     
128.             true, name) {}
     
129.     use_type(T & t, indicator & ind,
     
130.         std::string const & name = std::string())
     
131.         : standard_use_type(&t,
     
132.             static_cast<exchange_type>(exchange_traits<T>::x_type),
     
133.             ind, false, name) {}
     
134.     use_type(T const & t, indicator & ind,
     
135.         std::string const & name = std::string())
     
136.         : standard_use_type(const_cast<T *>(&t),
     
137.             static_cast<exchange_type>(exchange_traits<T>::x_type),
     
138.             ind, false, name) {}
     
139. };
     
140. 
     
141. // special cases for char* and char[]
     
142. 
     
143. template <>
     
144. class use_type<char *> : public standard_use_type
     
145. {
     
146. public:
     
147.     use_type(char * str, std::size_t bufSize,
     
148.         std::string const & name = std::string())
     
149.         : standard_use_type(&str_, x_cstring, false, name), str_(str, bufSize) {}
     
150.     use_type(char const * str, std::size_t bufSize,
     
151.         std::string const & name = std::string())
     
152.         : standard_use_type(&str_, x_cstring, true, name),
     
153.         str_(const_cast<char *>(str), bufSize) {}
     
154.     use_type(char * str, indicator & ind, std::size_t bufSize,
     
155.         std::string const & name = std::string())
     
156.         : standard_use_type(&str_, x_cstring, ind, false, name), str_(str, bufSize) {}
     
157.     use_type(char const * str, indicator & ind, std::size_t bufSize,
     
158.         std::string const & name = std::string())
     
159.         : standard_use_type(&str_, x_cstring, ind, true, name),
     
160.         str_(const_cast<char *>(str), bufSize) {}
     
161. 
     
162. private:
     
163.     cstring_descriptor str_;
     
164. };
     
165. 
     
166. template <std::size_t N>
     
167. class use_type<char[N]> : public use_type<char *>
     
168. {
     
169. public:
     
170.     use_type(char str[], std::string const & name = std::string())
     
171.         : use_type<char *>(str, N, name) {}
     
172.     use_type(char const str[], std::string const & name = std::string())
     
173.         : use_type<char *>(str, N, name) {}
     
174.     use_type(char str[], indicator & ind,
     
175.         std::string const & name = std::string())
     
176.         : use_type<char *>(str, ind, N, name) {}
     
177.     use_type(char const str[], indicator & ind,
     
178.         std::string const & name = std::string())
     
179.         : use_type<char *>(str, ind, N, name) {}
     
180. };
     
181. 
     
182. template <std::size_t N>
     
183. class use_type<const char[N]> : public use_type<char *>
     
184. {
     
185. public:
     
186.     use_type(char str[], std::string const & name = std::string())
     
187.         : use_type<char *>(str, N, name) {}
     
188.     use_type(char const str[], std::string const & name = std::string())
     
189.         : use_type<char *>(str, N, name) {}
     
190.     use_type(char str[], indicator & ind,
     
191.         std::string const & name = std::string())
     
192.         : use_type<char *>(str, ind, N, name) {}
     
193.     use_type(char const str[], indicator & ind,
     
194.         std::string const & name = std::string())
     
195.         : use_type<char *>(str, ind, N, name) {}
     
196. };
     
197. 
     
198. // helper dispatchers for basic types
     
199. 
     
200. template <typename T>
     
201. use_type_ptr do_use(T & t, std::string const & name, basic_type_tag)
     
202. {
     
203.     return use_type_ptr(new use_type<T>(t, name));
     
204. }
     
205. 
     
206. template <typename T>
     
207. use_type_ptr do_use(T const & t, std::string const & name, basic_type_tag)
     
208. {
     
209.     return use_type_ptr(new use_type<T>(t, name));
     
210. }
     
211. 
     
212. template <typename T>
     
213. details::use_type_ptr use(T & t, std::string const & name = std::string())
     
214. {
     
215.     return details::do_use(t, name,
     
216.         typename details::exchange_traits<T>::type_family());
     
217. }
     
218. 
     
219. template <typename T>
     
220. details::use_type_ptr use(T const & t, std::string const & name = std::string())
     
221. {
     
222.     return details::do_use(t, name,
     
223.         typename details::exchange_traits<T>::type_family());
     
224. }
     
225. 
     
226. } // namespace details
     
227. 
     
228. } // namesapce soci
     
229. 
     
230. #endif // SOCI_USE_TYPE_H_INCLUDED
     

复制代码

相关代码如上，如果我定义变量const char s[] = "Hello,CONST"，并且调用use(s)或者use<const char[sizeof(s)]>(s)时，AIX的xlC编译器并不会选择特化的use_type<char[N]>或者use_type<const char[N]>，而是选择了最基本的use_type(即118行的版本)，但是exchange_traits<char[N]>并没有声明x_type，造成编译错误(并且也违反了设计的思路)。
但是如果我调用use<char[sizeof(s)]>(s)，xlC却会选择use_type<char[N]>特化版本，能够正确编译，生成的代码测试也正常。
请问为什么调用use(s)或者use<const char[sizeof(s)]>(s)时，xlC为什么不选择use_type<const char[N]>呢？如何让他选择use_type<const char[N]>呢？
谢谢！！

OwnWaterloo

看不懂……  而且没有xlC …… xlC是哪个平台的编译器？

重载解析我一直没搞懂过……   要不你试试把无关代码都删除， 看看
use -> do_use ->  这个调用链上的T分别被解析为什么类型

然后再看采取什么方法让use 解析为你需要的类型……

syncpk99

xlC是IBM AIX上的编译器，T被解析成const char [13]，下面是具体的报错信息：

1. "../../../core/exchange-traits.h", line 36.9: 1540-0130 (S) "exchange_traits<const char [13]>::x_type" is not declared.
   
2. "../../../core/use.h", line 33.27: 1540-0700 (I) The previous message was produced while processing "struct soci::details::exchange_traits<const char [13]>".
   
3. "../../../core/type-conversion.h", line 80.5: 1540-0401 (S) The member "soci::details::conversion_use_type<const char [13]>::conversion_use_type(const char [13] &, const std::string &)" is already declared.
   
4. "../../../core/type-conversion.h", line 76.5: 1540-0425 (I) "conversion_use_type" is defined on line 76 of "../../../core/type-conversion.h".
   
5. "../../../core/type-conversion.h", line 274.25: 1540-0700 (I) The previous message was produced while processing "class soci::details::conversion_use_type<const char [13]>".
   

复制代码

chenxu_ustc

vc2005 编译的时候一样有这个错误

没本

如果某个语法特性不被大多数编译器支持，稳妥的方案就是不要用它。