Os ponteiros são como utilitários especiais, que facilitam o mapeamento em um código de programa. Ao contrário de outras variáveis, os ponteiros armazenam OS endereços de outras variáveis. Neste tutorial de ‘Ponteiros em C’, você examinará:

  • O que são ponteiros em C?
  • De quantas maneiras você pode acessar variáveis?
  • Quais são os diferentes tipos de ponteiros?
  • Quais são os casos de uso de ponteiros em C?
  • Quais são as vantagens dos ponteiros em C?
  • Quais são as desvantagens dos ponteiros em C?
  • Quais são os principais pontos?

O que são ponteiros em C?

Um ponteiro é uma variável que aponta para o endereço de outra variável. É declarado junto com um símbolo de asterisco (*). A sintaxe para declarar um ponteiro é a seguinte:

tipo de dados * var1

A sintaxe para atribuir o endereço de uma variável a um ponteiro é:

tipo de dados var1, * var2;

var2=& var1;

pointers_in_c-what-are-pointers-img1

De quantas maneiras você pode acessar as variáveis?

Você pode acessar uma variável de duas maneiras.

  • Acesso direto: você pode usar diretamente o nome da variável para acessar a variável.
  • Acesso indireto: você usa um ponteiro para acessar essa variável.

pointers_in_c-variable-access-img2

Exemplo:

#include

int main ()

{

int a=5, * ptr;

ptr=& a;

printf (“Acesso direto, a=% d \ n”, a);

printf (“Acesso indireto, a=% d \ n”, * ptr);

return 0;

}

pointers_in_c-variable-access-img2

Quais são os diferentes tipos de indicadores?

Existem basicamente quatro tipos de ponteiros, eles são:

  • Ponteiro Nulo
  • Void Pointer
  • Wild Pointer
  • Ponteiro pendente

Curso Full Stack Web Developer

Para se tornar um especialista em MEAN Stack Ver Curso

Full Stack Web Developer Course

Ponteiro Nulo:

pointers_in_c-null-pointer-img1

Se você atribuir um valor NULL a um ponteiro durante sua declaração, ele é chamado de Ponteiro Nulo.

Sintaxe:

Int * var=NULL;

Exemplo:

#include

int main ()

{

int * var=NULL;

printf (“var=% d”, * var);

}

pointers_in_c-null-pointer-img2.

Ponteiro de vazio:

pointers_in_c-void-pointer-img1.

Quando um ponteiro é declarado com uma palavra-chave void, ele é chamado de ponteiro void. Para imprimir o valor deste ponteiro, você precisa fazer um typecast dele.

Sintaxe:

void * var;

Exemplo:

#include

int main ()

{

int a=2;

void * ptr;

ptr=& a;

printf (“Após a modelagem, a=% d”, * (int *) ptr);

return 0;

}

pointers_in_c-void-pointer-img2.

Wild Pointer:

pointers_in_c-wild-pointer-img1

Um ponteiro curinga é apenas declarado, mas não é atribuído a um endereço de qualquer variável. Eles são muito complicados e podem causar erros de segmentação.

Exemplo:

#include

int main ()

{

int * ptr;

printf (“ptr=% d”, * ptr);

return 0;

}

pointers_in_c-wild-pointer-img2

Ponteiro pendente

pointers_in_c-dangling-pointer-img1

  • Suponha que haja um ponteiro p apontando para uma variável na memória 1004. Se você desalocar essa memória, esse p é chamado de ponteiro pendente.
  • Você pode desalocar uma memória usando uma função free ().

Exemplo:

#include

#include

int main ()

{

int * ptr=(int *) malloc (sizeof (int));

int a=5;

ptr=& a;

grátis (ptr);

//agora, este ptr é conhecido como ponteiro pendurado.

printf (“Depois de desalocar sua memória * ptr=% d”, * ptr);

return 0;

}

pointers_in_c-dangling-pointer-img2

Até agora, você aprendeu sobre os tipos de ponteiros. Agora, você examinará aspectos mais práticos. Vamos discutir alguns casos de uso de ponteiros em C.

Quais são os casos de uso de ponteiros em C?

  • Aritmética de ponteiro
  • Ponteiro a ponteiro
  • Matriz de ponteiros
  • Chamada por valor
  • Chamada por referência

Aritmética do ponteiro:

  • Incremento: você pode usar este operador para pular de um índice para o próximo índice em uma matriz.

Sintaxe:

ptr ++;

pointers_in_c-pointer-arithmetic-increment-img1

Exemplo:

#include

int main () {

int arr [3]={50, 150, 200};

int * ptr;

ptr=arr;

para (int i=0; i <3; i ++)

{

printf (“Valor de * ptr=% d \ n”, * ptr);

printf (“Endereço de * ptr=% d \ n”, ptr);

ptr ++;

}

pointers_in_c-pointer-arithmetic-increment-img2

  • Decremento: você pode usar este operador para pular de um índice para o índice anterior em uma matriz.

Sintaxe:

Ptr–;

arithmetic-decrement-img

Exemplo:

#include

int main ()

{

int arr [3]={50, 150, 200};

int * ptr;

ptr=& arr [2];

para (int i=0; i <3; i ++)

{

printf (“Valor de * ptr=% d \ n”, * ptr);

printf (“Endereço de * ptr=% d \ n \ n”, ptr);

ptr–;

}

}

arithmetic-decrement-img2

  • Inteiros adicionados a um ponteiro: você pode usar este operador para pular de um índice para o próximo i-ésimo índice em uma matriz.

Sintaxe:

ptr +=i;//onde ‘i’ é um inteiro

pointers_in_c-pointer-arithmetic-additional-img1

Exemplo:

#include

int main () {

int arr [5]={10, 100, 200, 300, 500};

int * ptr;

ptr=& arr [0];

para (int i=0; i <5; i ++) {

printf (“Valor de * ptr=% d \ n”, * ptr);

printf (“Endereço de * ptr=% d \ n \ n”, ptr);

ptr=ptr + 2;

}

}

pointers_in_c-pointer-arithmetic-additional-img2

  • Inteiros subtraídos de um ponteiro: você pode usar este operador para pular de um índice para o iésimo índice anterior em uma matriz.

Sintaxe:

ptr-=i;//onde ‘i’ é um número inteiro

pointers_in_c-pointer-arithmetic-subtraction-img1

Exemplo:

#include

int main () {

int arr [5]={10, 100, 200, 300, 500};

int * ptr;

ptr=& arr [4];

para (int i=0; i <5; i ++)

{

printf (“Valor de * ptr=% d \ n”, * ptr);

printf (“endereço de * ptr=% d \ n \ n”, ptr);

ptr-=2;

}

}

pointers_in_c-pointer-arithmetic-subtraction-img2

  • Precedência:
  • Operadores * e & recebem as mesmas prioridades dos operadores unários (incremento ++, decremento–).
  • Os operadores unários *, &, ++,-são avaliados da direita para a esquerda na mesma expressão.
  • Se um P apontar para uma variável X, você pode trocar X por * P.

Expressão

Expressão equivalente

Y=X + 1

Y=* P + 1

X=X + 10

* P=* P + 10

X +=2

* P +=2

++ X

++ * P

X ++

(* P) ​​++

Ponteiro a Ponteiro:

pointers_in_c-pointer-to-pointer-img1

Nessa situação, um ponteiro apontará indiretamente para uma variável por meio de outro ponteiro.

Sintaxe:

Int ** ptr;

Exemplo:

#include

int main ()

{

int var, * ptr1, ** ptr2;

var=10;

ptr1=& var;

ptr2=& ptr1;

printf (“Valor de var=% d \ n”, var);

printf (“Valor disponível em * ptr1=% d \ n”, * ptr1);

printf (“Valor disponível em ** ptr2=% d \ n”, ** ptr2);

return 0;

}

pointers_in_c-pointer-to-pointer-img2

Uma matriz de ponteiro:

Uma matriz do ponteiro é uma matriz em que cada elemento é um ponteiro.

Sintaxe:

int * arr [n]//onde n é o tamanho da matriz.

pointers_in_c-Array-of-pointer-img1

Exemplo:

#include

int main ()

{

int a [3]={10, 100, 200}, n=3;

int i, * ptr [3];

para (i=0; i <3; i ++)

{

ptr [i]=& a [i];

}

para (i=0; i

{

printf (“Valor de a [% d]=% d \ n”, i, * ptr [i]);

}

return 0;

}

pointers_in_c-Array-of-pointer-img2

Chamada por valor:

Em ‘chamada por valor’, você deve copiar os valores da variável e passá-los na chamada de função como um parâmetro. Se você modificar esses parâmetros, isso não mudará o valor da variável real.

pointers_in_c-call-by-value-img1

Exemplo:

#include

anular alteração (int num)

{

printf (“Antes de adicionar valor dentro da função num=% d \ n”, num);

num=num + 100;

printf (“Depois de adicionar valor dentro da função num=% d \ n”, num);

}

int main ()

{

int x=100;

printf (“Antes da chamada da função x=% d \ n”, x);

alterar (x);

printf (“Após a chamada da função x=% d \ n”, x);

return 0;

}

pointers_in_c-call-by-value-img2.

Chamada por referência:

Na chamada por referência, você deve pegar o endereço da variável e passá-lo na chamada da função como um parâmetro. Se você modificar esses parâmetros, o valor da variável real também será alterado.

pointers_in_c-call-by-reference-img1

Exemplo:

#include

void change (int * num)

{

printf (“Antes de adicionar valor dentro da função num=% d \ n”, * num);

(* num) +=100;

printf (“Depois de adicionar valor dentro da função num=% d \ n”, * num);

}

int main ()

{

int x=100;

printf (“Antes da chamada da função x=% d \ n”, x);

change (& x);//passando referência na função

printf (“Após a chamada da função x=% d \ n”, x);

return 0;

}

pointers_in_c-call-by-reference-img2

Destaque-se de seus colegas esta avaliação Temporada

Comece a aprender com nossos cursos GRATUITOS Inscreva-se agora

Destaque-se de seus pares nesta temporada de avaliação

Quais são as vantagens dos ponteiros em C?

pointers_in_c-vant-img1

  • Dicas em programação C são úteis para acessar um localização da memória
  • Os ponteiros são uma forma eficaz de acessar os elementos da estrutura do array
  • Ponteiros são usados ​​para a alocação de memória dinâmica e a distribuição
  • Ponteiros são usados ​​para construir estruturas de dados complicadas como uma lista encadeada, gráfico, árvore, etc.

Quais são as desvantagens dos ponteiros?

pointers_in_c-desvantages-img1

  • Os ponteiros são um pouco difíceis de entender
  • Os ponteiros podem causar vários erros, como erros de segmentação ou acesso não necessário à memória
  • Se um ponteiro tiver um valor incorreto, ele pode corromper a memória
  • Ponteiros também podem causar vazamento de memória
  • Os ponteiros são relativamente mais lentos do que as variáveis ​​

Quais são as principais vantagens?

  • Os ponteiros na programação C são simplesmente um local de armazenamento de dados na memória
  • Ponteiros podem ser usados ​​para percorrer a matriz com mais eficiência
  • Você pode usar ponteiros de função para invocar uma função dinamicamente
  • Aritmética de ponteiro é o processo de realizar operações aritméticas em um ponteiro
  • Em uma matriz de ponteiros, os ponteiros podem apontar para funções, tornando simples chamar funções diferentes

Você é um desenvolvedor web ou está interessado em construir um site? Inscreva-se no Full Stack Web Developer-Programa MEAN Stack Master . Explore a visualização do curso!

Próximas etapas

“Arrays em estruturas de dados”pode ser sua próxima parada. Arrays em estruturas de dados podem ser úteis na programação competitiva e outras implementações de estrutura de dados. Os arrays alocam memória em locais de memória contíguos para todos os seus elementos, facilitando o acesso aos elementos.

Você deseja aprender mais e dominar as principais linguagens de programação da atualidade? Bem, Desenvolvedor Full Stack Web-MEAN Stack O programa de mestrado oferece exatamente isso e muito mais. Este programa de treinamento globalmente reconhecido abrange mais de 20 habilidades e ferramentas exigidas que você aprenderá por meio de uma abordagem de aprendizagem aplicada com 10 projetos de fim de aula, 4 projetos de fim de fase e um projeto principal em 4 domínios da indústria. Explore o curso hoje.

Se você tiver alguma dúvida sobre “Ponteiros em C”, sinta-se à vontade para deixá-la na seção de comentários abaixo. Nossa equipe de especialistas 24 horas por dia, 7 dias por semana, responderá a todas as suas dúvidas o mais rápido possível!

Source link

Categories: Wordpress