template<typename CT>
class CTestString {
  public:
        CTestString(void);                                        
        CTestString(const LPCTSTR lpszStr);    
.................

   if (sizeof(CT)==2) m_bUnicode=true;
 ................
   // а гдето ниже, в какойто ф-ии пишу:
   if (m_bUnicode) m_iLength=wcslen(m_sString); else m_iLength=strlen(m_sString);

#include <iostream>
#include <string>

//Объявление общего шаблона traits'ы для всех типов символов
//(Только объявление, определения делаются только для конкретных типов символов)
template<typename> class CharTraits;

//Определение нашего типа строки использует шаблон CharTraits,
//таким образом, оно абстрагировано от конкрктных типов символов
template<typename T>
class CTestString 
{
  typedef CharTraits<T> Traits;
public:

  CTestString(const T* str) 
    : m(new T[Traits::Length(str) + 1])
  {
    Traits::Copy(m, str);
  }
  ~CTestString() 
  {
    delete[] m;
  }
  
  const T* Value() {return m;}

private:
  T* m;  
};  

//Далее можем определять traits'ы для разных типов символов
template<> 
class CharTraits<char>
{
public:
  static size_t Length(const char* str) {return strlen(str);}
  static void Copy(char* dst, const char* src) {strcpy(dst, src);}
};

template<> 
class CharTraits<wchar_t>
{
public:
  static size_t Length(const wchar_t* str) {return wcslen(str);}
  static void Copy(wchar_t* dst, const wchar_t* src) {wcscpy(dst, src);}
};

//Примеры использования:
int main() 
{
  typedef CTestString<char> String;
  typedef CTestString<wchar_t> WString;
  
  String str = "This is the ANSI string";
  WString wstr = L"This is the Unicode string";
  
  std::cout << str.Value() << std::endl;
  std::wcout << wstr.Value() << std::endl;
}

#ifdef UNICODE
...
#else
...
#endif

size_t str_len(const char *s) {return strlen(s)};
size_t str_len(const wchar_t *s) {return wcslen(s)};

template<class Type>
struct cts_traits
{
};

template<>
struct cts_traits<char>
{
    typedef char * pointer;
    typedef const char * const_pointer;
    static inline size_t used_strlen(const_pointer pStr) { return strlen(pStr); }
};

template<>
struct cts_traits<wchar_t>
{
    typedef wchar_t * pointer;
    typedef const wchar_t * const_pointer;
    
    static inline size_t used_strlen(const_pointer pStr) { return wcslen(pStr); }
};


template<typename CT>
class CTestString 
{
      typename cts_traits<CT>::pointer m_sString;
  public:
      CTestString(void);                                        

      
      void Smth()
      {
          cts_traits<CT>::used_strlen(m_sString);
      }
};

K>size_t str_len(const char *s) {return strlen(s)};
K>size_t str_len(const wchar_t *s) {return wcslen(s)};
K>

1. Traits можно сделать параметром шаблона с возможностью использования как по умолчанию, так и с явным заданием;
2. В реализации использующего кода могут потребоваться не только функции, а также и другие сущности: типы и константы;
3. Использзование Traits делает код более самодокументированным — по существующему комлекту легко создать новый;
4. Новые Traits можно реализовывать с использованием существующих (возможно, даже с применением наследования).
5. Если Trats оформлены как шаблонный класс, в некоторых случаях может оказаться очень полезным применение частичной специализации.