Menu

Ponteiros e operações de ponteiro em C ++

pointers pointer operations c

Experimente Nosso Instrumento Para Eliminar Problemas

Um estudo intensivo de ponteiros e seus usos em C ++.

Um Pointer é um dos recursos mais poderosos da linguagem C ++. Um ponteiro ajuda a manipular as variáveis ​​por meio de seu endereço.

aplicativo para espionar telefone Android

Neste tutorial, exploraremos em detalhes tudo sobre ponteiros e seus usos em C ++.

=> Veja a série de treinamento simples em C ++ aqui.

Ponteiros em c ++

O que você aprenderá:

O que é um ponteiro?

Um ponteiro é uma variável que contém o endereço de um local da memória. Sabemos que todas as variáveis ​​que declaramos têm um endereço específico na memória. Declaramos uma variável de ponteiro para apontar para esses endereços na memória.

A sintaxe geral para declarar uma variável de ponteiro é:

datatype * variable_name;

Por exemplo, a declaração int * ptr;

Isso significa que ptr é um ponteiro que aponta para uma variável do tipo int. Portanto, uma variável de ponteiro sempre contém uma localização ou endereço de memória. Vamos ver o funcionamento das variáveis ​​de ponteiro abaixo.

Considere que temos as seguintes declarações:

Int p, *ptr; //declare variable p and pointer variable ptr p = 4; //assign value 4 to variable p ptr = &p; //assign address of p to pointer variable ptr

Na memória, essas declarações serão representadas da seguinte forma:

alocação de memória de ponteiros

Esta é a representação interna do ponteiro na memória. Quando atribuímos a variável de endereço à variável de ponteiro, ele aponta para a variável como mostrado na representação acima.

Como ptr tem um endereço de variável p, * ptr fornecerá o valor da variável p (variável para a qual a variável de ponteiro ptr está apontando).

Observação: O operador * que usamos com o ponteiro é usado para denotar que é uma variável de ponteiro.

Vejamos alguns dos conceitos de ponteiro usados ​​em C ++.

Pointer Arithmetic

Sabemos que uma variável de ponteiro sempre aponta para o endereço na memória. Entre as operações que podemos realizar, temos as seguintes operações aritméticas que são realizadas em ponteiros.

  • Operador de incremento (++)
  • Operador de decremento (-)
  • Adição (+)
  • Subtração (-)

Vamos ver o uso dessas operações em um programa de exemplo.

#include #include using namespace std; int main() { int myarray(5) = {2, 4,6, 8,10}; int* myptr; myptr = myarray; cout<<'First element in the array :'<<*myptr<

Resultado:

Primeiro elemento na matriz: 2
próximo elemento na matriz: 4
próximo elemento na matriz: 6
próximo elemento na matriz: 4
próximo elemento na matriz: 2

Vimos as operações aritméticas realizadas em ponteiros. Observe que o operador de incremento ++ incrementa o ponteiro e aponta para o próximo elemento na matriz. Da mesma forma, o operador de decremento diminui a variável de ponteiro em 1 para que ela aponte para o elemento anterior na matriz.

Também usamos operadores + e -. Primeiro, adicionamos 1 à variável de ponteiro. O resultado mostra que ele aponta para o próximo elemento na matriz. Da mesma forma, o operador - faz com que a variável de ponteiro aponte para o elemento anterior na matriz.

Além desses operadores aritméticos, também podemos usar operadores de comparação como ==,.

Ponteiros nulos e vazios

Se for esse o caso, uma variável de ponteiro não é atribuída a um endereço de uma variável, então é uma boa prática atribuir um valor NULL à variável de ponteiro. A variável de ponteiro com um valor NULL é chamada de ponteiro NULL.

Um ponteiro nulo é um ponteiro constante com valor zero definido no cabeçalho iostream. A memória no endereço 0 é reservada pelo sistema operacional e não podemos acessar este local.

Usando o ponteiro nulo, podemos evitar o uso indevido de ponteiros não utilizados e evitar que variáveis ​​de ponteiro tenham alguns valores de lixo atribuídos a eles.

Os ponteiros vazios são os ponteiros especiais que apontam para os valores sem tipo. Os ponteiros de vazio são mais flexíveis, pois podem apontar para qualquer tipo. Mas eles não podem ser diretamente desreferenciados. Para desreferenciamento, o ponteiro void precisa ser convertido em um ponteiro que aponta para um valor com o tipo de dados concreto.

Mostramos o funcionamento do ponteiro NULL e do ponteiro void no exemplo de código a seguir.

#include #include using namespace std; int main() { int intvar = 10; char c = 'A'; void* vptr; int* myptr = NULL; cout<<'NULL pointer value :'<

Resultado:

Valor do ponteiro NULL: 0
O ponteiro vazio vptr aponta para: A
O ponteiro vazio vptr aponta para: 10

No programa acima, primeiro, declaramos um ponteiro de inteiro ao qual é atribuído um valor NULL. Quando imprimimos este ponteiro, vemos que o valor é 0, como discutimos anteriormente.

Em seguida, declaramos um ponteiro void. Primeiro, atribuímos um endereço de variável de caractere a este ponteiro void. Em seguida, atribuímos void pointer a um ponteiro de caractere e o typecast com char *. Em seguida, imprimimos o valor charptr que aponta para char A, que era uma variável de caractere que declaramos anteriormente e é apontada pelo ponteiro void.

Em seguida, atribuímos uma variável inteira ao ponteiro void e, em seguida, realizamos as mesmas etapas de desreferenciamento desse ponteiro vazio usando um ponteiro inteiro.

Matrizes e ponteiros

Arrays e ponteiros estão fortemente associados entre si. Sabemos que o nome do array aponta para o primeiro elemento do array e este é um ponteiro constante.

Podemos atribuir esse ponteiro a uma variável de ponteiro e, em seguida, acessar a matriz diminuindo o ponteiro ou usando o operador subscrito.

melhor limpador de arquivos lixo grátis para windows 10

Veremos essa associação entre a variável de ponteiro e a matriz no exemplo de código a seguir.

#include #include using namespace std; int main() { int myarray(5) = {1, 1, 2, 3, 5}; int* ptrvar; ptrvar = myarray; for(int i=0;i<5;i++) { cout<<*ptrvar<<' '; ptrvar++; } return 0; }

Resultado:

1 1 2 3 5

No programa acima, atribuímos o nome do array a uma variável de ponteiro. Como o nome da matriz aponta para o primeiro elemento na matriz, podemos imprimir o conteúdo de toda a matriz usando uma variável de ponteiro e incrementá-la usando o operador ++. Isso é mostrado na saída.

Array Of Pointers

Às vezes, precisamos de mais de uma variável de ponteiro em um programa. Em vez de declarar cada variável de ponteiro individual, podemos declarar uma matriz de ponteiros.

Tomemos imediatamente um exemplo para demonstrar uma série de ponteiros.

#include #include using namespace std; int main() { int myarray(5) = {2,4,6,8,10}; int *ptr(5); //array of pointers for(int i=0;i<5;i++){ ptr(i) = &myarray(i); } for (int i = 0; i < 5; i++) { cout << 'Value of myarray(' << i << ') = '; cout << *ptr(i) << endl; } return 0; }

Resultado:

Valor de myarray (0) = 2
Valor de myarray (1) = 4
Valor de myarray (2) = 6
Valor de myarray (3) = 8
Valor de myarray (4) = 10

Na declaração acima,

int * ptr (5);

Podemos interpretar como; ptr é uma matriz de 5 ponteiros inteiros. Portanto, cada elemento de ptr apontará para uma variável do tipo inteiro.

Fazemos uso de um array inteiro e atribuímos o endereço de cada elemento do array a cada um dos elementos ptr. Em seguida, exibimos o conteúdo da matriz ptr emitindo “* ptr (i)”.

Ponteiro de ponteiros

O ponteiro dos ponteiros nada mais é do que vários caminhos indiretos. É uma espécie de cadeia de indicadores. Quando definimos um ponteiro de ponteiros, o primeiro ponteiro tem um endereço do segundo ponteiro, que por sua vez tem o endereço da variável para a qual aponta.

Na memória, isso será representado como:

Ponteiro de alocação de memória de ponteiros

Um ponteiro de ponteiros é declarado da seguinte maneira:

int** intptr;

Pegamos diretamente um exemplo de código para entender melhor o ponteiro dos ponteiros.

#include #include using namespace std; int main() { int *vptr; int ** intptr; int var = 10; vptr = &var; intptr = &vptr; cout<<'Variable var: '<

Resultado:

Var variável: 10
Ponteiro para variável: 10
Ponteiro para ponteiro para uma variável: 10

No programa acima, declaramos uma variável inteira, um ponteiro inteiro e um ponteiro de um ponteiro para um inteiro. Conforme mostrado no programa, a variável de ponteiro recebe o valor de uma variável. O ponteiro da variável de ponteiro é atribuído ao endereço da variável de ponteiro.

No final, imprimimos as três variáveis ​​que apresentam o mesmo valor 10 igual a uma variável inteira.

Passando ponteiros para funções

Passar ponteiros para a função é o mesmo que outras técnicas de passagem de parâmetro em que passamos variáveis ​​de ponteiro para a função.

Revisitamos nossa troca de dois valores e modificamos para passar variáveis ​​de ponteiro como parâmetros.

#include #include using namespace std; void swap(int* a, int* b) { int temp; temp = *a; *a = *b; *b = temp; } int main() { int a, b; cout<>a>>b; cout<<'a = '< Ponteiros de função

da mesma forma, como temos ponteiros para variáveis, matrizes, etc., também podemos ter ponteiros para funções. Mas a diferença é que o ponteiro de função aponta para o código executável e não para dados como variáveis ​​ou arrays.

Pegamos um exemplo para demonstrar os ponteiros de função.

#include #include using namespace std; void displayVal(int a) { printf('Value of a is %d ', a); } int main() { void (*func_ptr)(int) = &displayVal; (*func_ptr)(100); return 0; }

Resultado:

O valor de a é 100

vídeos para assistir com fone de ouvido vr

No programa acima, temos uma função ‘displayVal’ que apenas imprime um valor inteiro passado a ela. Na função principal, definimos um ponteiro de função ‘func_ptr’ que recebe um int como um argumento e retorna um tipo void.

void (* func_ptr) (int)

Observação: Precisamos incluir o ponteiro de função dentro de (). Se omitirmos, ele se tornará um protótipo de função.

Atribuímos o endereço da função ‘displayVal’ a este ponteiro de função. Então, usando este ponteiro de função ‘func_ptr’, passamos o valor do argumento 100, que é equivalente a chamar displayVal com o argumento 100.

Agora, se tivermos outra função com o mesmo protótipo, podemos usar o mesmo ponteiro de função atribuindo o endereço da função a ele. Este é o principal uso dos ponteiros de função.

Conclusão

Isso é tudo sobre os ponteiros, suas definições e usos em C ++.

Em nosso próximo tutorial, aprenderemos mais sobre referências em C ++. As referências também têm uso especial em C ++ e costumam ser usadas como apelidos para variáveis.

=> Clique aqui para ver a série de treinamento Absolute C ++.

Leitura recomendada

^