C / C++ / MFC

template<class char_type>
void OutString(const char_type* string)
{
  ASSERT(FALSE);
}
 
template<> void OutString<char>(const char* string)
{
   std::out << string;
}
 
template<> void OutString<wchar_t>(const wchar_t* string)
{
   std::wout << string;
}

template<class T>
void mytemp<T>::show_info(const char_type* c1, const char_type* c2)
{
   basic_stringstream<char_type, char_traits<char_type>, allocator<char_type> > os;
   LoadCharStream(os, c1, c2);
   show_string(os.str());
}
 
template<class T>
void mytemp<T>::LoadCharStream(wstringstream& os, const wchar_t* c1, const wchar_t* c2)
{
   os << L"some text: '" << c2 << L"' following '" << c1 << L"'";
}
 
template<class T>
void mytemp<T>::LoadCharStream(stringstream& os, const char* c1, const char* c2)
{
   os << "some text: '" << c2 << "' following '" << c1 << "'";
}

// in header
template <typename CharacterType >
class Foo
{
public:
    void DoFoo(CharacterType Char);
};

template <typename CharacterType>
void Foo<CharacterType>::DoFoo(CharacterType Char)
{
    // what is CharacterType?
    // do some type dependant stuff
}

>// in header
template <typename CharacterType >
class CharacterDependantClass
{
public:
    void DoFoo(CharacterType Char);
};

template <typename CharacterType>
void CharacterDependantClass<CharacterType>::DoFoo(CharacterType Char)
{
    // what is CharacterType?
    // do some type dependant stuff
}

// after the implementation
// use a typedef that you use throughout your program
#ifdef UNICODE
typedef CharacterDependantClass<wchar_t> ClassType;
#else
typedef CharacterDependantClass<char> ClassType;
#endif

// this class uses a policy to turn off observers
template <typename CharType,
          class ObserverPolicy
         >
class YourAlgorithmClass
{
public:
    // ...
    void AddObserver( Observer* pObs );
    // more observer mehtods depending on your needs
protected:
    // the overloads. The compiler will choose the right overload for
    // CharType. In the overload for wchar_t, you can convert the message
    // to a char string and call the other overload.
    //
    // You don't even need the overloads here, but you can 
    // place the overloads in the observer class
    // it's a matter of your own taste.
    void SendMessageToObservers(char* pszMessage);
    void SendMessageToObservers(wchar_t* pszMessage);

private:
    std::vector<Observer*> m_Observers;
};

// In the implementation you can use the ObserverPolicy to turn off and on
// the observers.
template <typename CharType, class ObserverPolicy>
void YourAlgorithmClass<CharType, ObserverPolicy>::SendMessageToObservers(char* pszMessage)
{   // the compiler will use this method depending on the policy.
    // if the method returns false, the function does nothing and the 
    // compiler should omit the call
    // 
    // note that I used 'should' since I don't don't if every compiler 
    // is this smart
    if( !ObserverPolicy::UseObservers() )
        return; 

    // notify observers here
}

// ...
// A policy class could look like this:
class UseObservers
{
public:
    static bool UseObservers() { return true; }
}

// or for no observers
class DontUseObservers
{
public:
    static bool UseObservers() { return false; }
}

// Get the selected color from the CColorDialog.
CColorDialog dlg;
if (dlg.DoModal() == IDOK)
{
   COLORREF color = dlg.GetColor();
   TRACE("RGB value of the selected color - red = %u, 
      green = %u, blue = %u\n",
      GetRValue(color), GetGValue(color), GetBValue(color));
}