Interface* pInterface = 0;

#ifdef __linux__
	pInterface = new InterfaceLinux();
#else
	pInterface = new InterfaceWindows();
#endif

// Programmlogik

delete pInterface ;

Daraus wird dann irgendwie sowas:

std::auto_ptr<Interface*> pInterface(0);

#ifdef __linux__
	pInterface = new InterfaceLinux();  // Zuweisung geht so nicht mehr?!
#else
	pInterface = new InterfaceWindows();  // Zuweisung geht so nicht mehr?!
#endif

// Programmlogik 
/* Hier muss jetzt dereferenziert werden (*pInterface) oder alle Funktionen müssen auf std::auto_ptr<Interface*> umgestellt werden */

doSthWithInterface(*pInterface);

Man spart sich das delete und alles andere wird irgendwie komplizierter. Ich sehe die Vorteile nicht so recht

std::unique_ptr<Interface> pInterface;

Zur Neuzuweisung kannst du reset verwenden.

#ifdef __linux__
    pInterface.reset( new InterfaceLinux );
#else
    pInterface.reset( new InterfaceWindows );
#endif

Wobei ich mich frage, wieso die Zuweisung ins Makro stecken, und nicht den Initializer der Definition...

Interface* CreateInterface()
{
    return new
#ifdef __linux__
    InterfaceLinux();
#else
    InterfaceWindows();
#endif
}
...
    std::unique_ptr<Interface> pInterface(CreateInterface());

Oder auch

#ifdef __linux__
#define INTERFACE InterfaceLinux
#else
#define INTERFACE InterfaceWindows
#endif
...

Viele Wege führen nach Rom.

Und plötzlich braucht es weder Zeiger noch new.

Wobei, @SeppJ, ich glaub du hast da was verdreht - ich denke der Name der definiert (Interface) wird steht bei typedef rechts

Oops.
Ja, typedef ist eleganter als #define

Wobei, @SeppJ, ich glaub du hast da was verdreht - ich denke der Name der definiert (Interface) wird steht bei typedef rechts

Das kommt davon, wenn man mit einem Auge auf das define-Makro schielt.

Natürlich könnte man diese drei Klassen zusammenfassen, und gleich den Inhalt/Aufbau von Interface per Präprozessor/Build-Skript abhängig vom OS machen.

Bei der typedef Variante sehe ich jetzt aber keinen echten Nachteil.

Abgesehen vielleicht von Sachen wie z.B. wie gut sich das mit diversen Doku-Generatoren (Doxygen, ...) verträgt. Was das angeht wäre es aber vermutlich besser, wenn man eine Klasse Interface hätte, die grösstenteils unabhängig vom OS implementiert ist, und weder per typedef noch per Makro noch per Build-Skript ausgetauscht wird. D.h. entweder zurück zu der Variante die der OP eh schon hat (gemeinsame Basisklasse). Oder eine kleine Wrapper-Klasse die intern abhängig vom OS ein InterfaceLinux oder InterfaceWindows hat, und alle Calls einfach weiterleitet.