Existe um princípio de design de software que diz para programar para interface e não para implementação, isto significa que desenvolvendo em C++ devo abusar de ponteiros e utilizar a instanciação comum apenas com variáveis locais de uso limitado?
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.[/quote]
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?
[code]void metodo(const Interface& interface) {
}
Classe x;
metodo(x);[/code]
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;
}
A herança múltipla não tem nada aver com conceito de interfaces em c++. Isso se consegue com classes “puras abstratas”.
[code]class ITeste{
private:
public:
void doTeste()=0;
};[/code]
Edit -> Entendi o que você quis dizer lá em cima.