[Tutorial] Introdução ao C++

[Silas Martins 0]

- Introdução:

 

A base de um programa em C++ são as classes (class). Elas funcionam de forma muito parecido com as estruturas (struct), diferenciando-se por criar elementos públicos (public) ou privados (private).

 

Em uma estrutura todos os elementos são públicos, podem ser acessados por qualquer ponto do programa (desde que esteja dentro do escopo da estrutura), já os membros privados da classe podem apenas ser acessados de dentro da própria classe.

 

Exemplo:

 

class Classe1

{

private:

int x, y;

 

public:

void exibe_valores(void) { printf("%d %d", x, y); }

};

 

No exemplo anterior somente a função exibe_valores() pode ser acessada pelo resto do programa, os valores x e y são privados para o uso da classe.

 

- Operadores new e delete:

 

As funções de new e delete são as mesma de malloc() e free(), ou seja, alocar memória dinamicamente. As vantagens de new e delete é que não são funções são operadores, sendo assim mais rápidos e são mais seguros para alocar memória do que malloc().

 

Obs: Nunca misture as duas técnicas! Nunca aloque com new e desaloque com free() (ou vice-versa). Isto pode resultar em um erro fatal.

 

Exemplo:

 

void main(void)

{

int *x;

 

x = new int;

x = 8;

}

 

Para declarar um vetor com new utilize:

 

int *x;

 

x = new int[10];

 

Logo x será um ponteiro para um vetor de dez elementos.

 

- A palavra-chave inline

 

Em C/C++ quando você chama uma função ela é alocada na memória (mais precisamente na pilha) para então ser executada. Mas em C++ existe o inline que é um operador que inclui as linhas desta função dentro do programa. Ou seja, a função deixa de ser função e torna-se parte do corpo do programa.

 

Exemplo:

 

inline void oi(void)

{

printf("OI!n");

}

 

void main(void)

{

oi();

printf("Eu disse: ");

oi();

}

 

Quando o programa for compilado ele ficará da seguinte forma:

 

void main(void)

{

printf("OI!n");

printf("Eu disse: ");

printf("OI!n");

}

 

A palavra-chave inline substitui a função, colocando-a no programa. Isto torna o programa mais rápido, mas cuidado o uso abusivo de uma função inline pode fazer o tamanho físico de seu programa aumentar monstruosamente.

 

- Métodos

 

Método é a palavra dada para as funções que são declaradas dentro de uma classe. Logo eles são funções comuns podendo retornar valores, receber parâmetros.

 

Exemplo:

 

class Classe1

{

private:

int x, y;

 

public:

void define_valores(int temp_x, int temp_y);

void imprime_valores(void) { printf("%d %d", x, y); }

};

 

Classe1::define_valores(int temp_x, temp_y)

{

x = temp_x;

y = temp_y;

}

 

A classe do exemplo anterior tem dois métodos, define_valores() e imprime_valores(). Onde um armazena valores nas variáveis privadas x e y e o outro imprime os valores das variáveis privadas na tela.

 

Como você pode notar o conteúdo do método define_valores() está escrito dentro da própria classe e do método imprime_valores() está escrito fora da classe. Aparentemente isso pode não trazer grandes diferenças mas há uma diferença crucial. Os métodos escritos fora da classe serão utilizados como funções comuns e os métodos escritos dentro da classe serão utilizados como funções inline.

 

Logo imprime_valores() é inline e define_valores() é uma função comum.

 

- Funções contrutoras e funções destrutoras

 

Esta duas funções são características bastante interessante do C++. Como os próprios nomes sugerem a função contrutora será chamada quando a classe for criada e a função destrutora será chamada quando a classe for destruida. Logo elas são importantes no caso de alocação dinâmica, usando a função contrutora para armazenar um buffer e a destrutora para apaga-lo.

 

A função contrutora e a destrutora levam sempre o mesmo nome da classe, a diferença é que a destrutora tem um til (~) antes do nome. Estas duas funções não retornam nenhum valor, logo não sem de nenhum tipo, mas a função contrutora pode receber parâmetros.

 

Exemplo:

 

class Classe1

{

private:

int *x, *y;

 

public:

Classe1(void)

{

x = new int;

y = new int;

}

~Classe1(void)

{

delete x;

delete y;

}

void define_valores(int tempx, int tempy);

void imprime_valores(void);

};

 

void Classe1::define_valores(int tempx, int tempy)

{

x = tempx;

y = tempy;

}

 

void Classe1::imprime_valores(void)

{

printf("%d %d", x, y);

}

 

void main(void)

{

Classe1 teste;

 

teste.define_valores(10, 5);

teste.imprime_valores();

}

 

No exemplo acima a função contrutora é chamada no seguinte ponto:

Classe1 teste;

Quando ela é criada ela chama a função Classe1(void) e aloca as duas variáveis dinâmicas na memória.

Já a função destrutora é chamada quando acaba o programa, por uma questão de escopo. Se a classe houvesse sido criada dentro de um bloco de um laço for ela seria dentruída quando a laço acabasse.

 

Você pode ter notado que tanto a função contrutora quanto a função destrutora na classe acima são funções inline, por terem sido escritas dentro do corpo da classe. Mas também é possível faze-las como uma função comum.

 

Exemplo:

 

class Classe1

{

private:

int *x, *y;

 

public:

Classe1(void) ;

~Classe1(void);

void define_valores(int tempx, int tempy);

void imprime_valores(void);

};

 

Classe1::Classe1(void)

{

x = new int;

y = new int;

}

 

Classe1::~Classe1(void)

{

delete x;

delete y;

}

 

void Classe1::define_valores(int tempx, int tempy)

{

x = tempx;

y = tempy;

}

 

void Classe1::imprime_valores(void)

{

printf("%d %d", x, y);

}

 

- Herança

 

A herança com certeza é a característica que deixa as linguagens orientadas a objetos tão forte e úteis.

 

tutorial cedido por: Victor

este tutorial se encontra também em: Webtutoriais

[quitZAUMMM 18]

acabei lendo isso hj =//

achei ótimo Silas, obrigado pela contribuição.

 

http://forum.imasters.com.br/public/style_emoticons/default/thumbsup.gif