Ponteiros C++

Declaração

Quando realizamos operações com ponteiros, basicamente desejamos conhecer o endereço de uma variável e manipular o seu conteúdo. Para tanto, C++ nos fornece dois operadores especiais, o operador de endereços & (determina o primeiro byte do bloco ocupado pela variável) e o operador indireto de conteúdos * (retorna o conteúdo, ou seja, o valor do dado armazenado no endereço apontado).


Como qualquer variável, os apontadores precisam ser declarados. Ao declará-los, tomemos o cuidado de observar o tipo do bloco que será apontado. Por exemplo, se queremos um ponteiro apontando para uma variável char (bloco de 1 byte), devemos declará-lo como char; se o queremos apontando para uma variável int (bloco de 2 (ou 4) bytes, conforme a máquina), também devemos declará-lo como int, e assim por diante.



A declaração de um ponteiro é parecida com a declaração de outra variável qualquer. Eis a sintaxe:

tipo *nome;

onde tipo é o grupo a que pertence a variável e nome é o nome que escolhemos para a variável. Exemplo:

char *ch;
int *pi;
float *flot;



O operador unário *, mais conhecido como operador indireto, nos permite acessar o conteúdo do objeto apontado; permite, também, que o compilador saiba que a variável guardará um endereço, e não outro dado qualquer.

Quando declaramos um ponteiro, devemos inicializá-lo com algum "valor" que, de regra, será o endereço de alguma variável. Conforme vimos, C++ dispõe do operador de endereço & que permite que um apontador guarde o endereço da variável a qual se refere:

tipo *nome = &nome1;


onde nome1 é o nome da variável apontada:

char c;
int p;
float flt;


char *ch = &c;
int *pi = &p;
float *flot = &flt;


Para compreendermos melhor, vamos supor que a variável inteira p seja inicializada com o valor 257 (int p = 257; ) e que esteja localizada no endereço 0065FDF8. Então, após a atribuição do ponteiro (int *pi = &p; ), pi estará apontado para o endereço de memória 0065FDF8 e *pi será igual a p, ou seja, seu valor será exatamente os mesmos 257.




Veja as instruções:

int *p, p2;
float* flot, *flot2;



A primeira instrução declara um ponteiro p (para int) e uma variável p2 do tipo int. Já a segunda instrução declara dois ponteiros (flot e flot2) do tipo float. Observe o operador indireto * determinando os elementos da lista que serão ponteiros. Observe também que os três ponteiros ainda não foram inicializados, o que significa que eles apontam para um endereço qualquer da memória do micro. Um ponteiro, nessas circunstâncias, pode acarretar sérios problemas. Se não existir nenhum "valor" para inicializar o ponteiro, devemos inicializá-lo com 0 (zero), o que indicará que o ponteiro não se refere a nenhum objeto:

tipo *nome = 0;


Vamos escrever um simples programa Console Wizard abordando o tema:

Código:

#include <iostream>
#include <conio>
using namespace std;
main()
{
        int i = 97;      //variável int
        int *Pi = &i;    //ponteiro para int
        int *Pi2 = 0;    //Ponteiro apontando para null
        cout << "\n\tConteudo via variavel = " << i;
        cout << "\n\tEndereco via variavel = " << &i;
        cout << "\n\tConteudo via ponteiro = " << *Pi;
        cout << "\n\tEndereco via ponteiro = " << Pi;
        cout << "\n\n";
        int i2 = 98;    //variável int
        Pi2 = & i2;    //inicializa Pi2 com endereço de i2
        cout << "\n\tAgora podemos acessar *Pi2 ... "
            << *Pi2 << "\n";    //exibe o conteúdo de i2 via ponteiro
        getch();
}


Veja um exemplo equivalente no ambiente visual do C++Builder:

Código:

//---------------------------------------------------------------------------
void __fastcall TForm1::Button1Click(TObject *Sender)
{
        int i = 97;      //variável int
        int *Pi = &i;    //ponteiro para int
        int *Pi2 = 0;    //Ponteiro apontando para null
        Label1 -> Caption = "\tConteúdo via variável = " + String(i) +
                            "\n\tEndereço via variável = " +  IntToHex(int(&i), 8) +
                            "\n\tConteúdo via ponteiro = " +  *Pi  +
                            "\n\tEndereço via ponteiro = " +  IntToHex(int(Pi), 8);
        int i2 = 98;    //variável int
        Pi2 = & i2;    //inicializa Pi2 com endereço de i2
        Label2 -> Caption = "\tAgora podemos acessar *Pi2 ... " +
                            String(*Pi2);    //exibe o conteúdo de i2 via ponteiro
}
//---------------------------------------------------------------------------


O código abaixo exibe o endereço da variável:

Código:

//---------------------------------------------------------------------------
void __fastcall TForm1::Button1Click(TObject *Sender)
{
double r = 65;
Label1 -> Caption = IntToHex(int(&r), 8);

}
//---------------------------------------------------------------------------


Os exemplos acima ilustram bem o fato de que toda variável possui um endereço e de que, mesmo sem saber o endereço específico da variável, podemos armazenar esse endereço em um ponteiro.

Eh isso :3
Kibei de um site ai enqnto estudava C++ , delphi eh foda, mas enjoa .-.

Bejo na bunda ;*