CPP. C plus plus versus Java

Transcrição

1 CPP C plus plus versus Java

2 Principais Diferenças Herança a múltiplam Destructores e garbage colector Override de operadores Máquina virtual Templates e genéricos Referências e ponteiros Métodos virtuais e classes virtuais Conversão implícita de tipos usando construtores Incialização de arrays Listas de inicialização de membros Directivas de pre-processamento Declaration and implementation Bibliotecas (STL) Break e continue sem labels, for each Syntaxe

3 C++ Hello World #include <iostream> using namespace std; void hello() { cout<< Hello Wordl! ; int main(){ hello();

4 Máquina virtual O java normalmente corre numa máquina virtual enquanto que o compilador de C++ gera código máquina.

5 Herança múltipla Uma pessoa pode ser simultaneamente um estudante e um trabalhador. C++ permite herança múltipla. C++ classe TrabalhadorEstudante: public Trabalhador, public Estudante { Pode gerar problemas se houver métodos comuns a trabalhador e a estudante, mas tal pode se resolver por chamadas explicitas do tipo Trabalhador::metodo1( ) ou Estudante::metodo1( ) se a classe estiver a ser utilizada como uma das classes base não há ambiguidade.

6 Herança múltipla Java Classe TrabalhadorEstudante extends pessoa implements Trabalhador, Estudante{. Obriga e rescrever os métodos de trabalhador e de estudante, embora este possam chamar implementações de classes concretas de trabalhador e de estudante. Ou Classe TrabalhadorEstudante extends pessoa { Trabalhador trabalhador; Estudante estudante;. Mas tal não permite redefinir facilmente métodos da classe Trabalhador ou Estudante.

7 Garbage colector e destructores Em java as variáveis são removidas da memoria pelo garbage colector quando não estão a ser utilizadas. Em C++ as variáveis locais são automaticamente eliminadas, mas variáveis criadas com o operador new o malloc() tem de ser explicitamente libertadas utilizando o delete ou free()

8 Destrutores File pessoa.h class Pessoa { private: nome char*; public: Pessoa(nome char *); ~Pessoa(); char *getnome() {return nome;; File pessoa.cpp #include pessoa.h Pessoa::Pessoa(nome char *){ this->nome = new char[strlen(nome)]; strcpy(this.nome, nome); Pessoa::~Pessoa(nome char *){ cout<< destruindo uma Pessoa\n delete nome;

9 Destrutores File main.cpp #include pessoa.h main(){ Pessoa pessoa( Joaquim ); cout<<pessoa.getnome(); cout<<endl; Resultado Joaquim destruindo uma Pessoa

10 Overload de operadores #include <string.h> String& String::operator+=(conts String &s) { len+=s.len; char *p= new char[len+1]; strcpy(p,str); strcat(p,s.str); delete str; str=p; return *this; String& String::operator+(conts String &s) conts { String *result = new String(this); // Copia cada ums dos atributos // da String. result += s; // Assume que um novo char array // foi alocado. return *result; Todos os operadores podem ser redefinidos menos o ::,.*,. e?: Código de teste: String aux( Hello ); aux+= World\n ; cout<<aux; Código de teste: String aux1( Hello ); String aux2( World\n ); cout<< aux1+aux2;

11 Operator overloading O uso de operadores resulta em código mais compacto. No entanto código mais compacto é normalmente mais difícil de ler. Overload de operadores pode levar a código confuso (devido a redefinições não esperadas). Uma descrição textual é normalmente mais descritiva que um operador. Overload complica o compilador Por estas razões, não é suportado pelo java. No entanto o overload de operadores pode ser útil desde que bem utilizado.

12 Templates e genéricos Template <class Type> Type min(type a, Type b) { return (a<b)?a:b; Uma chamada da forma: int a=3, b=4; cout<<min(a, b); Queria uma instância do código da forma: int min(int a, int b) { return (a<b)?a:b; Uma chamada da forma: double b=3.2, b=4.7; cout<<min(a, b); Queria uma instancia do código da forma: double min(double a, doube b) { return (a<b)?a:b; Existem duas versões da mesma função ao contrário do mecanismo de apagamento do java.

13 Referências e ponteiros Em java todas as variáveis correspondem a apontadores para objectos com excepção dos tipos primitivos. C++ os objectos são implementados de forma semelhante a estruturas. Apontador tem de ser criados explicitamente. Ponteiros em C++ podem ser usados como em C, por exemplo com aritmética de ponteiros. Java Conta conta = new Conta(100); Conta conta2 = conta; //referencia para conta System.out.println(conta.getSaldo( )); C++ Conta conta(100); Conta conta2 = conta; // cópia membro a membro de conta cout<<conta.getsaldo(); Ou Conta *conta = new Conta(100); Conta *conta2 = &conta; cout<<(*conta).getsaldo();

14 Referências C++ (&) Referências em C++ class Artigo { Revista &revista; Autor &autor; Artigo(Autor &autor, Revista &revista); Escondem ponteiros mas deixa de ser necessário usar *. Exemplo: autor.nome = João em vez de (*autor).nome = João //autor não é um ponteiro Tem de ser incializadas e depois disso não podem apontar para outros objectos. Tal não acontece com as referências em Java. Ao contrário do java os operadores = e == referem-se ao objecto e não ao ponteiro. int &refval = val; // Ok int &refval; // error

15 Referências java Java class Artigo { Revista revista; Autor autor; Artigo(Autor autor, Revista revista) { this.autor=autor; this.revista=revista; void println() { System.out.println( autor.nome); System.out.println( revista.nome); C++ class Artigo { Revista *revista; Autor *autor; Artigo(Autor *autor, Revista *revista) { this->autor=autor; this->revista=revista; void println() { cout<<autor->nome; cout<<revista->nome;

16 Métodos virtuais Em C++ apenas os métodos com a keyword virtual podem ser redefinidos. Java C++ class Conta { public final float getsaldo(); public float deposito(); public float levantamento(); class Conta { public: float getsaldo(); virtual float deposito(); virtual float levantamento();

17 Conversão implícita Em Java conversão implícitas são efectuadas: nos tipos primitivos de char até double; de uma subclasse para uma superclasse. Exemplo: static double somaaaa(double x, double x); int x=3; long z=3; somaaaa(x,z); Ou dump(conta x); ContaAOrdem conta = new ContaAOrdem(100); Dump(conta); Em C++ quando estas conversões não são possíveis são testadas conversões definidas pelo utilizador baseadas em construtores e operadores de conversão. Exemplo: classe SmallInt { private: int value; public: SamllInt(int x) {value = x; operator int() {return value; extern SmallInt xpto(smallint s); void main() { cout<<xpto(34); // converte 34 em SamlInt, e SamlInt em int para enviar para cout

18 Cast Em Java os type cast são verificados em tempo real. ContaOrdem extends Conta { /* code */ Conta conta = new ContaOrdem(100); // Run time checked ContaOrdem contaordem = (ContaOrdem)conta; C++ tem vários tipos de type casts. ContaOrdem: Conta { /* code */ Conta *conta = new ContaOrdem(100); // C style no run time check Conta *contaordem1 = (ContaOrdem)conta; // No run time check ContaOrdem *contaordem2 = static_cast<contaordem>(conta); // Run time checked ContaOrdem *contaordem3 = dynamic_cast<contaordem>(conta);

19 Arrays: incialização de membros Em java os membros dos arrays são por defeito incializados a null. C++ podemos inicializar os arrays com outros objectos. String ar1[] = { phoenix, crane ; String ar2[] = {String(), String(1024), String( string ); String ar3[] = {1024, String(512);

20 Operador delete [] Se aplicarmos o operador delete a um array apenas o primeiro elemento é libertado da memoria. Para arrays é necessário utilizar o operador delete []. No entanto não é necessário especificar o tamanho do array que é armazenado pelo new. Exemplo: String aux = new String[100];.. delete aux; //errado!!! delete [] aux; //correcto!!!

21 Listas de inicialização de membros Java classe contaordem extends conta { contaordem(float v) { super(v); é chamado o constructor do super classe como a primeira linha do corpo do constructor. C++ classe contaordem: conta, aplicação { { contaordem(float v): conta(v), aplicação() { a chamada aos constructores das super classes é feita numa lista antes do corpo do constructor. Notar que podem ser chamados vários constructores.

22 Listas de inicialização de membros Java classe Autor { Autor(String n) {. classe Artigo { Revista revista; Autor autor; Artigo(String autor, ) { autor = new Autor(autor); O atributo autor é inicialmente inicializado com null, e só dentro do constructor é que o seu valor final é definido. C++ classe Autor { Autor(char *n) {. classe Artigo { Revista revista; Autor autor; Artigo(char *n, ): autor(n) { O atributo autor não é um ponteiro e portanto não pode ser inicializado a null. Tem de ser inicializado com na lista de incialização de membros. Tal podia ser resolvido declarando autor como um ponteiro.

23 Directivas de pre-processamento C++ permite directivas de pre-processamento como no C Exemplo1: #include <iostream> #include my_header.h Exemplo2: #ifndef STRING_H #define STRING_H.. #endif Exemplo3: #ifdef win32.. #endif #ifdef sun3.. #endif

24 Declaração e implementação No ficheiro conta.h No ficheiro conta.cpp class Conta{ float valor; float taxa; long numero; void lançajuros(); void deposito(float x); void levantamento(float x); #include conta.h void Conta::lançaJuros(){ valor+=valor*taxa; void Conta::deposito(float x){ valor+=x; void Conta::levantamento(float x){ valor-=x;

25 Sintaxe Uma classe C++ class x: superclasse1, superclasse2 { private: int x; float y; public: rtype método1(args); rtype método2(args); protected: rtype método3(args);