Re: Template to define type names
Am 01.09.2011 18:08, schrieb Brendon:
I have some template code I want to use to define a static string with
the name of a type as shown below.
This compiles fine under Visual Studio 2010 and GCC 4.5.2 However on
windows when running, the name of the type printed below is:
"std::vector<>" not "std::vector<std::vector<int>>" as expected. I see
the correct result on Linux using GCC.
All these compilers behave conforming, see below.
I assume it has to do with the static initialization order for this
recursive template.
No, because the static initialization rules would induce a strict order.
But your static data members are only zero-initialized in order, because
std::string is not a pod (see 3.6.2 [basic.start.init] in C++03 or does
not have an initialization which is a constant expression plus does not
have a constexpr constructor in C++11. The actual initialization is
performed during the so called dynamic initialization.
And here is the crux of your problem: Your program relies on a strict
order of dynamic initialization, but the C++03 standard does not say
much about this. This has been fixed in the language via wording as shown in
http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#270
http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#362
The result of these decisions is, that dynamic initialization of static
data members of templates is *unordered* unless these members have been
explicitly specialized. But this is only true for
TypeNameTraits<int>::NAME in your example.
recursive template. What is the order meant to be in this case?
It is unordered, therefore not specified.
Any suggestions on other ways of doing this or if there is a simple
fix to this problem?
I suggest that you replace your static data members by static functions,
which contain local static variables. The latter undergo a dynamic
initialization which follows the runtime flow, like so:
#include <iostream>
#include <vector>
#include <string>
// Generic definition of template
template <typename DataT>
struct TypeNameTraits
{
inline static const std::string& NAME();
};
template <typename DataT>
inline const std::string& TypeNameTraits<DataT>::NAME() {
static const std::string result = "!UNKNOWN_TYPE_NAME!";
return result;
}
// I define a number of primitive types here
template<>
inline const std::string& TypeNameTraits<int>::NAME() {
static const std::string result = "int";
return result;
}
// Partial specialization for std::vector
template <typename DataT>
struct TypeNameTraits<std::vector<DataT> >
{
inline static const std::string& NAME();
};
template <typename DataT>
inline const std::string& TypeNameTraits<std::vector<DataT> >::NAME() {
static const std::string result = std::string("std::vector<") +
TypeNameTraits<DataT>::NAME() + ">";
return result;
}
int main()
{
std::cerr << TypeNameTraits<std::vector<std::vector<int> >
::NAME() << std::endl;
}
HTH & Greetings from Bremen,
Daniel Kr?gler
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]