Imparare C/C++ Passo dopo Passo - Pagina 9

 printf("\nIndirizzo di A è     : 0x%x", &a);

int *ptr;

puntatore   ptr;                 /*  non valido */
``` Il problema è che il compilatore deve sapere che tipo di variabile il puntatore punta.  |



|  | Dichiarazione di una variabile puntatore  
char *cptr;           /* Puntatore a carattere */  
int *iptr;            /* Puntatore a int */  
float *fptr;            /* Puntatore a float */  
struct emp *e;            /* Puntatore a dati astratti emp e */ |

#### Accesso alla variabile Puntata:

Ecco un modo speciale per accedere ai valori di una variabile utilizzando il suo indirizzo invece del suo nome.



|  | /* 60_addr.c */  
#include   
int main()  
{  
int var1 = 11; /* variabile var1 = 11 */  
int *ptr; /* Variabile ptr come puntatore a */  
  
ptr = &var; /* Contiene l'indirizzo di var in ptr */  
  
printf("Valore di var1 è %d", *ptr); /* Puntatore all'indirizzo di var1 */  
return 0;  
} |


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


Se l'istruzione è printf ("%d", ptr); allora visualizza il valore di ptr, cioè l'indirizzo di var1, ma l'istruzione sopra può visualizzare il contenuto dell'indirizzo, che è stato memorizzato nella variabile ptr.

Programma per dimostrare l'uso di Address_Of e Pointer_To


|  | /* 61_ptrdemo.c */  
#include   
int main()  
{  
int a = 10, *p; /* Intero a e puntatore p */  
p = &a; /* Assegna l'indirizzo di a a p */  
  
printf("\nValore di A : %d", a); /* Contenuto di a */  
printf("\nIndirizzo di A : 0x%x", &a); /* Indirizzo di a */  
printf("\nValore di P : 0x%x", p); /* Contenuto di p */  
printf("\nIndirizzo di P : 0x%x", &p); /* Indirizzo di p */  
printf("\nContenuto all'indirizzo di a : %d", *p); /* Puntatore a &a */  
return 0;  
} |

#### 5. Aritmetica dei Puntatori

Tutte le variabili possono supportare operazioni aritmetiche, così come possiamo eseguire operazioni aritmetiche anche sui puntatori. Il linguaggio C/C++ può supportare 4 operazioni aritmetiche sui Puntatori, vale a dire.


|  | Operazione  
Addizione  
Sottrazione  
Incremento  
Decremento | Simbolo  
+  
-  
++  
-- |



Nota: La caratteristica principale dell'aritmetica dei puntatori è che gli operatori sopra sono in byte con riferimento al tipo della sua variabile.



|  | /* 62_ptr.c */  
/* Dimostrazione dell'aritmetica dei puntatori */  
#include   
int main()  
{  
int a, *p;  
a = 100;  
p = &a;  
(*p)++; /* Incrementa il puntatore a (contenuto all'indirizzo) di 1 */  
printf("%d", *p);  
return 0;  
} |
|  | Output  
101 |


Dimostrazione dell'aritmetica dei Puntatori, Incrementa il valore dell'indirizzo


|  | /* 63_ptr.c */  
/* Incrementa il valore dell'indirizzo di 1 */  
#include   
int main()  
{  
int a, *p;  
a = 100;  
p = &a;  
*p++; /* Incrementa il valore dell'indirizzo in p di 1 */  
printf("%d", *p);  
return 0;  
}  |
|  | Output  
Output imprevisto |


Il programma sopra illustra gli operatori aritmetici con riferimento sia all'incremento del valore che dell'indirizzo. p è una variabile puntatore e a è assegnato a 100, così come p è assegnato all'indirizzo di a.

Ora *p++ effettua l'incremento o in realtà salta la memoria di 2 byte per ottenere un nuovo indirizzo e il suo contenuto.  
Se è **(*p)++, allora il contenuto puntato da p** è 100 è incrementato, risultando in 101.

#### 6. Puntatori e Array

Nel linguaggio C/C++, i tipi di dati puntatori e array si somigliano. Gli elementi dell'array fanno riferimento così come la variabile puntatore, entrambi sono utilizzati per contenere l'indirizzo degli elementi di dati in memoria.


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


C'è una stretta associazione tra puntatori e array. Ecco una revisione sugli array.


|  | /* 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;  
} |


C'è la possibilità di accedere agli elementi dell'array utilizzando la notazione dei puntatori.  
Trova l'output del seguente programma.


|  | /* 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;  
} |


Segui il programma successivo:


|  | /* 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;  
} |


Ecco un approccio più semplice per stampare gli elementi del dato array (dimensione non richiesta).


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

#### 7. Puntatori e Stringhe

Una stringa è una collezione di caratteri, inclusi gli spazi. Questa volta discutiamo su come gestire le stringhe utilizzando i puntatori. Non ci sono più discussioni per creare confusione. Ecco il compito semplice per verificare sia il puntatore che l'array di stringhe.

C'è una sottile differenza tra stringhe e puntatori, segui il programma.


|  | /* 68_ptrstr.c */  
#include   
int main()  
{  
char str1[ ] = "Ti piacerebbe esplorare C.";  
char *str2 = "Ti piacerebbe esplorare C.";  
puts(str1);  
puts(str2);  
str1++; /* Espressione non valida */  
str2++; /* Espressione valida */  
puts(str2); /* stampa ou piacerebbe esplorare…… */  
return 0;  
} |


Stringhe come Argomenti di Funzione

Una variabile puntatore è più flessibile delle variabili array, ecco il programma per dimostrare e visualizzare una stringa con la notazione dei puntatori.


|  | /* 69_ptrarr.c */  
#include   
void disp(char *p);  
int main()  
{  
char str[ ] = "Ciao!!..Ciao!!.. I puntatori possono gestirlo?";  
disp(str);  
return 0;  
} void disp(char *p)  
{  
while(*p)  
printf("%c", *p++);  
} |


Array di puntatori a stringhe

C'è uno svantaggio nel memorizzare un array di stringhe, in quanto i sotto-array che contengono la stringa devono avere tutti la stessa lunghezza. Così che lo spazio viene sprecato quando le stringhe sono più corte dei sotto-array.  
Ecco la soluzione:


|  | /* 70_strings.c */  
#include   
int main()  
{  
char *weeks[7 ] = { "Domenica", "Lunedì", "Martedì", "Mercoledì",  
"Giovedì", "Venerdì", "Sabato" };  
int i;  
for( i = 0; i<7; i++)  
puts(weeks[ i ] );  
return 0;  
} |


Quando le stringhe non fanno parte di un array, C/C++ le colloca contiguamente in memoria, quindi non ci sono spazi sprecati.  
**/* Un programma di esempio per contenere un array di puntatori di tipo ‘int’ */**


|  | /* 71_ptrarr.c */  
#include   
int main()  
{  
int *arr[4]; /* Array di puntatori a 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;  
} |


Uno sguardo alle Funzioni della Libreria

Siamo già familiari con le funzioni standard delle stringhe. Hanno argomenti stringa che sono specificati utilizzando la notazione dei puntatori,  
Se siamo chiari con i concetti di puntatori e stringhe, siamo in grado di scrivere le nostre funzioni per le stringhe.  
Ecco un programma di esempio per copiare una stringa.  
  
**/* Copia una stringa in un'altra con i puntatori */**


|  | /* 72_strcpy1.c */  
#include   
void strcpy1(char * dest, char *src);  
  
int main()  
{  
char *str1 = "Come posso imparare di più su C/C++ !!!";  
char *str2;  
strcpy1(str2, str1);  
puts(str2);  
return 0;  
} void strcpy1(char * dest, char *src)  
{  
while(*src)  
*dest++ = *src++;  
*dest = '\0';  
} |


#### 8. Glossario


| Indirizzo | Un valore che punta a una posizione in memoria. Un puntatore contiene l'indirizzo o la posizione di un valore, a differenza del valore stesso. |
| Array | Un array è una collezione di elementi di dati dello stesso tipo. |
| Contiguo | Una caratteristica di memorizzazione che specifica che i valori sono memorizzati in posizioni consecutive sia in memoria che su disco. |
| Funzione | Una serie di istruzioni per eseguire un compito specifico, che può essere combinato con altre funzioni per creare un programma. |
| Memoria | Descrittiva di un dispositivo o mezzo che può accettare dati, contenerli e fornirli su richiesta in un secondo momento. Sinonimo di memorizzazione. |
| Puntatore | Contiene l'indirizzo o la posizione di memoria di un valore, a differenza del valore stesso. |
| RAM | (Memoria ad Accesso Casuale) 1. Un dispositivo di memorizzazione strutturato in modo tale che il tempo necessario per recuperare i dati non è significativamente influenzato dalla posizione fisica dei dati.  2. La *sezione di memorizzazione primaria* di un computer personale. |
| Stringa | Un array capace di memorizzare zero o più caratteri. In C, una stringa è dichiarata come un array di caratteri con il carattere NULL (\0) aggiunto per specificare la fine della stringa. |
| Variabile | Un nome associato a una posizione in memoria il cui valore può cambiare durante l'esecuzione del programma. |