Como usar ponteiros C ++

A memória de um computador é uma longa série de células. O tamanho de cada célula é chamado de byte. Um byte é um espaço ocupado por um caractere inglês do alfabeto. Um objeto no sentido comum é um conjunto consecutivo de bytes na memória. Cada célula tem um endereço, que é um número inteiro, geralmente escrito na forma hexadecimal. Existem três maneiras de acessar um objeto na memória. Um objeto pode ser acessado usando o que é conhecido como um ponteiro. Ele pode ser acessado usando o que é conhecido como uma referência. Ele ainda pode ser acessado usando um identificador. O foco deste artigo é o uso de indicadores e referências. Em C ++, existe o objeto apontado e o objeto ponteiro. O objeto apontado tem o objeto de interesse. O objeto de ponteiro tem o endereço para o objeto apontado.

Você precisa ter conhecimento básico em C ++, incluindo seus identificadores, funções e matrizes; entender este artigo.

O objeto ponteiro e o objeto apontado, cada um tem seu identificador.

O operador de endereço, &

Este é um operador unário. Quando seguido por um identificador, retorna o endereço do objeto do identificador. Considere a seguinte declaração:

int ptdInt;

Abaixo está o código, a seguinte expressão, retornará o endereço identificado por ptdInt:

& ptdInt

Você não precisa saber o endereço exato (número) ao codificar.

O operador de indireção, *

Este é um operador unário no contexto de ponteiros. Geralmente é digitado na frente de um identificador. Se usado em uma declaração do identificador, então o identificador é o objeto ponteiro que contém apenas o endereço do objeto apontado. Se usado na frente do identificador do objeto ponteiro, para retornar algo, então o que é retornado é o valor do objeto apontado.

Criando um Ponteiro

Dê uma olhada no seguinte segmento de código:

float ptdFloat;
float * ptrFloat;
ptrFoat = &ptdFloat;

O segmento começa com a declaração do objeto apontado, ptdFloat. ptdFloat é um identificador, que apenas identifica um objeto flutuante. Um objeto real (valor) poderia ter sido atribuído a ele, mas, neste caso, nada foi atribuído a ele. A seguir no segmento, há a declaração do objeto ponteiro. O operador de indireção na frente deste identificador significa que ele deve conter o endereço de um objeto apontado. O tipo de objeto, float no início da instrução, significa que o objeto apontado é um float. O objeto de ponteiro é sempre do mesmo tipo que o objeto apontado. ptrFoat é um identificador, que apenas identifica um objeto de ponteiro.

Na última declaração do código, o endereço do objeto apontado é atribuído ao objeto ponteiro. Observe o uso do operador de endereço, &.

A última instrução (linha) acima mostra que depois de declarar o objeto de ponteiro sem inicialização, você não precisa do operador de indireção, quando você tem que inicializá-lo. Na verdade, é um erro de sintaxe usar o operador de indireção na terceira (última) linha.

O objeto ponteiro pode ser declarado e inicializado pelo objeto apontado em uma instrução, da seguinte maneira:

float ptdFloat;
float * ptrFoat = &ptdFloat;

A primeira linha do segmento de código anterior e esta são as mesmas. A segunda e terceira linhas do segmento de código anterior foram combinadas em uma instrução aqui.

Observe no código acima que ao declarar e inicializar o objeto de ponteiro, o operador de indireção deve ser usado. No entanto, não é usado se a inicialização deve ser feita posteriormente. O objeto ponteiro é inicializado com o endereço do objeto apontado.

No segmento de código a seguir, o operador de indireção é usado para retornar o conteúdo do objeto apontado.

int ptdInt = 5;
int * ptrInt = &ptdInt;
cout << *ptrInt << '\n';

A saída é 5.

Na última declaração aqui, o operador de indireção foi usado para retornar o valor apontado pelo identificador de ponteiro. Portanto, quando usado em uma declaração, o identificador do operador de indireção conteria o endereço do objeto apontado. Quando usado em uma expressão de retorno, em combinação com o identificador de ponteiro, o operador de indireção retorna o valor do objeto apontado.

Atribuindo Zero a um Ponteiro

O objeto de ponteiro deve sempre ter o tipo do objeto apontado. Ao declarar o objeto de ponteiro, o tipo de dados do objeto apontado deve ser usado. No entanto, o valor do zero decimal pode ser atribuído ao ponteiro como no seguinte segmento de código:

int ptdInt = 5;
int * ptrInt;
ptrInt = 0;
ou no segmento,
int ptdInt = 5;
int * ptrInt = 0;

Em ambos os casos, o ponteiro (identificador) é chamado de ponteiro nulo; ou seja, não aponta para lugar nenhum. Ou seja, não possui o endereço de nenhum objeto pontiagudo. Aqui, 0 é o zero decimal e não o zero hexadecimal. O zero hexadecimal apontaria para o primeiro endereço da memória do computador.

Não tente obter o valor apontado por um ponteiro nulo. Se você tentar isso, o programa pode compilar, mas não pode ser executado.

Nome da matriz como um ponteiro constante

Considere a seguinte matriz:

int arr [] = 000, 100, 200, 300, 400;

O nome da matriz, arr é na verdade o identificador que contém o endereço do primeiro elemento da matriz. A seguinte expressão retorna o primeiro valor na matriz:

* arr

Com a matriz, o operador de incremento, ++ se comporta de maneira diferente. Em vez de adicionar 1, ele substitui o endereço do ponteiro, pelo endereço do próximo elemento na matriz. No entanto, o nome da matriz é um ponteiro constante; o que significa que seu conteúdo (endereço) não pode ser alterado ou incrementado. Portanto, para incrementar, o endereço inicial da matriz deve ser atribuído a um ponteiro não constante da seguinte maneira:

int * ptr = arr;

Agora, ptr pode ser incrementado para apontar para o próximo elemento da matriz. ptr foi declarado aqui como um objeto de ponteiro. Sem * aqui, não seria um ponteiro; seria um identificador para conter um objeto int e não para conter um endereço de memória.

O seguinte segmento de código finalmente aponta para o quarto elemento:

++ptr;
++ptr;
++ptr;

O código a seguir gera o quarto valor da matriz:

int arr [] = 000, 100, 200, 300, 400;
int * ptr = arr;
++ptr;
++ptr;
++ptr;
cout << *ptr << '\n';

A saída é 300.

Nome da função como um identificador

O nome de uma função é o identificador da função. Considere a seguinte definição de função:

int fn ()

cout << "seen" << '\n';
return 4;

fn é o identificador da função. A expressão,

& fn

retorna o endereço da função na memória. fn é como o objeto pontiagudo. A declaração a seguir declara um ponteiro para uma função:

int (* func) ();

O identificador do objeto apontado e o identificador do objeto ponteiro são diferentes. func é um ponteiro para uma função. fn é o identificador de uma função. E assim, func pode ser feito para apontar para fn da seguinte forma:

func = &fn;

O valor (conteúdo) de func é o endereço de fn. Os dois identificadores podem ter sido vinculados a uma instrução de inicialização da seguinte maneira:

int (* func) () = &fn;

Observe as diferenças e semelhanças no tratamento de ponteiros de função e ponteiros escalares. func é um ponteiro para uma função; é o objeto pontiagudo; é declarado de forma diferente de um ponteiro escalar.

A função pode ser chamada com,

fn ()
ou
função ()

Não pode ser chamado com * func ().

Quando a função possui parâmetros, os segundos parênteses possuem os tipos dos parâmetros e não precisam ter os identificadores para os parâmetros. O programa a seguir ilustra isso:

#incluir
usando namespace std;
float fn (float fl, int in)

return fl;

int main ()

float (* func) (float, int) = &fn;
float val = func (2.5, 6);
cout << val << '\n';
return 0;

A saída é 2.5.

Referência C ++

Referenciar em C ++ é apenas uma maneira de produzir um sinônimo (outro nome) para um identificador. Ele usa o operador &, mas não da mesma forma que & é usado para ponteiros. Considere o seguinte segmento de código:

int myInt = 8;
int & yourInt = myInt;
cout << myInt << '\n';
cout << yourInt << '\n';

O resultado é:

8
8

A primeira instrução inicializa o identificador, myInt; eu.e. myInt é declarado e feito para conter o valor, 8. A segunda instrução cria um novo identificador, yourInt, um sinônimo de myInt. Para conseguir isso, o operador & é colocado entre o tipo de dados e o novo identificador na declaração. As declarações cout mostram que os dois identificadores são sinônimos. Para retornar o valor neste caso, você não precisa precedê-lo com * . Basta usar o identificador.

myInt e yourInt aqui, não são dois objetos diferentes. Eles são dois identificadores diferentes que fazem referência (identificam) ao mesmo local na memória com o valor 8. Se o valor de myInt for alterado, o valor de yourInt também mudará automaticamente. Se o valor de yourInt for alterado, o valor de myInt também mudará automaticamente.

As referências são do mesmo tipo.

Referência a uma função

Assim como você pode ter uma referência a um escalar, você também pode ter uma referência a uma função. No entanto, codificar uma referência a uma função é diferente de codificar uma referência a um escalar. O programa a seguir ilustra isso:

#incluir
usando namespace std;
float fn (float fl, int in)

return fl;

int main ()

float (& func) (float, int) = fn;
float val = func (2.5, 6);
cout << val << '\n';
return 0;

A saída é 2.5.

Observe a primeira instrução na função principal, que torna func um sinônimo de fn. Ambos fazem referência à mesma função. Observe o uso único e a posição de &. Portanto, & é o operador de referência aqui e não o operador de endereço. Para chamar a função, basta usar qualquer um dos nomes.

Um identificador de referência não é o mesmo que um identificador de ponteiro.

Função que retorna um Pointer

No programa a seguir, a função retorna um ponteiro, que é o endereço do objeto apontado:

#incluir
usando namespace std;
float * fn (float fl, int in)

float * fll = &fl;
return fll;

int main ()

float * val = fn (2.5, 6);
cout << *val << '\n';
return 0;

A saída é 2.5

A primeira instrução na função, fn () existe apenas para criar um objeto de ponteiro. Observe o uso único e a posição de * na assinatura da função. Observe também como o ponteiro (endereço) foi recebido na função main () por outro objeto de ponteiro.

Função que retorna uma referência

No programa a seguir, a função retorna uma referência:

#incluir
usando namespace std;
float & fn (float fl, int in)

flutuar & frr = fl;
return frr;

int main ()

float & val = fn (2.5, 6);
cout << val << '\n';
return 0;

A saída é 2.5.

A primeira instrução na função, fn () existe apenas para criar uma referência. Observe o uso único e a posição de & na assinatura da função. Observe também como a referência foi recebida na função main () por outra referência.

Passando um ponteiro para uma função

No programa a seguir, um ponteiro, que na verdade é o endereço de um objeto flutuante apontado, é enviado como um argumento para a função:

#incluir
usando namespace std;
float fn (float * fl, int in)

return * fl;

int main ()

float v = 2.5;
float val = fn (& v, 6);
cout << val << '\n';
return 0;

A saída é 2.5

Observe o uso e a posição de * para o parâmetro float na assinatura da função. Assim que a avaliação da função fn () começa, a seguinte declaração é feita:

float * fl = & v;

Ambos fl e & v estão apontando para o mesmo objeto pontiagudo que contém 2.5. * fl na instrução de retorno não é uma declaração; significa, o valor do objeto apontado apontado pelo objeto ponteiro.

Passando uma referência a uma função

No programa a seguir, uma referência é enviada como um argumento para a função:

#incluir
usando namespace std;
float fn (float & fl, int in)

return fl;

int main ()

float v = 2.5;
flutuante val = fn (v, 6);
cout << val << '\n';
return 0;

A saída é 2.5

Observe o uso e a posição de & para o parâmetro flutuante na assinatura da função. Assim que a avaliação da função fn () começa, a seguinte declaração é feita:

flutuar & fl = v;

Passando um Array para uma Função

O programa a seguir mostra como passar uma matriz para uma função:

#incluir
usando namespace std;
int fn (int arra [])

return arra [2];

int main ()

int arr [] = 000, 100, 200, 300, 400;
int val = fn (arr);
cout << val << '\n';
return 0;

A saída é 200.

Neste programa, é a matriz que é passada. Observe que o parâmetro da assinatura da função tem uma declaração de array vazia. O argumento na chamada da função é apenas o nome de uma matriz criada.

Uma função C ++ pode retornar um array?

Uma função em C ++ pode retornar o valor de uma matriz, mas não pode retornar a matriz. A compilação do programa a seguir resulta em uma mensagem de erro:

#incluir
usando namespace std;
int fn (int arra [])

return arra;

int main ()

int arr [] = 000, 100, 200, 300, 400;
int val = fn (arr);
return 0;

Pointer of a Pointer

Um ponteiro pode apontar para outro ponteiro. Ou seja, um objeto de ponteiro pode ter o endereço de outro objeto de ponteiro. Eles ainda devem ser todos do mesmo tipo. O seguinte segmento de código ilustra isso:

int ptdInt = 5;
int * ptrInt = &ptdInt;
int ** ptrptrInt = &ptrInt;
cout << **ptrptrInt << '\n';

A saída é 5.

Na declaração de ponteiro a ponteiro, double * é usado. Para retornar o valor do objeto apontado final, double * ainda é usado.

Array of Pointers

O programa a seguir mostra como codificar uma matriz de ponteiros:

#incluir
usando namespace std;
int main ()

int num0 = 000, num1 = 100, num2 = 200, num3 = 300, num4 = 400;
int * no0 = & num0, * no1 = & num1, * no2 = & num2, * no3 = & num3, * no4 =&num4;
int * arr [] = no0, no1, no2, no3, no4;
cout << *arr[4] << '\n';
return 0;

O resultado é:

400

Observe o uso e a posição de * na declaração da matriz. Observe o uso de * ao retornar um valor na matriz. Com ponteiros de ponteiros, dois * estão envolvidos. No caso de array de ponteiros, um * já foi atendido, porque o identificador de array é um ponteiro.

Matriz de Strings de Comprimento Variável

Um literal de string é uma constante que retorna um ponteiro. Uma matriz de strings de comprimento variável é uma matriz de ponteiros. Cada valor na matriz é um ponteiro. Os ponteiros são endereços para locais de memória e são do mesmo tamanho. As strings de diferentes comprimentos estão em outro lugar na memória, não na matriz. O programa a seguir ilustra o uso:

#incluir
usando namespace std;
int main ()

const char * arr [] = "mulher", "menino", "menina", "adulto";
cout << arr[2] << '\n';
return 0;

A saída é “garota”.

A declaração do array começa com a palavra reservada, “const” para constante; seguido por “char” para o caractere, em seguida, o asterisco, * para indicar que cada elemento é um ponteiro. Para retornar uma string da matriz, * não é usado, devido à natureza implícita do ponteiro de cada string. Se * for usado, o primeiro elemento da string será retornado.

Ponteiro para uma função retornando um ponteiro

O programa a seguir ilustra como um ponteiro para uma função que retorna um ponteiro é codificado:

#incluir
usando namespace std;
int * fn ()

int num = 4;
int * inter = #
return inter;

int main ()

int * (* func) () = &fn;
int val = * func ();
cout << val << '\n';
return 0;

A saída é 4.

A declaração de um ponteiro para uma função que retorna um ponteiro é semelhante à declaração de um ponteiro para uma função comum, mas precedida por um asterisco. A primeira instrução na função main () ilustra isso. Para chamar a função usando o ponteiro, preceda-o com *.

Conclusão

Para criar um ponteiro para um escalar, faça algo como,

flutuar apontado;
float * ponteiro = &pointed;

* tem dois significados: em uma declaração, é uma indicação de um ponteiro; para retornar algo, é para o valor do objeto apontado.

O nome da matriz é um ponteiro constante para o primeiro elemento da matriz.

Para criar um ponteiro para uma função, você pode fazer,

int (* func) () = &fn;

onde fn () é uma função definida em outro lugar e func é o ponteiro.

& tem dois significados: em uma declaração, indica uma referência (sinônimo) para o mesmo objeto que outro identificador; ao retornar algo, significa o endereço de.

Para criar uma referência a uma função, você pode fazer,

float (& refFunc) (float, int) = fn;

onde fn () é uma função definida em outro lugar e refFunc é a referência.

Quando uma função retorna um ponteiro, o valor retornado deve ser recebido por um ponteiro. Quando uma função retorna uma referência, o valor retornado deve ser recebido por uma referência.

Ao passar um ponteiro para uma função, o parâmetro é uma declaração, enquanto o argumento é o endereço de um objeto apontado. Ao passar uma referência a uma função, o parâmetro é uma declaração, enquanto o argumento é a referência.

Ao passar um array para uma função, o parâmetro é uma declaração enquanto o argumento é o nome do array sem []. A função C ++ não retorna uma matriz.

Um ponteiro a ponteiro precisa de dois * em vez de um, quando apropriado.

Chrys