C-Zeiger Unterschied zwischen akzeptieren von Werten mit Arrays und Variablen?

Question

ich Zeiger neu bin ...

Während Werte auf ein Array mit Zeiger zuweisen wir verwenden:

int *arr; 
arr = malloc(10*sizeof(int)); 
for(i=0;i<10;i++) 
{ 
    scanf("%d",(arr + i)); 
} 

Aber während einer Variablen zugewiesen verwenden wir

int *arr = malloc(sizeof(int)); 
*arr = 10; 

Warum können wir nicht verwenden,

scanf("%d",*(arr + i)); 

Warum zeigt es Fehler?

Answer 1

In

scanf("%d",(arr + i)); 

(arr + i) bereits ein Zeiger zum i-ten Element des Feldes arr. Hätten Sie scanf Ed in eine "single" Variable, müssten Sie ihre Adresse übergeben (= Zeiger auf diese Variable).

scanf("%d", &some_int_variable); 

Warum es Fehler zeigt, ist?

Dereferenzierung:

scanf("%d",*(arr + i)); 

wäre falsch, weil es nicht den Zeiger auf das i-ten Arraymitglied passieren würde zu lesen, da scanf() ein Zeiger erfordert auf das Argument spezifiziert durch das Formattag, kein Wert.

Answer 2

Da scanf erfordert einen Zeiger. Kein Wert. *(arr+i) ist der Wert also, wenn Sie das an scanf übergeben, konnte die Funktion den Wert nicht ändern, so dass es nach dem Funktionsaufruf wirksam war.

Sie benötigen einen Zeiger, um den Wert des Objekts, auf das verwiesen wird, zu ändern und die Änderung nach dem Aufruf wirksam werden zu lassen.

Es ist wie alle Funktionsaufrufe in c. Sie gehen nach Wert. Innerhalb der Funktion kann der Wert geändert werden, aber sobald die Funktion zurückkehrt, gehen solche Änderungen verloren.

Wenn der übergebene Wert jedoch der Wert eines Zeigers ist, kann die Funktion den Wert des Objekts ändern, auf das der Zeiger zeigt. Eine solche Änderung ist immer noch wirksam, wenn die Funktion zurückkehrt.

Ein einfaches Beispiel:

void f(int a) 
{ 
    a = 10; // This change is lost when the function returns 
} 

void g(int* a) 
{ 
    *a = 10; // This change will survive when the function returns 
} 

int main(void) 
{ 
    int a = 0; 
    f(a); 
    printf("%d\n", a); // will print 0 
    g(&a); 
    printf("%d\n", a); // will print 10 
    return 0; 
} 

Answer 3

scanf eine Adresse (Zeiger) ein Wert annimmt, teilt der Formatbezeich was für Zeiger.

scanf("%d", (arr + i)) bedeutet, dass Sie scanf die Adresse arr plus einem Offset von i,

geben, wenn Sie *arr = 10; schreiben Sie es auch als *(arr + 0) = 10; schreiben kann, so sind Sie de Referenzierung den Wert und es 10 mit anderen Worten die Zuordnung Sie kann dies nicht scanf geben, da es einen Zeiger will.

so

arr = malloc(10*sizeof(int)); 

     +---+---+---+---+---+---+---+---+---+---+ 
arr ->|0 | | | | | | | | | 9 | 
     +---+---+---+---+---+---+---+---+---+---+ 

arr + i ist eine Adresse im Bereich 0..9, de-Referenzierung Wert im Array schreiben Sie *(a+i)

aber

arr = malloc(sizeof(int)); 

     +---+ 
arr ->| | 
     +---+ 

Schreiben *ar r Sie denentieren den von Ihnen zugewiesenen Wert

*arr = 10; 

     +---+ 
arr ->| 10| 
     +---+ 

jedoch

Schreiben

scanf("%d", arr); 

ist seit arr fein ist ein Zeiger, der auf eine ganze Zahl und Punkte Scanf nimmt einen Zeiger.