Ponteiros C++ com exemplos

O que são ponteiros?

Em C++, um ponteiro refere-se a uma variável que contém o endereço de outra variável. Assim como as variáveis regulares, os ponteiros têm um tipo de dados. Por exemplo, um ponteiro do tipo integer pode conter o endereço de uma variável do tipo integer. Um ponteiro do tipo caractere pode conter o endereço de uma variável do tipo caractere.

Você deve ver um ponteiro como uma representação simbólica de um endereço de memória. Com ponteiros, os programas podem simular chamada por referência. Eles também podem criar e manipular estruturas de dados dinâmicas. Em C++, uma variável de ponteiro refere-se a uma variável que aponta para um endereço específico em uma memória apontada por outra variável.

Neste tutorial de C++, você aprenderá:

O que são ponteiros?
Endereços em C++
Sintaxe da declaração do ponteiro
Operador de referência (&) e operador de deferência (*)
Ponteiros e matrizes
Ponteiro NULL
Ponteiros de variáveis
Aplicação de ponteiros
Vantagens de usar ponteiros

Endereços em C++

Para entender os ponteiros C++, você deve entender como os computadores armazenam dados.

Quando você cria uma variável em seu programa C++, ela recebe algum espaço na memória do computador. O valor desta variável é armazenado no local atribuído.

Para saber a localização na memória do computador onde os dados estão armazenados, o C++ fornece o & operador (referência). O operador retorna o endereço que uma variável ocupa.

Por exemplo, se x for uma variável, &x retornará o endereço da variável.

Sintaxe da declaração do ponteiro

A declaração de C++ usa a seguinte sintaxe:

datatype *variable_name;

O tipo de dados é o tipo base do ponteiro que deve ser um tipo de dados C++ válido.
O nome_da_variável deve ser o nome da variável do ponteiro.
O asterisco usado acima para a declaração do ponteiro é semelhante ao asterisco usado para realizar a operação de multiplicação. É o asterisco que marca a variável como um ponteiro.

Aqui está um exemplo de declarações de ponteiro válidas em C++:

int    *x;    // a pointer to integer
double *x;    // a pointer to double
float  *x;    // a pointer to float
char   *ch     // a pointer to a character

Operador de referência (&) e operador de deferência (*)

O operador de referência (&) retorna o endereço da variável.

O operador de desreferência (*) nos ajuda a obter o valor que foi armazenado em um endereço de memória.

Por exemplo:

Se tivermos uma variável com o nome num, armazenada no endereço 0x234 e armazenando o valor 28.

O operador de referência (&) retornará 0x234.

O operador de desreferência (*) retornará 5.

Exemplo 1:

#include <iostream>
using namespace std;
int main() {
	int  x = 27;  
	int  *ip;        
	ip = &x;       
	cout << "Value of x is : ";
	cout << x << endl;
	cout << "Value of ip is : ";
	cout << ip<< endl;
	cout << "Value of *ip is : ";
	cout << *ip << endl;
	return 0;
}

Saída:

Como isso funciona:

Aqui está uma captura de tela do código:

Explicação do código:

Importe o arquivo de cabeçalho iostream. Isso nos permitirá usar as funções definidas no arquivo de cabeçalho sem obter erros.
Inclua o namespace std para usar suas classes sem chamá-lo.
Chame a função main(). A lógica do programa deve ser adicionada no corpo desta função. O { marca o início do corpo da função.
Declare uma variável inteira x e atribua a ela um valor de 27.
Declare uma variável de ponteiro *ip.
Armazene o endereço da variável x na variável ponteiro.
Imprima algum texto no console.
Imprima o valor da variável x na tela.
Imprima algum texto no console.
Imprima o endereço da variável x. O valor do endereço foi armazenado na variável ip.
Imprima algum texto no console.
Valor de impressão de armazenado no endereço do ponteiro.
O programa deve retornar valor após a execução bem-sucedida.
Fim do corpo da função main().

Ponteiros e matrizes

Matrizes e ponteiros funcionam com base em um conceito relacionado. Há coisas diferentes a serem observadas ao trabalhar com matrizes com ponteiros. O próprio nome da matriz denota o endereço base da matriz. Isso significa que para atribuir o endereço de uma matriz a um ponteiro, você não deve usar um e comercial (&).

Por exemplo:

p = arr;

O acima está correto, pois arr representa o endereço dos arrays. Aqui está outro exemplo:

p = &arr;

O acima está incorreto.

Podemos converter implicitamente um array em um ponteiro. Por exemplo:

int arr [20];
int * ip;

Abaixo está uma operação válida:

ip = arr;

Após a declaração acima, ip e arr serão equivalentes e compartilharão propriedades. No entanto, um endereço diferente pode ser atribuído a ip, mas não podemos atribuir nada a arr.

Exemplo 2:

Este exemplo mostra como percorrer uma matriz usando ponteiros:

#include <iostream>
using namespace std;
int main() {
	int *ip;
	int arr[] = { 10, 34, 13, 76, 5, 46 };
	ip = arr;
	for (int x = 0; x < 6; x++) {
		cout << *ip << endl;
		ip++;
	}
	return 0;
}

Saída:

Aqui está uma captura de tela do código:

Explicação do código:

Declare uma variável de ponteiro inteiro ip.
Declare um array chamado arr e armazene 6 inteiros nele.
Atribuir arr ao ip. O ip e arr se tornarão equivalentes.
Crie um para um loop. A variável de loop x foi criada para iterar sobre os elementos do array do índice 0 a 5.
Imprima os valores armazenados no endereço do IP do ponteiro. Um valor será retornado por iteração, e um total de 6 repetições será feito. O endl é uma palavra-chave C++ que significa a linha final. Esta ação permite mover o cursor para a próxima linha após a impressão de cada valor. Cada valor será impresso em uma linha individual.
Para mover o ponteiro para a próxima posição int após cada iteração.
Fim do for um loop.
O programa deve retornar algo após a execução bem-sucedida.
Fim do corpo da função main().

Ponteiro NULL

Se não houver um endereço exato a ser atribuído, a variável de ponteiro pode ser atribuída a um NULL. Deve ser feito durante a declaração. Esse ponteiro é conhecido como ponteiro nulo. Seu valor é zero e é definido em muitas bibliotecas padrão como iostream.

Exemplo 3:

#include <iostream>
using namespace std;
int main() {
	int  *ip = NULL;
	cout << "Value of ip is: " << ip;
	return 0;
}

Saída:

Aqui está uma captura de tela do código:

Explicação do código:

Declare uma variável de ponteiro ip e atribua a ela um valor NULL.
Imprime o valor da variável de ponteiro ip ao lado de algum texto no console.
O programa deve retornar o valor após a conclusão bem-sucedida.
Fim do corpo da função main().

Ponteiros de variáveis

Com C++, você pode manipular dados diretamente da memória do computador.

O espaço de memória pode ser atribuído ou reatribuído como desejar. Isso é possível pelas variáveis de ponteiro.

As variáveis de ponteiro apontam para um endereço específico na memória do computador apontado por outra variável.

Pode ser declarado da seguinte forma:

int *p;

Ou,

int* p;

No seu exemplo, declaramos a variável ponteiro p.

Ele irá armazenar um endereço de memória.

O asterisco é o operador de desreferência que significa um ponteiro para.

O ponteiro p está apontando para um valor inteiro no endereço de memória.

Exemplo 4:

#include <iostream>

using namespace std;
int main() {
	int *p, x = 30;
	p = &x;
	cout << "Value of x is: " << *p;
	return 0;
}

Saída:

Aqui está uma captura de tela do código:

Explicação do código:

Declare uma variável de ponteiro p e uma variável x com um valor de 30.
Atribua o endereço da variável x a p.
Imprima o valor da variável de ponteiro p junto com algum texto no console.
O programa deve retornar o valor após a conclusão bem-sucedida.
Fim do corpo da função main().

Aplicação de ponteiros

Funções em C++ podem retornar apenas um valor. Além disso, todas as variáveis declaradas em uma função são alocadas na pilha de chamadas de função. Assim que a função retorna, todas as variáveis da pilha são destruídas.

Os argumentos para a função são passados por valor, e qualquer modificação feita nas variáveis não altera o valor das variáveis reais que são passadas. O exemplo a seguir ajuda a ilustrar esse conceito:-

Exemplo 5:

#include <iostream>

using namespace std;
void test(int*, int*);
int main() {
	int a = 5, b = 5;
	cout << "Before changing:" << endl;
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;

	test(&a, &b);

	cout << "\nAfter changing" << endl;
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
	return 0;
}

void test(int* n1, int* n2) {
	*n1 = 10;
	*n2 = 11;
}

Saída:

Aqui está uma captura de tela do código:

Explicação do código:

Crie um protótipo de uma função chamada test que receberá dois parâmetros inteiros.
Chame a função main(). Vamos adicionar a lógica do programa dentro de seu corpo.
Declare duas variáveis inteiras a e b, cada uma com um valor de 5.
Imprima algum texto no console. O endl (linha final) moverá o cursor para começar a imprimir na próxima linha.
Imprima o valor da variável a no console junto com outro texto. O endl (linha final) moverá o cursor para começar a imprimir na próxima linha.
Imprima o valor da variável b no console junto com outro texto. O endl (linha final) moverá o cursor para começar a imprimir na próxima linha.
Crie uma função chamada test() que receba os endereços das variáveis a e b como parâmetros.
Imprima algum texto no console. O \n criará uma nova linha em branco antes que o texto seja impresso. O endl (linha final) moverá o cursor para começar a imprimir na próxima linha após a impressão do texto.
Imprima o valor da variável a no console junto com outro texto. O endl (linha final) moverá o cursor para começar a imprimir na próxima linha.
Imprima o valor da variável b no console junto com outro texto. O endl (linha final) moverá o cursor para começar a imprimir na próxima linha.
O programa deve retornar o valor após a conclusão bem-sucedida.
Fim do corpo da função main().
Definindo a função test(). A função deve receber duas variáveis de ponteiro inteiro *n1 e *n2.
Atribuindo à variável de ponteiro *n1 um valor de 10.
Atribuindo à variável de ponteiro *n2 um valor de 11.
Fim do corpo da função test().

Mesmo assim, novos valores são atribuídos às variáveis a e b dentro do teste de função, uma vez que a chamada da função é concluída, o mesmo não é refletido na função externa main.

Usar ponteiros como argumentos de função ajuda a passar o endereço real da variável na função, e todas as alterações realizadas na variável serão refletidas na função externa.

No caso acima, a função 'test' tem o endereço das variáveis 'a' e 'b.' Essas duas variáveis são diretamente acessíveis a partir da função 'test' e, portanto, qualquer alteração feita nessas variáveis é refletida na função de chamada 'a Principal.'

Vantagens de usar ponteiros

Aqui estão os prós/benefícios do uso de Ponteiros

Ponteiros são variáveis que armazenam o endereço de outras variáveis em C++.
Mais de uma variável pode ser modificada e retornada por função usando ponteiros.
A memória pode ser alocada e desalocada dinamicamente usando ponteiros.
Os ponteiros ajudam a simplificar a complexidade do programa.
A velocidade de execução de um programa melhora com o uso de ponteiros.

Resumo:

Um ponteiro se refere a uma variável que contém o endereço de outra variável.
Cada ponteiro tem um tipo de dado válido.
Um ponteiro é uma representação simbólica de um endereço de memória.
Os ponteiros permitem que os programas simulem chamada por referência e criem e manipulem estruturas de dados dinâmicas.
Matrizes e ponteiros usam um conceito relacionado.
O nome do array denota a base do array.
Se você quiser atribuir o endereço de um array a um ponteiro, não use um e comercial (&).
Se não houver um endereço específico para atribuir uma variável de ponteiro, atribua um NULL.

Alocação dinâmica de matrizes em C++ com exemplo Tipo de dados C++ Char com exemplos

Linguagem C