Wenn die Verwendung * in pointer-Zuweisung?

Ich weiß nicht, wenn Sie müssen, verwenden Sie ein *, wenn Sie arbeiten mit Zeigern ein, wenn nicht. Alles, was zu tragen ist eine hexadezimale ist ein Zeiger richtig? Der name der variable ein array ist, tragen Sie die hexadezimale Speicheradresse. Also warum nicht ist es ein Zeiger?

Letzte Sache, die erste - der name eines Arrays ist nicht einen Zeiger; es nicht speichern eine Adresse irgendwo. Wenn Sie definieren ein array, es wird so ausgelegt sein mehr oder weniger wie folgt aus:

 +---+ 
arr: | | arr[0] Steigende Adresse 
+---+ | 
| | arr[1] | 
+---+ | 
... | 
+---+ | 
| | arr[n-1] V 
+---+ 

Gibt es keine Lagerung beiseite für ein Objekt arr getrennt von der array-Elemente arr[0] durch arr[n-1]. C speichert keine Metadaten wie Länge oder Start-Adresse als Teil des array-Objekts.

Statt, es gibt eine Regel, die sagt, wenn ein array Ausdruck erscheint in Ihrem code und, der Ausdruck ist nicht der operand der sizeof oder unäre & Betreiber, wird es konvertiert werden ("decay"), um einen Zeiger Ausdruck, und der Wert der Zeiger-Ausdruck wird die Adresse des ersten Elements des Arrays.

So die Erklärung

T arr[N]; //for any type T

dann die folgenden Bedingungen erfüllt sind:

    Expression         Type        Decays to        Value
    ----------         ----        ---------        -----
           arr         T [N]       T *              Address of first element
          &arr         T (*)[N]    n/a              Address of array (same value
                                                      as above
          *arr         T           n/a              Value of arr[0]
        arr[i]         T           n/a              Value of i'th element
       &arr[i]         T *         n/a              Address of i'th element
    sizeof arr         size_t                       Number of storage units (bytes)
                                                      taken up by arr

Den Ausdrücke arr, &arr, und &arr[0] alle ergeben die gleiche Wert (die Adresse des ersten Elements des Arrays ist gleich der Adresse des Arrays), sondern Ihre Arten nicht alle gleich; arr und &arr[0] Typ T *, während &arr Typ T (*)[N] (Zeiger auf N-element-array von T).

Alles, was zu tragen ist eine hexadezimale ist ein Zeiger richtig?

Hexadezimal ist nur eine bestimmte Darstellung von binären Daten; es ist nicht eine Art, in und von sich selbst. Und nicht alles, was geschrieben oder dargestellt in hex ist ein Zeiger. Ich kann den Wert zuzuweisen 0xDEADBEEF 32-bit-Ganzzahl; das heißt nicht, dass es ein Zeiger ist.

Die exakte Darstellung von Zeiger können variieren zwischen Architekturen; es kann sogar variieren zwischen verschiedenen Zeiger-Typen auf der gleichen Architektur. Für ein flat-memory-Modell (wie jedes moderne desktop-Architektur), wird es ein einfaches integral Wert. Für eine segmentierte Architektur (wie die alten 8086/DOS-Tagen), könnte es sein, ein paar Werte für die Seite # und offset.

Einen Zeiger Wert darf nicht so breit sein wie die Art verwendet, um es zu speichern. Zum Beispiel, die alten Motorola 68000 hatte nur 24 Adressleitungen, so dass alle Zeiger würde der Wert nur 24 bit breit. Jedoch, das Leben leichter zu machen, die meisten Compiler verwendet 32-bit-Typen zu repräsentieren-Zeiger, verlassen die oberen 8 bit ungenutzt (Potenzen von 2 sind bequem).

Ich weiß nicht, wenn Sie müssen, verwenden Sie ein *, wenn Sie arbeiten mit Zeigern ein, wenn nicht.

Ziemlich einfach - wenn Sie möchten, finden Sie die Spitzen-zu Einheit, verwenden Sie die *; wenn Sie möchten finden Sie die Zeiger selbst, lassen Sie es aus.

Einen anderen Weg, es zu betrachten - die Ausdruck *ptr ist äquivalent zu dem Ausdruck var, so dass jede Zeit, die Sie verweisen möchten, zum Inhalt von var verwenden Sie *ptr.

Konkreten Beispiel helfen könnte. Angenommen, das folgende:

void bar( T *p )
{
  *p = new_value();  //write new value to *p
}

void foo( void )
{
  T var;
  bar( &var );  //write a new value to var
}

Im obigen Beispiel die folgenden Bedingungen erfüllt sind:

 p == &var
*p == var

Wenn ich etwas dazu schreiben *p ich bin wirklich zu aktualisieren var. Wenn ich etwas dazu schreiben p ich werde es, um auf etwas anderes als var.

Dieser code oben ist eigentlich der primäre Grund warum Zeiger existieren, an Erster Stelle. In C werden alle Funktionsparameter übergeben werden von Wert; das heißt, die formalen parameter in der Funktionsdefinition ist ein separates Objekt aus der aktuellen parameter im Aufruf der Funktion. Alle updates für die formalen parameter nicht spiegelt sich in der tatsächlichen parameter. Wenn wir den code wie folgt ändern:

void bar( T p )
{
  p = new_value();  //write new value to p
}

void foo( void )
{
  T var;
  bar( var );  //var is not updated
}

Den Wert p geändert wird, aber da p ist ein anderes Objekt im Speicher aus var, wird der Wert in var bleibt unverändert. Die nur Weg für eine Funktion zum aktualisieren der aktuelle parameter wird über einen pointer.

Also, wenn Sie aktualisieren möchten, die Sache p Punkte zu, schreiben *p. Wenn Sie festlegen möchten p zu Punkt zu einem anderen Objekt, schreiben p:

int x = 0, y = 1;
int *p = &x; //p initially points to x
printf( "&x = %p, x = %d, p = %p, *p = %d\n", (void *) &x, x, (void *) p, *p );
*p = 3;
printf( "&x = %p, x = %d, p = %p, *p = %d\n", (void *) &x, x, (void *) p, *p );
p = y; //set p to point to y
printf( "&y = %p, y = %d, p = %p, *p = %d\n", (void *) &y, y, (void *) p, *p );

In diesem Punkt sind Sie wahrscheinlich Fragen, "warum benutze ich die Sternchen in int *p = &x und nicht in p = y?" Im ersten Fall sind wir deklarieren p als Zeiger und initialisiert ihn in der gleichen operation, und die * erforderlich ist, durch die Erklärung der syntax. In diesem Fall schreiben wir an p, nicht *p. Es wäre äquivalent zu schreiben

int *p;
p = &x;

Beachten Sie auch, dass in einer Erklärung der * ist gebunden an den Namen der Variablen, nicht der Typ Bezeichner; es analysiert, wie int (*p);.

C-Deklarationen sind auf der Grundlage der Arten von Ausdrücke, nicht Objekte. Wenn p ist ein Zeiger auf ein int, und wir wollen, beziehen sich auf die Spitzen-zu Wert, verwenden wir die * - operator dereferenzieren es, wie so:

x = *p;

Den Typ des Ausdruck *p ist int, so die Erklärung geschrieben, wie

int *p;

Zeiger deklariert sind, ähnlich wie reguläre Variablen.Das Sternchen vor dem Namen des Zeigers während der Erklärung zu unterscheiden, ist es wie ein Zeiger.Bei der Deklaration sind Sie nicht de-Referenzierung,z.B.:

int a = 0;
int *p = &a //here the pointer of type int is declared and assigned the address of the variable a

Nach der Erklärung Anweisung zum zuweisen der Zeiger eine Adresse oder Wert verwenden Sie diesen Namen ohne Sternchen,e.g:

int a;
int *p;
p = &a;

Zuweisen das Ziel des Zeigers ein Wert,Sie dereferenzieren Sie es, indem Sie vor dem Zeiger Namen mit *:

int a = 0;
int *p;
p = &a;
*p = 1;

Sind Sie ziemlich viel richtig.

Bin ich im ersten Fall zuerst die Dereferenzierung der Zeiger zuweisen 10 die Lage, dass Ihr ein festhalten? Und im zweiten Fall, ich bin die Zuweisung der tatsächlichen Lage auf den Zeiger.

Genau. Dies sind zwei logisch unterschiedliche Aktionen, wie Sie sehen.

"array" ist hier bereits im Besitz der hexadezimale Speicheradresse. Machen nicht, dass es ein Zeiger?

Und Sie bekommen den Griff auch hier. Für den Willen, Ihr Verständnis würde ich sagen, dass arrays sind Zeiger. In Wirklichkeit ist es jedoch nicht so einfach -- arrays nur Zerfall in Zeiger in den meisten Fällen. Wenn Sie wirklich in diese Angelegenheit, finden Sie ein paar tolle Beiträge hier.

Aber, da es nur ein Zeiger ist, können Sie nicht "assign to array". Zu behandeln, wie ein array im Zeiger-Kontext ist in der Regel erläutert, in der ein ziemlich guter Weg, in jedem C-Buch unter "Strings" Abschnitt.

Eines Ihrer Beispiele, ist nicht gültig. *ptr = 10;. Der Grund dafür ist, dass 10 einen Wert, aber es ist kein Speicher zugewiesen werden.

Können Sie denken Sie an Beispiele wie "die Zuordnung etwas Punkt, an die Adresse" oder "Adresse von etwas ist". So,

int *ptr ist ein Zeiger auf die Adresse etwas. So ptr = &val; bedeutet ptr gleich die Adresse von val. Dann kann man sagen *ptr = 10; oder val = 10; führen beide *ptr und val sind auf der Suche an der gleichen Speicherstelle und daher den gleichen Wert. (Hinweis: ich habe nicht gesagt, "Hinweis").