Arrays und Zeiger in C ++ - Dummies - Persönliche Finanzen 2024

Der Name des Arrays ist ein Zeiger auf das Array selbst.. Das -Array ist eine Folge von Variablen, die im Speicher gespeichert sind. Der Array-Name verweist auf das erste Element.

Dies ist eine interessante Frage zu Zeigern: Können Sie einen Funktionsheader haben, wie zum Beispiel die folgende Zeile, und einfach sizeof verwenden, um zu bestimmen, wie viele Elemente sich im Array befinden? Wenn dies der Fall ist, muss der Aufrufer die Größe des Arrays nicht angeben.

int AddUp (int Numbers []) {

Betrachten Sie diese Funktion im Beispiel Array01 und ein main (), das sie aufruft:

void ProcessArray (int Numbers []) { cout << "innere Funktion: Größe in Byte ist" << sizeof (Zahlen) << endl;} int main (int argc, char * argv []) {int MyNumbers [] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; cout << "äußere Funktion: Größe in Bytes ist"; cout << sizeof (MeineZahlen) << endl; ProcessArray (MeineNummern); return 0;}

Wenn Sie diese Anwendung ausführen, sehen Sie Folgendes:

Außenfunktion: Größe in Bytes ist 40 Innenfunktion: Größe in Bytes ist 4

Außerhalb der Funktion weiß der Code, dass die Größe des Arrays 40 Byte beträgt. Aber warum denkt der Code, dass die Größe 4 ist, nachdem er sich innerhalb des Arrays befindet? Der Grund dafür ist, dass Sie einen Zeiger wirklich an ein Array übergeben, obwohl es so aussieht, als würden Sie ein Array übergeben. Die Größe des Zeigers ist nur 4, und so wird die endgültige cout-Zeile gedruckt.

Das Deklarieren von Arrays hat eine leichte Eigenart. Wenn Sie ein Array deklarieren, indem Sie eine bestimmte Anzahl von Elementen angeben, z. B.

int MyNumbers [5];

Der Compiler weiß, dass Sie ein Array haben und der Operator sizeof gibt Ihnen die Größe des gesamten Arrays an. Der Array-Name ist dann sowohl als auch ein Zeiger und ein Array! Wenn Sie jedoch einen Funktionsheader ohne Array-Größe deklarieren, z. B.

void ProcessArray (int Numbers []) {

, behandelt der Compiler dies einfach als Zeiger und nicht mehr. Diese letzte Zeile entspricht in der Tat der folgenden Zeile:

void ProcessArray (int * Numbers) {

Innerhalb der Funktionen, die eine Zeile deklariert, sind also die folgenden zwei Codezeilen äquivalent <: Zahlen [3] = 10; * (Zahlen + 3) = 10;

Diese Äquivalenz bedeutet, dass Sie eine externe Deklaration für ein Array verwenden, z. B.

extern int MyNumbers [];

und dann nehmen Sie die Größe dieses Arrays, der Compiler wird verwirrt. Hier ein Beispiel: Wenn Sie zwei Dateien haben, Zahlen. CPP und Haupt. CPP, wo Zahlen. cpp deklariert ein Array und main. cpp extern deklariert es (wie im Array02-Beispiel gezeigt), erhalten Sie einen Compiler-Fehler, wenn Sie sizeof aufrufen:

#include using namespace std; extern int MeineNummern []; int main (int argc, char * argv []) {cout << sizeof (MeineNummern) << endl; return 0;}

In Code:: Blocks gibt der gcc-Compiler diesen Fehler:

Fehler: ungültige Anwendung von 'sizeof' auf unvollständigen Typ 'int []'

Die Lösung besteht darin, die Größe anzugeben. des Arrays in Klammern.Stellen Sie einfach sicher, dass die Größe die gleiche wie in der anderen Quellcode-Datei ist! Sie können den Compiler fälschen, indem Sie die Nummer ändern, und Sie

erhalten keinen Fehler . Aber das ist schlechter Programmierstil und nur nach Fehlern zu fragen. Obwohl ein

-Array einfach eine Folge von Variablen ist, die alle nebeneinander im Speicher liegen, ist der -Namen eines Arrays eigentlich nur ein Zeiger auf das erste Element im Array. Sie können den Namen als Zeiger verwenden. Tun Sie dies jedoch nur, wenn Sie wirklich mit einem Zeiger arbeiten müssen. Schließlich haben Sie wirklich keinen Grund, Code zu schreiben, der kryptisch ist, wie * (Numbers + 3) = 10;.. Die Umkehrung ist auch wahr. Schauen Sie sich diese Funktion an:

void ProcessArray (int * Zahlen) {cout << Zahlen [1] << endl;}

Diese Funktion verwendet einen Zeiger als Parameter, jedoch greifen Sie als Array darauf zu. Schreiben Sie keinen Code wie diesen; Stattdessen sollten Sie verstehen

, warum Code wie dieser funktioniert. Auf diese Weise erlangen Sie ein tieferes Wissen über Arrays und darüber, wie sie innerhalb des Computers leben, und dieses Wissen wiederum kann Ihnen beim Schreiben von Code helfen, der ordnungsgemäß funktioniert. Obwohl der Name des Arrays nur ein Zeiger ist, ist der Name eines Arrays von Ganzzahlen nicht das Gleiche wie ein Zeiger auf eine ganze Zahl. Überprüfen Sie diese Codezeilen (im Beispiel Array03):

int LotsONumbers [50]; int x; LotsONumbers = & x;

Richten Sie den Zeiger LotsONumbers

auf etwas anderes: etwas, das als ganze Zahl deklariert ist. Der Compiler lässt Sie das nicht tun; Sie erhalten einen Fehler. Das wäre nicht der Fall, wenn LotsONumbers als int * LotsONumbers deklariert würde; dann würde dieser Code funktionieren. Aber wie geschrieben, gibt Ihnen dieser Code einen Compilerfehler. Und glauben Sie es oder nicht, hier ist der Compiler-Fehler erhalten Sie in Code:: Blocks: Fehler: inkompatible Typen in der Zuordnung von 'int *' zu 'int [50]' Dieser Fehler impliziert der Compiler sieht ein eindeutige Unterscheidung zwischen den beiden Typen, int * und int []. Trotzdem ist der Name des Arrays tatsächlich ein Zeiger und Sie können ihn als einen verwenden. Man kann einfach nicht alles damit machen, was man mit einem normalen Zeiger machen kann, wie man es neu zuordnen kann.

Wenn Sie Arrays verwenden, beachten Sie die folgenden Tipps. Diese werden Ihnen helfen, Ihre Arrays fehlerfrei zu halten:

Halten Sie Ihren Code konsistent. Wenn Sie zum Beispiel einen Zeiger auf eine ganze Zahl deklarieren, behandeln Sie ihn nicht als Array.

Halten Sie Ihren Code klar und verständlich. Wenn Sie Zeiger übergeben, ist es in Ordnung, die Adresse des ersten Elements zu übernehmen, wie in & (MyNumbers [0]), wenn dies den Code klarer macht - obwohl es nur MyNumbers entspricht.

Wenn Sie ein Array deklarieren, versuchen Sie immer, eine Zahl in die Klammern zu setzen, es sei denn, Sie schreiben eine Funktion, die ein Array übernimmt.
Wenn Sie das Schlüsselwort extern verwenden, um ein Array zu deklarieren, setzen Sie die Array-Größe in Klammern. Aber sei konsistent! Verwenden Sie nicht eine Nummer einmal und eine andere Nummer ein anderes Mal. Der einfachste Weg, konsistent zu sein, ist die Verwendung einer Konstanten wie const int ArraySize = 10; in einer gemeinsamen Header-Datei und verwenden Sie diese dann in Ihrer Array-Deklaration: Int MyArray [ArraySize];..