Este artigo é sobre o conceito de ponteiro para ponteiro em C++. O ponteiro para ponteiro aponta ou armazena o endereço de outro ponteiro e permite a manipulação dos próprios ponteiros. Usando este conceito, podemos facilmente modificar um ponteiro de outro local na memória. Ponteiros duplos são benéficos em memória alocada dinamicamente ou matrizes multidimensionais para manipular os elementos de uma matriz. Discutiremos esse ponteiro para o funcionamento e uso do ponteiro em C++ com exemplos adequados.
Cenário 1: Representação de memória de ponteiro para ponteiro
Neste cenário, a declaração do ponteiro duplo é semelhante à declaração do ponteiro com um asterisco adicional (*) antes do nome do ponteiro. Podemos representar facilmente a localização da memória de um ponteiro duplo em C++. O trecho de código do ponteiro para ponteiro é fornecido a seguir:
#include
usando namespace std;
principal interno ( )
{
dígito interno = cinquenta ;
interno * prr;
ptr = & dígito;
interno ** ptrr1;
ptrr1 = & prr;
corte << 'O endereço de memória do ponteiro é: \n ' ;
corte << 'ptrr (ponteiro):' << ptrr << ' \n ' ;
corte << '*ptrr1 (ponteiro duplo):' <<* ptrr1 << ' \n ' ;
corte << 'O valor armazenado no ponteiro é: \n ' ;
corte << '*ptrr =' <<* ptrr << fim;
corte << '**ptrr1 (ponteiro para ponteiro) =' <<** ptrr1 << fim;
retornar 0 ;
}
Na função principal, pegamos uma variável cujo endereço de memória precisa ser armazenado em um ponteiro. Agora, inicializamos a variável “dígito”. Depois disso, declaramos o ponteiro “ptrr” que armazena o endereço de memória “dígito”. Agora, declaramos o ponteiro duplo cujo nome é “**ptrr1” que armazena o endereço do ponteiro “*ptrr”. Ao final do código, exibimos a memória e o valor do ponteiro e do ponteiro duplo na tela do console. A saída deste código é mencionada a seguir:
O endereço de memória do ponteiro “ptrr” é “0x6ffe04”, e o ponteiro “*ptrr1” também armazena o endereço de memória do ponteiro “ptrr”. O valor armazenado dentro do ponteiro é “50”. Basicamente, o endereço do ponteiro duplo é sempre igual ao endereço de memória do ponteiro.
Cenário 2: ponteiro para ponteiro como parâmetro de função
Neste cenário aprenderemos como passar o ponteiro duplo em qualquer função como parâmetro para realizar a alocação de memória temporária em qualquer variável. O trecho de código do parâmetro de função com ponteiro duplo é mencionado a seguir:
#include
void getMemoryAddress ( interno ** duplo_ptr ) {
você clima = 200 ;
* duplo_ptr = & temperatura;
}
principal interno ( ) {
interno * ptr_1;
interno ** duplo_ptr;
duplo_ptr = & ptr_1;
getMemoryAddress ( duplo_ptr ) ;
std::cout << 'O valor de **double_ptr é:' << ** duplo_ptr << std::endl;
retornar 0 ;
}
Aqui, aprenderemos como funciona o conceito de ponteiro para ponteiro em C++. Lembre-se de que um ponteiro é declarado no programa para funcionar com um ponteiro duplo. Então, construímos a função “getMemoryAddress”. Projetamos esta função para que, ao passarmos o parâmetro, ela obtenha automaticamente o endereço de memória do ponteiro duplo.
Na função, pegamos a variável “tempp” e o ponteiro duplo “**double_ptr”. Passamos o endereço da variável especificada que é “tempp” para o ponteiro duplo e os valores do ponteiro duplo como argumento da função. O programa exibe o resultado do código da função principal na tela do console, de modo que todas as coisas que estão na função principal são executáveis. Tomamos o ponteiro “ptr_1” e o ponteiro duplo como “double_ptr” na função principal. Passamos o endereço do ponteiro para o ponteiro duplo.
Agora, passamos a variável de ponteiro duplo na função de substituição e passamos o ponteiro para a variável de ponteiro na instrução de fluxo de saída “cout” para mostrar o resultado do ponteiro duplo.
Quando o compilador atinge a função de substituição, o verificador do compilador onde esta função está definida executa o código dentro da função e retorna o resultado para a função principal.
A saída deste código está anexada a seguir:
Resultado: O valor do ponteiro duplo é 200.
Cenário 3: Usando a matriz 2D com ponteiro a ponteiro
Neste exemplo, lidaremos com um array 2D com um ponteiro duplo. Pegamos um array e passamos o endereço de um array no ponteiro. O código completo deste cenário é fornecido da seguinte forma:
principal interno ( ) {const int linhas = 3 ;
const int colunas = 2 ;
interno ** matriz = novo int * [ linhas ] ;
para ( int eu = 0 ; eu < linhas; ++eu ) {
matriz [ eu ] = novo interno [ colunas ] ;
}
para ( int eu = 0 ; eu < linhas; ++eu ) {
para ( int j = 0 ; j < colunas; ++j ) {
matriz [ eu ] [ j ] = eu * colunas + j;
}
}
para ( int eu = 0 ; eu < linhas; ++eu ) {
para ( int j = 0 ; j < colunas; ++j ) {
corte << matriz [ eu ] [ j ] << ' ' ;
}
corte << fim;
}
para ( int eu = 0 ; eu < linhas; ++eu ) {
excluir [ ] matriz [ eu ] ;
}
excluir [ ] matriz;
retornar 0 ;
}
Como todos sabemos, temos muitas linhas e várias colunas em um array 2D. Na função principal, inicializamos as linhas e colunas que possuem “const int”. Depois disso, alocamos o espaço de memória para as linhas e o espaço de memória para as colunas ao longo de cada linha. Passamos o valor do número de linhas como um ponteiro no ponteiro duplo da matriz como “**matriz”. Neste ponteiro duplo, o loop do número de linhas é executado ou verdadeiro. Então, outro loop interno é executado até que a condição se torne falsa.
Após a alocação de memória, atribuímos novamente um valor em um array: um loop externo para as linhas e um loop interno para as colunas do array 2D. No loop interno, o valor das linhas e colunas é atribuído ao ponteiro duplo e executa uma operação aritmética necessária. Exibimos os valores de um array 2D como o número de linhas e colunas alocadas na memória. O número de linhas e colunas sempre aponta para o ponteiro duplo que armazena os valores das linhas e colunas. No final, limpamos a memória e desalocamos esse array da memória em C++.
A saída do array 2D com um ponteiro duplo é anexada a seguir:
Cenário 4: trocando os ponteiros usando ponteiro para ponteiro
Aqui, aprenderemos como trocar os ponteiros em C++ declarando o ponteiro duplo. O trecho de código deste cenário está anexado a seguir:
#includetroca nula ( interno ** ptrr_1, você ** ptrr_2 ) {
interno * var_temp = * ptrr_1;
* ptrr_1 = * ptrr_2;
* ptrr_2 = var_temp;
}
principal interno ( ) {
interno x = quinze , você = 25 ;
interno * ptrrA = & x, * ptrrB = & e;
std::cout << 'Antes da troca: *ptrrA is =' << * ptrrA << ', *ptrrB é = ' << * ptrrB << std::endl;
trocar ( & ptrrA, & ptrrB ) ;
std::cout << 'Após a troca: *ptrrA is =' << * ptrrA << ', *ptrrB is= ' << * ptrrB << std::endl;
retornar 0 ;
}
Primeiro, construímos a função swap, passando ambos os ponteiros como argumento da função. Na função swap, pegamos o ponteiro “temp” e passamos o valor de “pointer1” em “temp” por algum tempo. Em seguida, passamos o valor de “ponteiro2” para “ponteiro1”. No final, passamos o valor do ponteiro “temp” para o “ponteiro2”.
Na função principal, precisamos de dois ponteiros que passamos ou substituímos na função “swap”. Passamos os endereços das variáveis para os ponteiros fornecidos. Em seguida, o valor do ponteiro antes e depois da troca do ponteiro é exibido.
A saída deste código está anexada a seguir:
Como podemos ver, os valores do ponteiro são trocados com sucesso usando um ponteiro duplo em C++.
Conclusão
Concluímos que ponteiro a ponteiro sempre armazena o endereço de memória de qualquer ponteiro em C++. Podemos usar o ponteiro duplo para usar temporariamente a localização da memória de qualquer ponteiro a qualquer momento. Esta é uma forma muito eficaz de manipular indiretamente o endereço da memória e aproximar os dados.