Rückgabe-Array von Funktion C++

Return Array From Function C

Arrays sind spezifische Container, die Werte desselben Datentyps haben. Funktionen in C++ führen Operationen auf Arrays aus, und diese Arrays werden dann an die Hauptfunktion zurückgegeben. Es gibt viele Ansätze, dieses Phänomen zu beschreiben. In diesem Handbuch werden einige gängige Methoden erläutert:

Verwenden Sie Zeiger, um das statische Array zurückzugeben

Wenn wir ein normales Array verwenden, besteht die Möglichkeit, dass anormale Ergebnisse erzielt werden. Um dies zu vermeiden, verwenden wir in unserem C++-Code ein statisches Array. Lassen Sie uns das von uns verwendete Beispiel verstehen. In dieser Funktion haben wir ein Array mit 5 Werten zum hier erwähnten Rückgabetyp deklariert.



Int *Funktion ()



Da der Wert ein ganzzahliger Typ ist, wird er im folgenden Beispiel als int gekennzeichnet. Da wir die Funktion als Zeiger eingeführt haben, wird die Funktion ein Zeigertyp sein. Nach Eingabe der Werte wird ein Array an das Hauptprogramm zurückgegeben.



Im Hauptprogramm haben wir einen Funktionsaufruf durchgeführt. Um den von der Funktion zurückgegebenen Wert zu akzeptieren, verwenden wir eine Integer-Variable. Wenn das Array zurückgegeben wird, können wir leicht auf seine Werte zugreifen. Die Werte werden manuell gedruckt.

Int*Zeiger=Funktion();

Der Zeiger dient dazu, das Element zu lokalisieren, das auf Index 1 des Arrays vorhanden ist. Mit anderen Worten, es zeigt die Adresse des Werts im Array an. Dann verwenden wir einen Funktionsprototyp, der den Zeiger zurückgibt.



Um die Ausgabe des durch die Funktion zurückgegebenen Arrays anzuzeigen, müssen wir im Fall von Linux Zugriff auf das Ubuntu-Terminal haben. Dies liegt daran, dass die Ausgabe über das Linux-Terminal zugänglich ist. Unter Linux benötigen wir einen Compiler, um C++-Codes auszuführen, die in einem beliebigen Texteditor geschrieben wurden. Diese Kompilierung erfolgt über G++. Das -o wird verwendet, um die Ausgabe in einer Datei zu speichern. Hier benötigen wir die Ausgabedatei und die Quellcodedatei. Nach der Kompilierung führen wir den Code aus:

$g++ -oderDatei1 Datei1.c
$./Datei1

Aus der Ausgabe können wir sehen, dass das Array, das in der Funktion initialisiert wurde, in der Hauptfunktion angezeigt wird, indem ein statisches Array verwendet wird, das manuell und durch die Zeiger initialisiert wird.

Dynamisch zugewiesenes Array mit Zeigern zurückgeben

Arrays können mithilfe der dynamischen Zuordnung zurückgegeben werden. Arrays können mit dem Wort new dynamisch zugewiesen werden. Sie verbleiben dort, bis wir sie selbst löschen. Statische Arrays haben eine feste Größe, was bedeutet, dass Sie die Größe während der Initialisierung angeben müssen. Sobald das Array erstellt wurde, ist es schwierig, die Größe zur Laufzeit oder später zu erhöhen. Im Fall des dynamischen Arrays können wir jedoch jederzeit weitere Elemente hinzufügen, da es sich bei der Eingabe von Werten erweitert. Wir müssen also keine Größe angeben oder identifizieren.

Gehen Sie zu dem Beispiel, das wir hier verwendet haben. Wir haben ein dynamisches Array mit den Zeigern wie in den vorherigen Beispielen verwendet, wo wir Zeiger mit den statischen Arrays verwendet haben.

Int*Funktion()

Nach der Funktionsdeklaration werden Arrays dynamisch deklariert:

Int*Array= Neu int [100];

Der Begriff neu wird ständig verwendet, um ein dynamisches Array zu erstellen. Wir führen Operationen auf dem Array durch, indem wir Werte eingeben. Danach wird das Array an das Hauptprogramm zurückgegeben:

Betrachten Sie nun die Hauptfunktion. Wir haben den Funktionsaufruf gemacht. Wenn das Array zurückgegeben wird, fügen wir eine Zeigervariable vom Typ Integer hinzu, um den Wert zu akzeptieren.

Int*Zeiger=Funktion();

Die im Array gespeicherten Werte werden manuell gedruckt. Die Ausgabe wird durch die Kompilierungs- und Ausführungsmethode erhalten.

Return-Array mit den Strukturen

Strukturen sind die Container wie Arrays. Array enthält jedoch jeweils den Wert desselben Datentyps. Und im Fall von Strukturen enthalten sie mehr als einen Datentypwert. Wir haben eine Struktur namens sample genommen. Hier befindet sich die Array-Deklaration innerhalb der Strukturen anstelle von Funktionen. Der Rückgabetyp ist der Name der Struktur. Die Strukturvariable wird an das Hauptprogramm zurückgegeben. Die Struktur verwendet das Wort struct für die Deklaration.

Strukturmuster
{
Int arr[100];
};

Nach der Strukturdeklaration haben wir eine Funktion verwendet, in der ein Strukturobjekt erstellt wird. Dieses Objekt wird verwendet, um auf die Struktur zuzugreifen. Diese Funktion gibt das Strukturobjekt an die Hauptfunktion zurück, damit wir das Array über dieses Objekt ausgeben können. Eine Variable erhält die Werte in der Variablen. Dieser Wert ist die ganze Zahl, bis zu der wir Werte in das Array eingeben. Wie in diesem Beispiel haben wir als Zahl 6 gewählt. Also werden die Zahlen bis 6 in das Array eingetragen.

Strukturbeispielfunktion(intn)

Nun bewegen wir uns zum Hauptprogramm und haben ein Objekt erstellt, um auf das Array zuzugreifen:

Strukturprobe x;

Nach der Objektinitialisierung wird der Variablen ein Wert hinzugefügt, bis zu dem die Zahlen in das Array eingetragen werden sollen. In einem Funktionsaufruf übergeben wir den Wert im Parameter:

x=Funktion(n);

Wir werden die Anzeige mit der for-Schleife haben. Die Werte werden durch das beim Start des Hauptprogramms deklarierte Objekt angezeigt:

Die Ausgabe zeigt an, dass im Ergebnis 6 Werte angezeigt werden, da wir 6 Zahlen in das Programm eingegeben haben.

Return-Array mit Std

C++ verwendet viele Methoden, um ein Array von der Funktion zurückzugeben. Eine davon ist über std::array. Es ist eine Strukturvorlage. Diese Funktion bietet auch zwei weitere Funktionen, nämlich size() und empty(). Es wird ein Array-Name zurückgegeben, der angibt, dass das gesamte Array an das Hauptprogramm zurückgegeben wird. Hier fügen wir ein Header-Datei-Array hinzu. Es enthält neben der Bibliothek alle Funktionen des Arrays.

#enthalten

Array<int,10>Funktion()

Da wir das gesamte Array mit seinem Namen zurückgeben können, verwenden wir bei der Deklaration einer Funktion das Array als Rückgabetyp. Daten werden in das Array eingetragen. Danach wird das Array an das Hauptprogramm zurückgegeben. Wenn Sie sich der Hauptfunktion zuwenden, akzeptiert eine Array-Variable das Array, wenn die Funktion aufgerufen wird.

arr=Funktion();

Auch hier wird die for-Schleife zum Anzeigen von Array-Werten verwendet. Wir beobachten die Ausgabe aus dem unten angezeigten Bild. Da wir 10 Größen verwendet haben, werden 0 Zahlen eingegeben. Daher werden diese angezeigt:

Return Array durch Vektorcontainer

Dieser Ansatz ist ein dynamisch zugewiesenes Array. Wie in diesem Fall muss die Array-Größe nicht angegeben werden. Wir brauchen hier keinen Größenparameter. In diesem Beispiel müssen wir der Bibliothek einen Vektor-Header hinzufügen, der die Funktionalitäten des Vektors enthält.

Weiter zur Funktion, bei der der Rückgabetyp ebenfalls ein int-Vektor ist und auch einen Vektorzeiger als Argument im Parameter enthält. Ein Array mit dem Namen temp wird hier eingeführt:

Vektor<int>MultiplyArrayByTwo(constVektor<int> *arr)

Die Funktion multipliziert die Elemente des Arrays mit zwei, indem sie die Funktion tmp.push_back() verwendet. Geben Sie dann die tmp zurück. Eine Autotyp-Variable akzeptiert die Werte des Arrays von der Funktion. Das Array enthält die darin enthaltenen Elemente.

Die Ausgabe zeigt die Funktionsweise des Vektorcontainers.

Abschluss

Im oben genannten Artikel haben wir die fünf am häufigsten verwendeten Methoden beschrieben, um die Funktionalität der Rückgabe eines Arrays von der Funktion zu erklären.