Ponteiros em C: O que é ponteiro na programação C? Tipos

O que é um ponteiro em C?

A apontador Em C, um ponteiro é uma variável que armazena o endereço de outra variável. Um ponteiro também pode se referir a outro ponteiro ou a uma função. Um ponteiro pode ser incrementado ou decrementado para apontar para a próxima ou a anterior posição de memória. O objetivo de um ponteiro é economizar espaço de memória e obter um tempo de execução mais rápido.

Como usar ponteiros em C

Se declararmos uma variável v do tipo int, v armazenará um valor. Cada variável, além do seu valor, também possui um endereço, ou seja, onde ela está localizada na memória. O endereço pode ser obtido colocando um e comercial (&) antes do nome da variável. Se você imprimir o endereço de uma variável, ele se parecerá com um número aleatório que pode variar de uma execução para outra.

Em vez de armazenar um valor, um ponteiro armazena o endereço de uma variável. Por exemplo:

int *y = &v;

Declarando um ponteiro

Assim como variáveis, ponteiros em Programação C Devem ser declarados antes de poderem ser usados. Uma declaração de ponteiro tem o seguinte formato:

data_type *pointer_variable_name;

Aqui, tipo de dados é o tipo base do ponteiro e indica o tipo da variável para a qual o ponteiro aponta. O asterisco (*), o mesmo símbolo usado para multiplicação, é o operador de indireção que declara um ponteiro. Algumas declarações de ponteiro válidas são:

int    *ptr_thing;       /* pointer to an integer */
int    *ptr1, thing;     /* ptr1 points to an int; thing is an int */
double *ptr2;           /* pointer to a double */
float  *ptr3;           /* pointer to a float */
char   *ch1;            /* pointer to a character */

Inicializar um ponteiro

Após declarar um ponteiro, inicializamos ele com o endereço de uma variável. Se um ponteiro não for inicializado e for usado, os resultados podem ser imprevisíveis e potencialmente desastrosos. Para obter o endereço de uma variável, use o operador e comercial (&) antes do nome da variável:

pointer = &variable;

Segue abaixo um programa simples que ilustra um ponteiro:

#include <stdio.h>
int main()
{
   int a = 10;     // variable declaration
   int *p;         // pointer variable declaration
   p = &a;        // store address of a in pointer p
   printf("Address stored in p is: %x\n", p);  // access the address
   printf("Value stored in p is: %d\n", *p);    // access the value
   return 0;
}

Saída:

Address stored in p is: 60ff08
Value stored in p is: 10

Tipos de ponteiros em C

Ponteiro nulo

Criamos um ponteiro nulo atribuindo o valor NULL durante a declaração. Isso é útil quando nenhum endereço foi atribuído ao ponteiro. Um ponteiro nulo sempre contém o valor 0.

#include <stdio.h>
int main()
{
   int *p = NULL;     // null pointer
   printf("The value inside variable p is: %x", p);
   return 0;
}

ponteiro vazio

Um ponteiro void, também chamado de ponteiro genérico, não possui nenhum tipo de dado padrão. Ele é criado usando a palavra-chave void e pode armazenar o endereço de qualquer variável.

#include <stdio.h>
int main()
{
   void *p = NULL;    // void pointer
   printf("The size of pointer is: %d\n", sizeof(p));
   return 0;
}

Ponta Selvagem

Um ponteiro é chamado de ponteiro selvagem se não for inicializado com nenhum valor. Esses ponteiros não são eficientes porque podem apontar para um local de memória desconhecido, o que pode causar problemas e travar o programa. Sempre tenha cuidado com ponteiros selvagens.

#include <stdio.h>
int main()
{
   int *p;          // wild pointer
   printf("%d", *p);
   return 0;
}

Outros tipos de ponteiros em C incluem o ponteiro pendente, o ponteiro complexo, o ponteiro próximo, o ponteiro distante e o ponteiro enorme.

Ponteiros de acesso direto e indireto

Em C, existem duas maneiras equivalentes de acessar e manipular o conteúdo de uma variável. O acesso direto utiliza o nome da variável diretamente, enquanto o acesso indireto utiliza um ponteiro para a variável:

#include <stdio.h>
int var = 1;        /* declare and initialize an int variable */
int *ptr;           /* declare a pointer to int */
int main(void)
{
   ptr = &var;       /* point ptr to var */
   printf("\nDirect access, var = %d", var);
   printf("\nIndirect access, var = %d", *ptr);
   *ptr = 48;        /* change var through the pointer */
   printf("\nIndirect access, var = %d", *ptr);
   return 0;
}

Aritmética de Ponteiros em C

Ao trabalhar com ponteiros, observe estas regras de prioridade. Os operadores * e & têm a mesma prioridade que os operadores unários (negação !, incremento ++, decremento –). Na mesma expressão, os operadores unários *, &, !, ++ e – são avaliados da direita para a esquerda. Se um ponteiro P aponta para uma variável X, então *P pode ser usado em qualquer lugar onde X possa ser escrito. As seguintes expressões são equivalentes:

No último caso, os parênteses são necessários: como os operadores unários * e ++ são avaliados da direita para a esquerda, sem parênteses o ponteiro P seria incrementado, e não o objeto para o qual ele aponta. As operações aritméticas disponíveis em ponteiros são atribuição, incremento e decremento, e adição ou subtração.tracatribuindo um deslocamento inteiro, que move o ponteiro por essa quantidade de elementos (cada passo equivale ao tamanho em bytes do tipo base).

Ponteiros e arrays em C com exemplos

Tradicionalmente, acessamos elementos de um array usando um índice, mas ponteiros também facilitam isso. Um ponteiro definido para o nome do array aponta para o primeiro elemento:

#include <stdio.h>
int main()
{
   int a[5] = {1, 2, 3, 4, 5};   // array initialization
   int *p;                       // pointer declaration
   p = a;                       // p points to the first element; same as &a[0]
   for (int i = 0; i < 5; i++)
   {
      printf("%d\n", *p);            // print element
      p++;                      // move to the next element
   }
   return 0;
}

Adicionar um número a um ponteiro o move essa quantidade de posições para a frente. Se p aponta para o endereço de memória 0, então p + 1 faz com que o ponteiro aponte para o endereço de memória 1.

Ponteiros e strings C com exemplos

Uma string é um array de objetos char que termina com um caractere nulo '\0'. Podemos manipular strings usando ponteiros:

#include <stdio.h>
#include <string.h>
int main()
{
   char str[] = "Hello Guru99!";
   char *p;
   p = str;
   printf("First character is: %c\n", *p);
   p = p + 1;
   printf("Next character is: %c\n", *p);
   p = str;                     // reset the pointer
   for (int i = 0; i < strlen(str); i++)
   {
      printf("%c\n", *p);
      p++;
   }
   return 0;
}

Outra forma de lidar com strings é com um array de ponteiros:

#include <stdio.h>
int main()
{
   char *materials[] = {"iron", "copper", "gold"};
   for (int i = 0; i < 3; i++)
      printf("%s\n", materials[i]);
   return 0;
}

Vantagens dos ponteiros em C

• Ponteiros são úteis para acessar diretamente endereços de memória.
• Eles fornecem uma maneira eficiente de acessar os elementos de uma matriz.
• São utilizados para alocação e desalocação dinâmica de memória.
• São utilizadas para formar estruturas de dados complexas, como listas encadeadas, grafos e árvores.

Desvantagens dos ponteiros em C

• Os ponteiros são um pouco complexos de entender.
• Podem causar erros como falhas de segmentação ou acesso a um local de memória não intencional.
• Atribuir um valor incorreto a um ponteiro pode causar corrupção de memória.
• Os ponteiros também são responsáveis ​​por vazamentos de memória se a memória não for liberada.
• É responsabilidade do programador lidar com ponteiros com cuidado.

Perguntas Frequentes