Aprendendo C/C++ Passo a Passo - Página 9

 printf("\nEndereço de A é     : 0x%x", &a);

int *ptr;

ponteiro   ptr;                 /*  inválido */
``` O problema é que o compilador precisa saber que tipo de variável o ponteiro aponta.  |



|  | Declaração de uma variável ponteiro  
char *cptr;           /* Ponteiro para caractere */  
int *iptr;            /* Ponteiro para int */  
float *fptr;            /* Ponteiro para float */  
struct emp *e;            /* Ponteiro para dados abstratos emp e */ |


#### Acessando a variável Apontada:

Aqui está uma maneira especial de acessar os valores de uma variável usando seu endereço em vez de seu nome.

   


|  | /* 60_addr.c */  
#include   
int main()  
{  
int var1 = 11; /* variável var1 = 11 */  
int *ptr; /* Variável ptr como ponteiro para */  
  
ptr = &var1; /* Armazena o endereço de var1 em ptr */  
  
printf("Valor de var1 é %d", *ptr); /* Ponteiro para o endereço de var1 */  
return 0;  
} |


|  | ![](/files/4f55092a-e6b6-422d-af47-d517ba51db5b.jpg) |


Se a instrução for printf ("%d", ptr); então ela exibe o valor de ptr, que significa o endereço de var1, mas a instrução acima pode exibir o conteúdo do endereço, que foi armazenado na variável ptr.

Programa para demonstrar o uso de Endereço_De e Ponteiro_Para


|  | /* 61_ptrdemo.c */  
#include   
int main()  
{  
int a = 10, *p; /* Inteiro a e ponteiro p */  
p = &a; /* Atribui o endereço de a a p */  
  
printf("\nValor de A : %d", a); /* Conteúdo de a */  
printf("\nEndereço de A : 0x%x", &a); /* Endereço de a */  
printf("\nValor de P : 0x%x", p); /* Conteúdo de p */  
printf("\nEndereço de P : 0x%x", &p); /* Endereço de p */  
printf("\nConteúdo no endereço de a : %d", *p); /* Ponteiro para &a */  
return 0;  
} |


#### 5. Aritmética de Ponteiros

Todas as variáveis podem suportar operações aritméticas, assim como podemos realizar operações aritméticas em ponteiros também. A linguagem C/C++ pode suportar 4 operações aritméticas em Ponteiros, a saber.


|  | Operação  
Adição  
Subtração  
Incremento  
Decremento | Símbolo  
+  
-  
++  
-- |



Nota: A principal característica da aritmética de ponteiros é que os operadores acima são em bytes com referência ao tipo de variável.

   


|  | /* 62_ptr.c */  
/* Demonstração da aritmética de ponteiros */  
#include   
int main()  
{  
int a, *p;  
a = 100;  
p = &a;  
(*p)++; /* Incrementa o ponteiro para (conteúdo no endereço) em 1 */  
printf("%d", *p);  
return 0;  
} |
|  | Saída  
101 |


Demonstração da aritmética de ponteiros, Incrementa o valor do endereço


|  | /* 63_ptr.c */  
/* Incrementa o valor do endereço em 1 */  
#include   
int main()  
{  
int a, *p;  
a = 100;  
p = &a;  
*p++; /* Incrementa o valor do endereço em p em 1 */  
printf("%d", *p);  
return 0;  
}  |
|  | Saída  
Saída inesperada |


O programa acima ilustra os operadores aritméticos com respeito tanto ao valor quanto ao incremento de endereço. p é uma variável ponteiro e a é atribuída com 100, assim como p é atribuída com o endereço de a.

Agora *p++ efetua o incremento ou na verdade pula a memória em 2 bytes para obter um novo endereço e seu conteúdo.
  
Se for **(*p)++, então o conteúdo apontado por p** é 100, é incrementado, resultando em 101.

#### 6. Ponteiros e Arrays

Na linguagem C/C++, os tipos de dados ponteiros e arrays se assemelham entre si. O elemento do array referencia, assim como a variável ponteiro, ambos são usados para armazenar o endereço de elementos de dados na memória.


|  | char name[20];  
Ou  
char *name ;  
  
char months[12][10];  
Ou  
char **months; |


Há uma estreita associação entre ponteiros e arrays. Aqui está uma revisão sobre arrays.


|  | /* 64_ptrarr.c */  
#include   
int main()  
{  
int i, a[5] = { 56, 43, 78, 98, 12 };  
for( i = 0; i < 5; i++)  
printf("\n%d", a[i]);  
return 0;  
} |


Há uma possibilidade de acessar elementos de array usando notação de ponteiro.  
Encontre a saída do seguinte programa.


|  | /* 65_ptrarr.c */  
#include   
int main()  
{  
int i, a[5] = { 56, 43, 78, 98, 12 };  
for( i = 0; i < 5; i++)  
printf("\n%d", *(a+ i) );  
return 0;  
} |


Siga o próximo programa:


|  | /* 66_ptrarr.c */  
#include   
int main()  
{  
int i, a[ ] = { 56, 43, 78, 98, 12 }, *p;  
p = a;  
for( i = 0; i < 5; i++)  
printf("\n%d", *(p+ i) );  
return 0;  
} |


Aqui está uma abordagem mais fácil para imprimir os elementos do array dado (tamanho não é necessário).


|  | /* 67_ptrarr.c */  
#include   
int main()  
{  
int i, a[ ] = { 56, 43, 78, 98, 12 }, *p;  
p = a;  
while (*p)           /* ou for(int i = 0; i<5; i++ ) */  
printf("\n%d", *p++);  
return 0;  
} |


#### 7. Ponteiros e Strings

Uma string é uma coleção de caracteres, incluindo espaços. Desta vez, discutimos como lidar com strings usando ponteiros. Sem mais discussões para causar confusão. Aqui está a tarefa simples para verificar tanto ponteiro quanto array de strings.

Há uma sutil diferença entre strings & ponteiros, siga o programa.


|  | /* 68_ptrstr.c */  
#include   
int main()  
{  
char str1[ ] = "Você gostaria de explorar C.";  
char *str2 = "Você gostaria de explorar C.";  
puts(str1);  
puts(str2);  
str1++; /* Expressão inválida */  
str2++; /* Expressão válida */  
puts(str2); /* imprime você gostaria de explorar…… */  
return 0;  
} |


Strings como Argumentos de Função

Uma variável ponteiro é mais flexível do que variáveis de array, aqui está o programa para demonstrar & exibir uma string com notação de ponteiro.


|  | /* 69_ptrarr.c */  
#include   
void disp(char *p);  
int main()  
{  
char str[ ] = "Olá!!..Olá!!.. Ponteiros podem lidar com isso?";  
disp(str);  
return 0;  
} void disp(char *p)  
{  
while(*p)  
printf("%c", *p++);  
} |


Array de ponteiros para strings

Há uma desvantagem em armazenar um array de strings, em que os subarrays que contêm a string devem ter todos o mesmo comprimento. Assim, o espaço é desperdiçado quando as strings são mais curtas que os subarrays.  
Aqui está a solução:


|  | /* 70_strings.c */  
#include   
int main()  
{  
char *weeks[7 ] = { "Domingo", "Segunda-feira", "Terça-feira", "Quarta-feira",  
"Quinta-feira", "Sexta-feira", "Sábado" };  
int i;  
for( i = 0; i<7; i++)  
puts(weeks[ i ] );  
return 0;  
} |


Quando as strings não fazem parte de um array, C/C++ as coloca contiguamente na memória, assim não há espaços desperdiçados.  

**/* Um exemplo de programa para armazenar um array de ponteiros do tipo ‘int’ */**


|  | /* 71_ptrarr.c */  
#include   
int main()  
{  
int *arr[4]; /* Array de ponteiros int */  
int i = 31, j = 5, k = 19, l = 71, m;  
  
arr[0] = &i;  
arr[1] = &j;  
arr[2] = &k;  
arr[3] = &l;  
  
for(m = 0; m <= 3; m++)  
printf("\n%d", *(arr[m]) );  
return 0;  
} |


Uma olhada nas Funções da Biblioteca

Já estamos familiarizados com as funções padrão de string. Elas têm argumentos de string que são especificados usando notação de ponteiro,  
Se estivermos claros com o conceito de ponteiros & strings, seremos capazes de escrever nossas próprias funções de string.  
Aqui está um exemplo de programa para copiar string.  
  
**/* Copia uma string para outra com ponteiros */**


|  | /* 72_strcpy1.c */  
#include   
void strcpy1(char * dest, char *src);  
  
int main()  
{  
char *str1 = "Como posso aprender mais sobre C/C++ !!!";  
char *str2;  
strcpy1(str2, str1);  
puts(str2);  
return 0;  
} void strcpy1(char * dest, char *src)  
{  
while(*src)  
*dest++ = *src++;  
*dest = '\0';  
} |


#### 8. Glossário


| Endereço | Um valor que aponta para uma localização na memória. Um ponteiro contém o endereço ou localização de um valor, em oposição ao valor em si. |
| Array | Um array é uma coleção de itens de dados do mesmo tipo. |
| Contíguo | Uma característica de armazenamento que especifica que os valores são armazenados em locais consecutivos, seja na memória ou no disco. |
| Função | Uma série de instruções para realizar uma tarefa específica, que pode ser combinada com outras funções para criar um programa. |
| Memória | Descritivo de um dispositivo ou meio que pode aceitar dados, mantê-los e entregá-los sob demanda em um momento posterior. Sinônimo de armazenamento. |
| Ponteiro | Contém o endereço ou localização de memória de um valor, em oposição ao valor em si. |
| RAM | (Memória de Acesso Aleatório) 1. Um dispositivo de armazenamento estruturado de forma que o tempo necessário para recuperar dados não seja significativamente afetado pela localização física dos dados.  2. A *seção de armazenamento primário* de um computador pessoal. |
| String | Um array capaz de armazenar zero ou mais caracteres. Em C, uma string é declarada como um array de caracteres com o caractere NULL (\0) anexado para especificar o final da string. |
| Variável | Um nome associado a uma localização na memória cujo valor pode mudar durante a execução do programa. |