正确地调用字符串相关的函数(第二部分)

发布: 2007-7-01 20:40 | 作者: admin | 来源: | 查看: 13次 | 进入软件测试论坛讨论

在这一部分中，你将会明白在给定的字符类型中如何正确调用字符串相关的函数。在上一部分中，我们是采用定义一个宏(string_function_xparams)来实现。

对于给定函数的每一数字参数(如1，2等)，都有一个相对应的string_function_xparams函数与之匹配。给定的函数一般可以传递五个参数，如果你需要更多的参数，你可以在程序中生成自已的参数。

我将解释一下string_function_1param函数的用法(其实函数也类似)，这一函数有以下的模板参数：

CharType: 字符类型(基于正确调用字符串函数的结果)
ReturnType: 从字符串函数返回的类型
CharFunction: 当CharType 是char，则调用这一函数
WchartFunction:当CharType是wchar_t，则调用这一函数
Param1: 字符串函数的第一个参数
这一过程是这样的，首先以给定的参数调用字符串函数(CharFunction或WchartFunction)，而这一过程也是通过string_function_1param_helper函数来实现。

直接调用字符串函数而没有返回一个代理对象的原因是很难在一个类中传递一个函数。这是因为，对于每一个函数类型都需要不同的类，由于没有作为传递到类的模板参数的函数，模板类在这里不能适用。

下面的代码中列举了一系列的宏，这些宏都是有关字符串的操作方法，你可以在<string.h> 头文件中调用这些宏。

// t_char.h

#include <string.h>

#define t_strcat( CharType, param1, param2)
string_function_2params< CharType, CharType*>( strcat, wcscat, param1, param2)

#define t_strchr( CharType, str, ch)
string_function_2params< CharType, CharType*>( strchr, wcschr, param1, param2)

#define t_strcmp( CharType, param1, param2)
string_function_2params< CharType, int>( strcmp, wcscmp, param1, param2)

#define t_strcoll( CharType, param1, param2)
string_function_2params< CharType, int>( strcoll, wcscoll, param1, param2)

#define t_strcpy( CharType, param1, param2)
string_function_2params< CharType, CharType*>( strcpy, wcscpy, param1, param2)

#define t_strcspn( CharType, param1, param2)
string_function_2params< CharType, size_t>( strcspn, wcscspn, param1, param2)

#define t_strdup( CharType, strVal)
string_function_1param< CharType, CharType*>( strdup, wcsdup, strVal)

#define t_strlen( CharType, strVal)
string_function_1param< CharType, int>( strlen, wcslen, strVal)

#define t_strncat( CharType, param1, param2, param3)
string_function_3params< CharType, CharType*>( strncat, wcsncat, param1, param2, param3)

#define t_strncmp( CharType, param1, param2, param3)
string_function_3params< CharType, CharType*>( strncmp, wcsncmp, param1, param2, param3)

#define t_strncpy( CharType, param1, param2, param3)
string_function_3params< CharType, CharType*>( strncpy, wcsncpy, param1, param2, param3)

#define t_strpbrk( CharType, param1, param2)
string_function_2params< CharType, CharType*>( strpbrk, wcspbrk, param1, param2)

#define t_strrchr( CharType, param1, param2)
string_function_2params< CharType, CharType*>( strrchr, wcsrchr, param1, param2)

#define t_strspn( CharType, param1, param2)
string_function_2params< CharType, size_t>( strspn, wcsspn, param1, param2)

#define t_strstr( CharType, param1, param2)
string_function_2params< CharType, CharType*>( strstr, wcsstr, param1, param2)

#define t_strtok( CharType, param1, param2)
string_function_2params< CharType, CharType*>( strtok, wcstok, param1, param2)

#define t_strxfrm( CharType, param1, param2, param3)
string_function_3params< CharType, CharType*>( strxfrm, wcsxfrm, param1, param2, param3)

#define t_strftime( CharType, strDest, maxsize, format, timeptr)
string_function_4params< CharType, size_t>( strftime, wcsftime, strDest, maxsize, format, timeptr)

#include <string.h>

Here is an example of the macros in use:
#include <iostream>
#include <time.h>
#include <string>

template< class CharType>
struct StringConstant_t;

template<>
struct StringConstant_t< char>
{
public:
StringConstant_t( const char * str, const wchar_t * wstr)
  : m_str( str) {}

const char * value() const
{ return m_str; }
private:
const char * m_str;
};

template<>
struct StringConstant_t< wchar_t>
{
public:
StringConstant_t( const char * str, const wchar_t * wstr)
  : m_str( wstr) {}

const wchar_t * value() const
{ return m_str; }
private:
const wchar_t * m_str;
};

// based on the char type, point to
// one of the StringConstant_t< char> or
// StringConstant_t< wchar_t>
template< class CharType>
struct StringConstant;

template<>
struct StringConstant< char>
{
typedef StringConstant_t< char> constant_type;
};

template<>
struct StringConstant< signed char>
{
typedef StringConstant_t< char> constant_type;
};

template<>
struct StringConstant< unsigned char>
{
typedef StringConstant_t< char> constant_type;
};

template<>
struct StringConstant< wchar_t>
{
typedef StringConstant_t< wchar_t> constant_type;
};

#define CONST_STR( char_type, str) (( const char_type *)( StringConstant< char_type>::constant_type( str, L##str).value()))

template< class CharType>
std::basic_string< CharType> current_date_as_string()
{
const int MAX_DATE_SIZE = 256;
CharType strDate[ MAX_DATE_SIZE ];

time_t timeNow;
timeNow = time( NULL);
tm tmNow;
tmNow = *gmtime( &timeNow);
t_strftime(
  CharType, strDate, MAX_DATE_SIZE,
  CONST_STR( CharType, "%A, %d %B, %Y"),
  &tmNow);
return strDate;
}

int main(int argc, char* argv[])
{
// writing to std:;cout;
// using ’char’s
std::cout
  << "current date as ’const char *’n"
  << current_date_as_string< char>() << std::endl;
// writing to std:;wcout;
// using ’wchar_t’ characters
std::wcout
  << L"current date as ’const wchar_t *’n"
  << current_date_as_string< wchar_t>() << std::endl;

return 0;
}