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

O que é ponteiro em C?

A Apontador em C, é uma variável que armazena o endereço de outra variável. Um ponteiro também pode ser usado para se referir a outra função de ponteiro. Um ponteiro pode ser incrementado/decrementado, ou seja, apontar para o local de memória seguinte/anterior. O objetivo do 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 irá na verdade armazenar um valor.

Como usar ponteiros em C

v é igual a zero agora.

Porém, cada variável, além do valor, também possui seu endereço (ou, simplesmente, onde está localizado na memória). O endereço pode ser recuperado colocando um E comercial (&) antes do nome da variável.

Como usar ponteiros em C

Se você imprimir o endereço de uma variável na tela, ela parecerá um número totalmente aleatório (além disso, pode ser diferente de execução para execução).

Vamos tentar isso na prática com ponteiro no exemplo C

Como usar ponteiros em C

A saída deste programa é -480613588.

Agora, o que é um ponteiro? Em vez de armazenar um valor, um ponteiro armazenará o endereço de uma variável.


Variável de ponteiro

Int *y = &v;

VARIÁVEL PONTO
A valor armazenado em um nomeado endereço de armazenamento/memória A variável que aponta para o endereço de armazenamento/memória de outra variável

Declarando um ponteiro

Assim como variáveis, ponteiros em Programação C precisam ser declarados antes de poderem ser usados ​​em seu programa. Os ponteiros podem receber o nome que você quiser, desde que obedeçam às regras de nomenclatura de C. Uma declaração de ponteiro tem o seguintewing .

data_type * pointer_variable_name;

Aqui,

  • tipo de dados é o tipo base do ponteiro dos tipos de variáveis ​​​​de C e indica o tipo da variável para a qual o ponteiro aponta.
  • O asterisco (*: o mesmo asterisco usado para multiplicação) que é o operador indireto, declares um ponteiro.

Vamos ver algumas declarações de ponteiro válidas neste tutorial sobre ponteiros C:

int    *ptr_thing;            /* pointer to an integer */ 
int *ptr1,thing;/* ptr1 is a pointer to type integer and thing is an integer variable */
double    *ptr2;    /* pointer to a double */
float    *ptr3;      /* pointer to a float */
char    *ch1 ;       /* pointer to a character */
float  *ptr, variable;/*ptr is a pointer to type float and variable is an ordinary float variable */

Inicialize um ponteiro

Depois de declarar um ponteiro, inicializamos ele como variáveis ​​padrão com um endereço de variável. Se os ponteiros na programação C não forem inicializados e usados ​​no programa, os resultados serão imprevisíveis e potencialmente desastrosos.

Para obter o endereço de uma variável, usamos o operador E comercial (&), colocado antes do nome de uma variável cujo endereço precisamos. A inicialização do ponteiro é feita com o seguintewing sintaxe.

Sintaxe do ponteiro

 pointer = &variable;

Um programa simples para ilustração de ponteiro é fornecido abaixo:

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

Saída:

Address stored in a variable p is:60ff08
Value stored in a variable p is:10
operador Significado
* Serve 2 propósitos

  1. Declaração de um ponteiro
  2. Retorna o valor da variável referenciada
& Serve apenas para 1 propósito

  • Retorna o endereço de uma variável

Tipos de ponteiros em C

Following são os diferentes Tipos de ponteiros em C:

Ponteiro nulo

Podemos criar um ponteiro nulo atribuindo um valor nulo durante a declaração do ponteiro. Este método é útil quando você não possui nenhum endereço atribuído ao ponteiro. Um ponteiro nulo sempre contém o valor 0.

Following programa ilustra o uso de um ponteiro nulo:

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

Saída:

The value inside variable p is:
0

ponteiro vazio

In Programação C, um ponteiro vazio também é chamado de ponteiro genérico. Não possui nenhum tipo de dados padrão. Um ponteiro void é criado usando a palavra-chave void. Pode ser usado para armazenar o endereço de qualquer variável.

Following programa ilustra o uso de um ponteiro nulo:

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

Saída:

The size of pointer is:4

ponteiro selvagem

Um ponteiro é considerado um ponteiro selvagem se não estiver sendo inicializado para nada. Esses tipos de ponteiros C não são eficientes porque podem apontar para algum local de memória desconhecido, o que pode causar problemas em nosso programa e levar ao travamento do programa. Deve-se sempre ter cuidado ao trabalhar com ponteiros selvagens.

Following programa ilustra o uso do ponteiro curinga:

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

Saída:

timeout: the monitored command dumped core
sh: line 1: 95298 Segmentation fault      timeout 10s main

Outros tipos de ponteiros em 'c' são os seguintes:

  • ponteiro pendurado
  • Complex apontador
  • Ponteiro próximo
  • Ponteiro distante
  • Ponteiro enorme

Ponteiros de acesso direto e indireto

Em C, existem duas maneiras equivalentes de acessar e manipular um conteúdo variável

  • Acesso direto: usamos diretamente o nome da variável
  • Acesso indireto: usamos um ponteiro para a variável

Vamos entender isso com a ajuda do programa abaixo

#include <stdio.h>
/* Declare and initialize an int variable */
int var = 1;
/* Declare a pointer to int */
int *ptr;
int main( void )
{
/* Initialize ptr to point to var */
ptr = &var;
/* Access var directly and indirectly */
printf("\nDirect access, var = %d", var);
printf("\nIndirect access, var = %d", *ptr);
/* Display the address of var two ways */
printf("\n\nThe address of var = %d", &var);
printf("\nThe address of var = %d\n", ptr);
/*change the content of var through the pointer*/
*ptr=48;
printf("\nIndirect access, var = %d", *ptr);
return 0;}

Depois de compilar o programa sem erros, o resultado é:

Direct access, var = 1
Indirect access, var = 1

The address of var = 4202496
The address of var = 4202496

Indirect access, var = 48

Aritmética de Ponteiros em C

As operações do ponteiro estão resumidas a seguirwing descobrir

Aritmética de Ponteiros em C
Operações de ponteiro

Operação prioritária (precedência)

Ao trabalhar com ponteiros C, devemos observar o seguintewing regras de prioridade:

  • Os operadores * e & têm a mesma prioridade que os operadores unários (a negação!, a incrementação++, o decremento–).
  • Na mesma expressão, os operadores unários *, &,!, ++, – são avaliados da direita para a esquerda.

Se um ponteiro P aponta para uma variável X, então *P pode ser usado onde quer que X possa ser escrito.

O seguintewing expressões são equivalentes:

int X =10
int *P = &Y;
For the above code, below expressions are true
Expressão Expressão Equivalente
S=*P+1

*P=*P+10

*P+=2

++*P

(*P)++

Y=X+1

X=X+10

X+=2

++X

X ++

Neste último caso, os parênteses são necessários: como os operadores unários * e ++ são avaliados da direita para a esquerda, sem os parênteses o ponteiro P seria incrementado, e não o objeto para o qual P aponta.

A tabela abaixo mostra a operação aritmética e básica que pode ser usada ao lidar com ponteiros C

Divisão de Explicação
Atribuição interno *P1,*P2
P1=P2;
P1 e P2 apontam para a mesma variável inteira
Incremento e decrementação Int*P1;
P1++;P1– ;
Adicionando um deslocamento (constante) Isso permite que o ponteiro mova N elementos em uma tabela.
O ponteiro será aumentado ou diminuído em N vezes o número de bytes do tipo da variável.
P1+5;

Ponteiros e matrizes C com exemplos

Tradicionalmente, acessamos os elementos do array usando seu índice, mas esse método pode ser eliminado usando ponteiros. Os ponteiros facilitam o acesso a cada elemento do array.

#include <stdio.h>
int main()
{
    int a[5]={1,2,3,4,5};   //array initialization
    int *p;     //pointer declaration
               /*the ptr points to the first element of the array*/

    p=a; /*We can also type simply ptr==&a[0] */
    
    printf("Printing the array elements using pointer\n");
    for(int i=0;i<5;i++)    //loop for traversing array elements
    {
        	printf("\n%x",*p);  //printing array elements
        	p++;    //incrementing to the next element, you can also write p=p+1
    }
    return 0;
}

Saída:

1
2
3
4
5

Adicionar um número específico a um ponteiro moverá a localização do ponteiro para o valor obtido por uma operação de adição. Suponha que p seja um ponteiro que atualmente aponta para o local de memória 0 se realizarmos o seguintewing operação de adição, p+1 então ela será executada desta maneira:

Ponteiros e matrizes C

Adição/incremento de ponteiro

Como p atualmente aponta para o local 0 após adicionar 1, o valor se tornará 1 e, portanto, o ponteiro apontará para o local de memória 1.

Ponteiros e strings C com exemplos

Uma string é uma matriz de objetos char, terminando com um caractere nulo '\ 0'. Podemos manipular strings usando ponteiros. Este ponteiro no exemplo C explica esta seção

#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);
printf("Printing all the characters in a string\n");
p=str;  //reset the pointer
for(int i=0;i<strlen(str);i++)
{
printf("%c\n",*p);
p++;
}
return 0;
}

Saída:

First character is:H
Next character is:e
Printing all the characters in a string
H
e
l
l
o

G
u
r
u
9
9
!

Outra maneira de lidar com strings é com uma série de ponteiros, como no seguintewing programa:

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

Saída:

Please remember these materials:
iron
copper
gold

Vantagens dos ponteiros em C

  • Os ponteiros são úteis para acessar locais de memória.
  • Os ponteiros fornecem uma maneira eficiente de acessar os elementos de uma estrutura de array.
  • Ponteiros são usados ​​para alocação dinâmica de memória e também para desalocação.
  • Ponteiros são usados ​​para formar complex estruturas de dados, como lista vinculada, gráfico, árvore, etc.

Desvantagens dos ponteiros em C

  • Os ponteiros são um pouco complicadosplex para entender.
  • Os ponteiros podem levar a vários erros, como falhas de segmentação, ou podem acessar um local de memória que não é necessário.
  • Se um valor incorreto for fornecido a um ponteiro, isso poderá causar corrupção de memória.
  • Os ponteiros também são responsáveis ​​pelo vazamento de memória.
  • Os ponteiros são comparativamente mais lentos que os das variáveis.
  • Os programadores acham muito difícil trabalhar com os ponteiros; portanto, é responsabilidade do programador manipular um ponteiro com cuidado.

Resumo

  • Um ponteiro nada mais é do que um local de memória onde os dados são armazenados.
  • Um ponteiro é usado para acessar o local da memória.
  • Existem vários tipos de ponteiros, como ponteiro nulo, ponteiro selvagem, ponteiro vazio e outros tipos de ponteiros.
  • Ponteiros podem ser usados ​​com array e string para acessar elementos de forma mais eficiente.
  • Podemos criar ponteiros de função para invocar uma função dinamicamente.
  • As operações aritméticas podem ser realizadas em um ponteiro conhecido como aritmética de ponteiro.
  • Os ponteiros também podem apontar para funções, o que facilita a chamada de diferentes funções no caso de definir uma matriz de ponteiros.
  • Quando você deseja lidar com diferentes tipos de dados variáveis, você pode usar um ponteiro typecast void.