template<>
class convertor<LPSTR, LPWSTR> : public convertor_base
{};

template<>
class convertor<LPSTR, const LPWSTR> : public convertor_base
{};

/* ... etc ... */

А>template<>
А>class convertor<LPSTR, LPWSTR> : public convertor_base
А>{};

А>template<>
А>class convertor<LPSTR, const LPWSTR> : public convertor_base
А>{};

А>/* ... etc ... */
А>

#include <boost/preprocessor/seq/for_each_product.hpp>
#include <boost/preprocessor/seq/enum.hpp>

#define TYPES1 (LPSTR)(const LPSTR)(LPCSTR)(const LPCSTR)
#define TYPES2 (LPWSTR)(const LPWSTR)(LPCWSTR)(const LPWCSTR)

#define CONVERTOR(r, types) \
template<> class convertor< BOOST_PP_SEQ_ENUM(types) > : public convertor_base{};

BOOST_PP_SEQ_FOR_EACH_PRODUCT( CONVERTOR, (TYPES1)(TYPES2) )

А>template<>
А>class convertor<LPSTR, LPWSTR> : public convertor_base
А>{};

А>template<>
А>class convertor<LPSTR, const LPWSTR> : public convertor_base
А>{};

А>/* ... etc ... */
А>

template<> class convertor<LPSTR, LPWSTR> : public convertor_base{};

template<> class convertor<LPSTR, const LPWSTR> : public convertor_base{};

/* ... etc ... */

// mpl (стырено из буста)

template<bool V> struct mpl_bool { static const bool value = V; };
template<class T> struct mpl_type { typedef T type; };

template<bool V, class T> struct enable_if_c {};
template<class T> struct enable_if_c<true, T> : mpl_type<T> {};

template<bool V, class T, class E> struct select_c;
template<class T, class E> struct select_c<true, T, E> : mpl_type<T> {};
template<class T, class E> struct select_c<false, T, E> : mpl_type<E> {};

// прикладная часть

template<class C> struct is_char : mpl_bool<false> {};
template<> struct is_char<char> : mpl_bool<true> {};
template<> struct is_char<WCHAR> : mpl_bool<true> {};
template<> struct is_char<wchar_t> : mpl_bool<true> {};

template<class X> struct is_cstring : mpl_bool<false> {};
template<class C> struct is_cstring<C*> : is_char<C> {};
template<class C> struct is_cstring<C const*> : is_char<C> {};

/////////////////////////////////////////////////////////////////////////////////

// поджигаем!

class convertor_base { ..... }; // база для правильных конверторов

template<class X, class Y>
class convertor : typename enable_if_c< is_cstring<X>::value && is_cstring<Y>::value, convertor_base >::type {};

// либо

class default_convertor_base { ..... };

template<class X, class Y>
class convertor : typename select_c< is_cstring<X>::value && is_cstring<Y>::value, convertor_base, default_convertor_base >::type {};

template<typename TIfTRue, typename TIfFalse, bool tFalg> struct SelectIf;
template<typename TIfTRue, typename TIfFalse> 
    struct SelectIf<TIfTRue, TIfFalse, true> { typedef TIfTrue Type; };
template<typename TIfTRue, typename TIfFalse> 
    struct SelectIf<TIfTRue, TIfFalse, true> { typedef TIfFalse Type; };

template<typename T> struct IsStringType { enum { Value = false; }
template<T> struct IsStringType<LPCSTR> { enum { Value = true; }
// и т. д.

template<typename TLeft, typename TRight> class convertor : 
   public SelectIf< convertot_impl<TLeft, TRight>, cinveror_base, 
        IsStringType<TLeft>::Value && IsStringType<TRight>::Value >::Type {};

E>template<typename TIfTRue, typename TIfFalse, bool tFalg> struct SelectIf;
E>template<typename TIfTRue, typename TIfFalse> 
E>    struct SelectIf<TIfTRue, TIfFalse, true> { typedef TIfTrue Type; };
E>template<typename TIfTRue, typename TIfFalse> 
E>    struct SelectIf<TIfTRue, TIfFalse, true> { typedef TIfFalse Type; };

E>template<typename T> struct IsStringType { enum { Value = false; }
E>template<T> struct IsStringType<LPCSTR> { enum { Value = true; }
E>// и т. д.

E>template<typename TLeft, typename TRight> class convertor : 
E>   public SelectIf< convertot_impl<TLeft, TRight>, cinveror_base, 
E>        IsStringType<TLeft>::Value && IsStringType<TRight>::Value >::Type {};

E>ТОлько вот надо ли это?

template<class TDst, class TSrc>
class fc_convertor
{
public:
    static TDst convert(const TSrc& );
};

const LPCSTR sz = "some";
LPWSTR wsz = convertor<LPWSTR, const LPCSTR>::convert(sz);

LPWSTR wsz = new WCHAR[32];
LPCSTR sz = convertor<LPCSTR, LPWSTR>::convert(wsz);

const CHAR sz[] = "some";
LPCWSTR wsz = convertor<LPCWSTR, const CHAR(&)[5]>::convert(sz); // тут тип через функцию convert выводится

/* и т.д. */

А>Как так вот, я так и не понял

template<typename TLeft, typename TRight> class convertor_default_implementation {
   // Тут пишешь то, чо сейчас у тебя для converior<TLeft, TRight> написано
};

template<typename TLeft, typename TRight> class convertor : 
   public SelectIf< convertor_default_implementation<TLeft, TRight>, cinveror_base, 
        IsStringType<TLeft>::Value && IsStringType<TRight>::Value >::Type {
private:
    typedef SelectIf< convertor_default_implementation<TLeft, TRight>, cinveror_base, 
        IsStringType<TLeft>::Value && IsStringType<TRight>::Value >::Type TImplementation;
    // Тут реализуешь нужные конструкторы, например такой:
    convertor( const TLeft& left, const TRight& right ) : TImplementation( left, right ) {}
}

А>А что касается конкретно этого случая и предложенного к нему решения jazzer на макросах, то тут буст себя не с самой лучшей стороны показал. ИМХО. Хотя, каждому своё. Я, например, не макросоман, скорее макрософоб

А>Я думал, что сначала нужно отвечать на вопрос зачем тот или иной класс от чего-то наследовать.

struct PacketHeader { ..... };

struct Packet1a { PacketHeader hdr; ..... };
struct Packet1b : PacketHeader    { ..... };

template<class X, class Y> struct GenericConvertor { ..... };
template<class X, class Y> struct StringConvertor { ..... };

template<class X, class Y> struct convertor_traits
{
    typedef typename select_c<
        is_cstring<X>::value && is_cstring<Y>::value,
        StringConvertor<X,Y>,
        GenericConvertor<X,Y> >::type
            convertor;
};

struct DafaultConvertorImplementationSelector {};
template<typename T> struct ConvertorTypeSelector { typedef DafaultConvertorImplementationSelector Selector; };

template<typename TFrom, typename TTo>
class DefaultConvertorImplementation {
    // Тут твоя дефолтная реализация конвертора
};

template<typename TFrom, typename TTo, 
    typename TFromSelector = ConvertorTypeSelector<TFrom>::Selector, 
    typename TFromSelector = ConvertorTypeSelector<TTo>::Selector>
struct ConvertorImplementationSelector { 
    typedef DefaultConvertorImplementation<TForm, TTo> Convertor;
};

template<typename TFrom, typename TTo>
class Convertor {
    ConvertorImplementationSelector<TFrom, TTo>::Convertor theConvertor;
public:
    // Тут воспроизводишь интерфейс конвертора, раз уж наследоваться религия не позволяет, например так:
    void Convert( TFrom from, TTo to ) { theConvertor.Convert( from, to ); }
    // Ну и так далее

};

// Теперь описываем новый тип конвертора, для простых строк:
struct SimpleStringConvertorImplementationSelector {}; 
template<> struct ConvertorTypeSelector<const char*> { typedef SimpleStringConvertorImplementationSelector Selector; };
// И все другие простые строки...

// Теперь можем описать конвертор из строк в строки
class SimpleStringConvertorImplementation {
    // Тут реализуем тот конвертор, котрый ты называешь convertor_base
};

// И подключить его в нашу выбиралку
template<typename TFrom, typename TTo>, 
struct ConvertorImplementationSelector<TForm, TTo, 
        SimpleStringConvertorImplementationSelector, SimpleStringConvertorImplementationSelector> { 
    typedef SimpleStringConvertorImplementation Convertor;
};

// Мало того, теперь ты или пользователь библиотеки или ещё кто, например его пользователь
// Могут завести ещё один тип конверотра, например такой:

struct IntegerNumbersConvertorImplementationSelector {};
template<> struct ConvertorTypeSelector<int> { typedef IntegerNumbersConvertorImplementationSelector Selector; };
template<> struct ConvertorTypeSelector<unsigned int> { typedef IntegerNumbersConvertorImplementationSelector Selector; };
template<> struct ConvertorTypeSelector<long> { typedef IntegerNumbersConvertorImplementationSelector Selector; };
// и так далее, что там надо/бывает

// Теперь пишем конвертор для чисел:
template<typename TNumberFrom, typename TNumberTo>
class IntegerNumbersConvertor {
    //    ...
};
// И подключаем его в нашу выбиралку
template<typename TFrom, typename TTo>, 
struct ConvertorImplementationSelector<TForm, TTo, 
        IntegerNumbersConvertorImplementationSelector, IntegerNumbersConvertorImplementationSelector>: { 
    typedef IntegerNumbersConvertor<TFrom, TTo> Convertor;
};

// Мало того, наши возможности  намного шире!!!

// Пишем, например, конвертор из простых строк в числа
template<typename TNumber>
class SimpleStringToNumberConvertor {
    // ...
};
// И подключаем его в нашу выбиралку
template<typename TFrom, typename TTo>, 
struct ConvertorImplementationSelector<TForm, TTo, 
        SimpleStringConvertorImplementationSelector, IntegerNumbersConvertorImplementationSelector>: { 
    typedef IntegerNumbersConvertor<TFrom, TTo> Convertor;
};

// при этом это всё могут делать как клиенты, так и ты сам...

// Мало того, ты можешь пойти и ещё дальше, например так:
template<typename TElement> struct ArryaConvertorImplementationSelector { typedef TElement Element; };
template<typedef TElement> struct ConvertorTypeSelector< std::vector<TElement> > 
    { typedef ArryaConvertorImplementationSelector<TElement> Selector; };

template<typename TFromArray, typename TFromElement, typename TToArray, typename TToElement>
class DefaultArrayConvertor {
    //    Ну тут какая-то реализация
};

// И не забываем подключить его в нашу выбиралку
template<typename TFrom, typename TTo>, 
struct ConvertorImplementationSelector< TForm, TTo, 
        ArryaConvertorImplementationSelector<TFrom>, ArryaConvertorImplementationSelector<TTo> >: { 
    typedef DefaultArrayConvertor<TFrom, ArryaConvertorImplementationSelector<TFrom>::Element, 
        TTo, ArryaConvertorImplementationSelector<TTo>::Element> Convertor;
};

// Ну и так далее, на сколько хватит фантазии и потребностей и тебя и твоих клиентов :)

template<class X, class Y> struct GenericConvertor { ..... };
template<class X, class Y> struct StringConvertor { ..... };

template<class X, class Y> struct convertor_traits
{
    typedef typename select_c<
        is_cstring<X>::value && is_cstring<Y>::value,
        StringConvertor<X,Y>,
        GenericConvertor<X,Y> >::type
            convertor;
};

template<typename X, typename Y> class convertor
{
public:
    void convert( X x, Y y ) { the_convertor.convert( x, y ); }
private:
    convertor_traits<X, Y>::convertor the_convertor;
};