O Princípio da programação para interface e o C++

Não entendi sua duvida? Pois a meu ver Interfaces não tem NADA a ver com ponteiros!

Uma interface é basicamente um “contrato” que uma classe deve implementar! Se a classe implementa uma interface ela deve seguir o contrato da interface e cada função deve fazer o que está definido “contrato” da interface ou seja, se está descrito na documentação da interface que uma função X soma dois números e retorna o resultado da soma como um inteiro, a classe que implementar essa interface tem que fazer extamente isso agora “como” ela vai fazer não importa!

Só para complementar o que eu falei antes! C++ não tem o conceito de interfaces como no java mas tem herança múltipla então dá para simular usando classes abstratas com todas as funções virtuais e fazer a classe de destino implementar essa classe.

Não. Você pode usar interfaces na forma de referências.
Pode usar interfaces na forma de templates.

E você pode usar Smart Pointers.

O uso de ponteiros em C++ é um tanto obsoleto.

Exato.

É importante não confundir a existência ou não de um conceito com a forma que ele é implementado:
http://www.guj.com.br/java/279725-interface-x-clase-abstrata/3#1477648

Em C++, não existe uma implementação explícita do conceito de interfaces, mas o que você falou, é uma das formas válidas de se usar o conceito.
O uso de templates é outra.

Essa distinção é especialmente importante em C++, pois é uma linguagem que limita pouco o programador.
Muitos conceitos devem ser conhecidos pelo programador, pois não serão impostos pela linguagem.

Não. Você pode usar interfaces na forma de referências.
Pode usar interfaces na forma de templates.

E você pode usar Smart Pointers.

O uso de ponteiros em C++ é um tanto obsoleto.

Esta é exatamente minha dúvida com ponteiros posso fazer:

Interface *obj = new ImplementaInterface();

com smartpointers :

std::auto_ptr<Interface> obj( new ImplementaInterface() );

Como seria com referência?

Fantástico o que eu precisava, muito obrigado Vini

Um exemplo usando boost::shared_ptr. Não testei, mas acredito que esse código não precise do Boost se usar C++0X e substituir o “#include <boost/shared_ptr>” por "#include <shared_ptr> e remover o “using namespace boost”.

#include <boost/shared_ptr.hpp>
#include <iostream>
using namespace std;
using namespace boost;

class UmaInterface {
public:
    virtual void umMetodo() = 0;
};

class UmaClasse: public UmaInterface {
public:
	UmaClasse() { }
	virtual void umMetodo () { cout << "UmaClasse" << endl; }
};

class OutraClasse: public UmaInterface {
public:
	OutraClasse() { }
	virtual void umMetodo () { cout << "OutraClasse" << endl; }
};

int main (int argc, char *argv[]) {
	// Java: UmaInterface ui1 = new UmaClasse();
    shared_ptr<UmaInterface> ui1 (new UmaClasse());
	// Java: UmaInterface ui2 = new OutraClasse();
    shared_ptr<UmaInterface> ui2 (new OutraClasse());
	// Java: ui1.umMetodo();
	ui1->umMetodo();
	// Java: ui2.umMetodo();
	ui2->umMetodo();
	// Java: System.out.println (ui1 instanceof UmaClasse);
	if (dynamic_pointer_cast<UmaClasse> (ui1)) cout << "true" << endl; else cout << "false" << endl;
	// Java: ui2 = (ui1 instanceof OutraClasse ? (OutraClasse) ui1 : null);
	ui2 = dynamic_pointer_cast<OutraClasse> (ui1);
	// Java: if (ui2 != null) ui2.umMetodo();
	if (ui2) 
	    ui2->umMetodo();
	// Java: if (ui2 == null) System.out.println ("Can't cast UmaClasse to OutraClasse");
	if (! ui2)
		cout << "Can't cast UmaClasse to OutraClasse" << endl;
    return 0;
}

x@ndy:

Só para complementar o que eu falei antes! C++ não tem o conceito de interfaces como no java mas tem herança múltipla então dá para simular usando classes abstratas com todas as funções virtuais e fazer a classe de destino implementar essa classe.

A herança múltipla não tem nada aver com conceito de interfaces em c++. Isso se consegue com classes "puras abstratas".

class ITeste{

private:

public:

   void doTeste()=0;

};

Edit -> Entendi o que você quis dizer lá em cima.