'=': Konvertierung von 'int (*) [5]' auf 'int *'

Question

#include <iostream> 
using namespace std; 
int main() 
{ 
    int x[] = { 1 ,2 ,3 ,4 ,5 }; 
    int *ptr; 
    ptr = &x; 
    return 0; 
} 

Der Compiler sagt mir, dass '=': aus nicht konvertieren 'int (*) [5]' to ' int * '. Was bedeutet das? Der Teil, den ich nicht verstehe, ist, dass ptr als ein Zeiger immer die Adresse von x speichern kann, die selbst ein Zeiger ist, der auf das Basiselement des Arrays zeigt.

Answer 1

Ein Array-Name ist ein konstanter Zeiger auf das erste Element des Arrays. So ist Ihre Variable x ein Zeiger auf &x[0] oder x ist ein Zeiger auf die Adresse des ersten Elements im Integer-Array x.

Ein Zeiger ist eine Variable, die eine Adresse speichert. Da der Array-Name ein Zeiger ist, speichert er eine Adresse. In diesem Fall speichert x die Adresse des ersten Elements, dh die Adresse x[0].

Sie deklarieren die Variable ptr als Zeiger auf eine Variable vom Typ Integer. So speichert ptr auch eine Adresse bei der Initialisierung.

Daher versucht Ihre Zuweisungsanweisung ptr = &x; die 'Adresse' einer Adresse zu finden, die bereits dort angegeben ist, als Sie zuvor die Adresse x[0] in x gespeichert haben.

Da der Compiler die 'Adresse' der 'Adresse von x [0]' nicht finden kann, wird ein Fehler ausgegeben.

Der richtige Weg, um die Compiler, dass Sie die Adresse x[0] in den Variablen ptr speichern mögen zu sagen, ist durch einfaches es folgende ptr = x; oder, mit anderen Worten zu sagen, ptr an der Adresse in x gespeichert gleich ist, und die Adresse in x gespeichert ist eigentlich die Adresse x[0].

Denken Sie daran, dass sowohl ptr als auch x Adressen speichern können. Hoffe das hilft zu klären.

Answer 2

Der Typ der Variablen x ist int[5]. Der auf diese Variable angewendete Operator & ist ein Zeiger auf ein Objekt vom Typ int[5]. auch

Sie können gültige vorstellen, Erklärungen über die folgende Art und Weise

typedef int T[5]; 

T x = { 1, 2, 3, 4, 5 }; 
T *ptr = &x; 

Auf der anderen Seite Sie

typedef int U; 

U x[5] = { 1, 2, 3, 4, 5 }; 
U *ptr = x; 

schreiben können, wie Sie T sehen können und U sind verschiedene Typen und entsprechend T * und U * sind verschiedene Typen. Und Objekte dieser Typen werden unterschiedlich initialisiert. Der Typ T * den Typen entspricht, während der Typ int (*)[5] U den Typen entspricht int *

Es gibt keine implizite Umwandlung von dem einem Zeigertyp zu einem anderen. Der Compiler gibt also einen Fehler aus.