C++ st可以安全地放在多个头文件中RE“似乎在VS2010中不起作用”，我没有检查，但上面的代码和我的代码之间的一个区别是上面使用了默认模板参数。干杯，嗯。@Alf：那没什么区别（对我来说更干净）。但我还是改变了它只是为了确定，同样的错误。看起来又是一起违规事

---

st可以安全地放在多个头文件中RE“似乎在VS2010中不起作用”，我没有检查，但上面的代码和我的代码之间的一个区别是上面使用了默认模板参数。干杯，嗯。@Alf：那没什么区别（对我来说更干净）。但我还是改变了它只是为了确定，同样的错误。看起来又是一起违规事件。（FFS）g++和Comeau在线接受代码，MSVC 10（我也用7.1检查过）不接受。检查模板参数是否匹配似乎MSVC错误地认为

main

中的数组类型不完整。在C++0x草案N3092中，§3.9/6讨论了转换单元内数组类型的完成（当大小已知时，从不完整到完成）。对不起，我不知道MSVC的变通方法。我试过几件事，但都没有成功-（只要它被宏包装起来，宏就可以推断长度并定义长度常量。我在回答中添加了这方面的示例代码。干杯，第2段-我完全理解这些区别。在某些情况下，我们谈论的是无害的文本复制，在其他情况下，我们谈论的是链接器barf。我确切地知道什么是prod。）在我想要的功能列表中，我有一个很高的需求-没有链接器，并且是一个很好的选择；没有膨胀。其次，关于类的问题与它无关。如果我有全局静态，那么加载顺序就没有定义。我可以重新安排代码，这样我就没有全局静态，但这不是重点。我是注意，如果你有全局静态，建议就不起作用

#define FOO "foo"

const char * const FOO = "foo";

const char FOO[] = "foo";

// .h
extern const char*const STR;

// .cpp
const  char*const STR = "abc";

template< class Dummy >
struct Foo_
{
    static char const s[];
};

template< class Dummy >
char const Foo_<Dummy>::s[] = "Blah blah";

typedef Foo_<void> Foo;    // Now you can refer to Foo:s


#include <iostream>
using namespace std;
int main()
{
    cout << sizeof( Foo::s ) << " bytes: \"" << Foo::s << "\"\n";
}

#include <stddef.h>

typedef ptrdiff_t   Size;

// Substitute a more general countOf
template< Size n >
struct SizedBuf { char sizer[n]; };

template< class Type, Size n >
SizedBuf< n > countOf_( Type (&)[n] ) { return n; }

#define COUNT_OF( array ) sizeof( countOf_( array ).sizer )

#define DEF_STRING( name, value )                               \
    template< class >                                           \
    struct name##_constant_                                     \
    {                                                           \
        static char const str[];                                \
        static Size const length    = COUNT_OF( value ) - 1;    \
    };                                                          \
                                                                \
    template< class Type >                                      \
    char const name##_constant_< Type >::str[] = value;         \
                                                                \
    template< class Type >                                      \
    Size const name##_constant_< Type >::length;                \
                                                                \
    typedef name##_constant_<void>  name;


DEF_STRING( a, "Argh, MSVC!" )
DEF_STRING( b, "Blah blah" )
DEF_STRING( c, "Currently there's no 'inline' for data in C++." )


#include <iostream>

template< char const* s >
void foo() { std::cout << "foo() says: " << s << std::endl; }

int main()
{
    using namespace std;

    int const x[a::length] = {};    // Showing off compile time constant.
    foo<a::str>();                  // Showing off external linkage.

    cout << a::length << " characters: \"" << a::str << "\"." << endl;
}

#include <iostream>

#define string_constant(pName, pLiteral)                    \
        template <typename = void>                          \
        struct pName##_detail                               \
        {                                                   \
            static const char value[];                      \
        };                                                  \
                                                            \
        template <typename T>                               \
        const char pName##_detail<T>::value[] = pLiteral;   \
                                                            \
        typedef pName##_detail<> pName

string_constant(my_constant, "this is a literal");

int main()
{
    std::cout << my_constant::value << std::endl;
    std::cout << sizeof my_constant::value << std::endl;
}