模板、字符串文本和UNICODE

其概念是使用宏生成文本的两种形式, char 和 wchar_t ,然后让模板函数选择适合上下文的模板函数。

记住,模板函数实际上不会生成任何代码,除非有其他代码调用它们。大多数情况下,这并不重要,但对于一个图书馆来说却是如此。

这段代码没有经过测试,但我相信它会成功的。

#define LITERAL(T,x) CString_traits<T>::choose(x, L##x)

template<typename T>
struct CString_traits
{
    typedef char char_type;
    static const char * choose(const char * narrow, const wchar_t * wide) { return narrow; }
    static char choose(char narrow, wchar_t wide) { return narrow; }
};

template<>
struct CString_traits<CStringW>
{
    typedef wchar_t char_type;
    static const wchar_t * choose(const char * narrow, const wchar_t * wide) { return wide; }
    static wchar_t choose(char narrow, wchar_t wide) { return wide; }
};

template <typename T>
inline void MakeQuoted(T & str, CString_traits<T>::char_type chQuote = LITERAL(T,'"'))
{
    if (str.IsEmpty() || str[0] != chQuote)
        str.Format(LITERAL(T,"%c%s%c"), chQuote, str, chQuote);
}

这篇文章是我个人的一点点天才。

#include <malloc.h>
template<typename to, int size> to* make_stack_temporary(const char(&lit)[size], to* memory = (to*)_alloca(sizeof(to)*size)) {
    for(int i = 0; i < size; i++)
        memory[i] = lit[i];
    return memory;
}

当您在默认参数中使用alloca时,它实际上是从 来电者 的堆栈,允许您返回数组而不诉诸堆。没有动态分配,没有内存释放。_alloca是MSVC提供的一个CRT函数,所以我不提供任何可移植性保证——但是如果您使用ATL,那么无论如何这都没有问题。当然,这也意味着指针不能放在调用函数的后面,但它应该可以满足格式字符串等临时用途。对于不太可能遇到的异常处理,还有一些注意事项(请查看MSDN了解详细信息),当然,它只适用于具有相同二进制表示的字符,据我所知,这是可以放入窄字符串文字中的每个字符。我很感激,这只解决了您可能遇到的实际问题的一个子集,但它比宏的特定子集要好得多,或者每文本指定两次,等等。

您还可以使用更丑陋但行为更一致的聚合初始化。

template<typename T> some_type some_func() {
    static const T array[] = { 'a', ' ', 's', 't', 'r', 'i', 'n', 'g', ' ', 'l', 'i', 't', 'e', 'r', 'a', 'l', '\0' };
}

在具有可变模板的C++ 0x中,这个解决方案不可能被吸吮。我接近一个更好的解决方案是C++ 03,但不要屏住呼吸。

编辑:你可以这样做,imo是最好的解决方案,但仍然需要一些麻烦。

#include <iostream>
#include <array>
#include <string>

struct something {
    static const char ref[];
};

const char something::ref[] = "";

template<int N, const char(*t_ref)[N], typename to> struct to_literal {
private:
    static to hidden[N];
public:
    to_literal() 
    : ref(hidden) {
        for(int i = 0; i < N; i++)
            hidden[i] = (*t_ref)[i];
    }
    const to(&ref)[N];
};
template<int N, const char(*t_ref)[N], typename to> to to_literal<N, t_ref, to>::hidden[];

template<int N, const char(&ref)[N], typename to> const to* make_literal() {
    return to_literal<N, &ref, to>().ref;
}

int main() {
    std::wcout << make_literal<sizeof(something::ref), something::ref, wchar_t>();
    std::wcin.get();
}

您必须遍历每个文本并使其成为结构的静态成员,然后引用它,但它的工作效果要好得多。

考虑到只有两种方法可以使用模板,因此不需要使用模板 MakeQuoted() . 您可以出于相同的目的使用函数重载:

inline void MakeQuoted(CStringA& str, char chQuote = '"') 
{ 
    if (str.IsEmpty() || str[0] != chQuote) 
        str.Format("%c%s%c", chQuote, str, chQuote); 
} 


inline void MakeQuoted(CStringW& str, wchar_t chQuote = L'"') 
{ 
    if (str.IsEmpty() || str[0] != chQuote) 
        str.Format(L"%c%s%c", chQuote, str, chQuote); 
} 

当然,这是不必使用宏的最简单的方法,假设这是使用字符串实用程序库尝试基于模板的解决方案的原因。

您可以为长而复杂的函数计算出常见的功能:

template<typename CStrT, typename CharT>
inline void MakeQuotedImpl(CStrT& str, CharT chQuote,
    const CharT* literal)
{
    if (str.IsEmpty() || str[0] != chQuote) 
        str.Format(literal, chQuote, str, chQuote); 

}

inline void MakeQuoted(CStringA& str, char chQuote = '"') 
{ 
    MakeQuotedImpl(str, chQuote, "%c%s%c");
} 


inline void MakeQuoted(CStringW& str, wchar_t chQuote = L'"') 
{
    MakeQuotedImpl(str, chQuote, L"%c%s%c");
} 

我也有类似的情况。我已经做了一个源代码文件和一个头文件(当然)我排除了建设。然后通过include指令创建了另外两个包含原始源的源文件。在一个文件中,我在include之前定义UNICODE(如果尚未定义)。在另一个文件中,I#undef UNICODE(如果已定义)。源文件包含一些静态结构和一些函数,这两组char(编译时不是)在文本中是相同的。如果每个函数都有wchar_t或char作为参数,则此方法将导致两组重载函数或两组不同名称的函数(取决于头文件的写入方式,以tchar.h为例)。现在,UNICODE和ANSI版本的函数都可用于应用程序,如果头文件正确写入,则TCHAR的默认版本也是如此。如果你想让我查一下,就这么说吧。

我相信你想要 TEXT MFC宏:

TCHAR* psz = TEXT("Hello, generic string");

可以对MarkQuoted使用模板部分专用化,并根据类型使用quote。

好吧,如果你真的想模板化这个,我想我能想到的最好的东西是一个模板化的类,它存储你的文本,基于 this discussion . 像这样的:

template <typename T> class Literal;
template <> class Literal<char>
{
public:
    static const char Quote = '"';
};
template <> class Literal<wchar_t>
{
public:
    static const wchar_t Quote = L'"';
};

那么,你会用 Literal<CHAR_T>::Quote 在您的非专用但模板化的函数中。我想有点混乱,但它的好处是让函数逻辑保持不重叠,并为您提供模板化的字符串文本。