Was bedeuten "** & ptr" und "2 ** ptr" von C-Zeiger?

Question

Ich bin Neuling auf C. muss ich verstehen, was jeder der auf dem Bildschirm bedeutet, durch den folgenden Code gedruckt Werte:

#include<stdio.h> 

int main() 
{ 
    int x = 10; 
    int *ptr = &x; 
    printf("%d %d %d\n", *ptr,**&ptr, 2**ptr); 
    return 0; 
} 

Output (GCC):

10 10 20 

Hier , Ich habe Variable x und ptr Punkt auf x Variable deklariert. So, *ptr Druckwert von x. Aber ich konnte die Werte von **&ptr und 2**ptr nicht verstehen.

Vielen Dank im Voraus.

Answer 1

Hier, * und & Operatoren Wirkung gegenseitig abbrechen, wenn nacheinander verwendet werden.

**&ptr die gleiche wie *ptr ist und hier halten ptr die Adresse x Variable. Drucken Sie hier den Wert x.

2**ptr wird als 2 * (*ptr) interpretiert. So ist 2 * (10) gleich 20.

Answer 2

**&ptr 

& und * sind unäre Operatoren, die eine entgegengesetzte Bedeutung 1 von dem anderen haben.

&(lvalue) bedeutet die Adresse der entsprechenden lvalue während *(lvalue) Mittel zurückzukehren, um den Wert von der Adresse von L-Wert wies zurück, die Art des L-Wertes unter Berücksichtigung, um zu wissen, um wie dereferenzieren zu.

Visuell die Bedeutung dieser Operatoren wie folgt aussieht (mein Talent in artist-mode von emacs ist nicht zu groß):

 +----------------+    
     | ptr = *&ptr |    
     +--------------+-+    
    /    \ 
    /    \ 
    &ptr     \ 
          +----------------+ 
          | *ptr  | 
          +----------------+ 
         /
         /
         ptr 

Bitte beachte, dass ich in der Box, während der rechte Wert markiert, außerhalb der Box die Adressen des Gedächtnisses der linken Werte der entsprechenden Speicherplätze.

Jetzt, wenn Sie *&(lvalue) schreiben, bedeutet es, den Wert von der Adresse von Lvalue zu erhalten, die in Kürze lvalue geschrieben wird.

So **&ptr bedeutet *ptr - nämlich den Wert aus der Adresse Zeiger durch ptr, als integer dereferenziert, in Ihrem Fall 10.

---

2**ptr 

Der Lexer wird den Code in Token aufgeteilt und den Parser einen Baum so bauen:

(2) * (*ptr) 

in diesem Fall wird das Ergebnis 2 mal der Wert aus der Adresse der ptr, in Ihrem c sein ase 20.

Answer 3

ptr ist eine Zeigervariable. Diese Zeigervariable zeigt auf den Speicherort, an dem der Wert von x gespeichert ist.* ptr greift auf den Wert zu, auf den die Zeigervariable zeigt.

Jetzt ist & ein Adressenoperator in C. & ptr gibt die Adresse von ptr zurück. So * & ptr gibt den Wert von der Adresse von ptr zurück. So * und & werden sich gegenseitig aufheben. Das ist ptr und * & ptr sind ein und dasselbe.

ptr = *&ptr => *ptr = **&ptr Daher ist der Wert 10.

2 ** ptr ist nichts anderes als 2 * (* ptr). Daher ist der Wert 20.

Answer 4

int *ptr verweist auf int x.

printf("%d\n", *ptr); bedeutet - Wert übernehmen, wo prt Punkte. So * ptr ist x Wert.

printf("%d\n", **&ptr); - & PTR ist die Adresse des Zeigers und *&ptr ist Wert in ptr. Und der Wert von &ptr ist Adresse von x. Also **&ptr ist ein Wert von x

printf("%d\n", 2**ptr); - 2 multiplizieren nach Wert in ptr. Es bedeutet 2 * x