using arrays with functions c
Alles, was Sie über Arrays mit Funktionen in C ++ wissen müssen:
In diesem Tutorial werden wir diskutieren, wie Arrays mit Funktionen in C ++ verwendet werden können. Im Allgemeinen können Arrays als Argumente an Funktionen übergeben werden, genauso wie wir die Variablen an Funktionen übergeben.
Die Bewertung formaler Parameter unterscheidet sich jedoch geringfügig, wenn es um Arrays geht. Bevor wir die Übergabe von Arrays an Funktionen untersuchen, müssen wir kurz das Konzept eines Zeigers auf ein Array diskutieren.
=> Lesen Sie hier die ausführlichen C ++ - Schulungsanleitungen.
Was du lernen wirst:
- Zeiger auf ein Array
- Übergeben von Arrays an die Funktion
- Arrays von Funktionen zurückgeben
- Fazit
- Literatur-Empfehlungen
Zeiger auf ein Array
Betrachten Sie das folgende Array, das die ersten fünf Zahlen der Fibonacci-Sequenz enthält.
int fibSeq(5) = {1,1,2,3,5};Deklarieren wir einen Zeiger fibPtr, um auf dieses Array zu zeigen.
int* fibPtr; fibPtr = fibSeq;Wenn wir den Inhalt von fibPtr drucken, ist die Ausgabe das erste Element des fibSeq-Arrays. Dies liegt daran, dass der Name des Arrays ohne eckige Klammern einen Zeiger auf das erste Element des Arrays ergibt. Daher zeigt der Name 'fibSeq' im obigen Beispiel auf das erste Element des Arrays 'fibSeq'.
Unten ist eine bildliche Darstellung davon:
Wie in der obigen bildlichen Darstellung gezeigt, zeigt fibPtr auf das erste Element des Arrays. Mit der Zeigerarithmetik können wir also alle Elemente des Arrays drucken, indem wir nur fibPtr verwenden.
Zum Beispiel, Ausdruck * (fibPtr + 1) zeigt auf das zweite Element des Arrays und so weiter.
Point-of-Sales-Systeme für iPad
Lassen Sie uns dies in ein Programm einfügen und die Ausgabe von 'fibSeq' und 'fibPtr' überprüfen:
#include #include using namespace std; int main() { int fibSeq(5) = {1,1,2,3,5}; int* fibPtr; fibPtr = fibSeq; cout<<'
fibSeq points to :'<<*fibSeq; cout<<'
fibSeq(0): '<<*fibPtr; cout<<'
fibSeq(1): '<<*(fibPtr + 1); cout<<'
fibSeq(2): '<<*(fibPtr + 2); cout<<'
fibSeq(3): '<<*(fibPtr + 3); cout<<'
fibSeq(4): '<<*(fibPtr + 4); } }Ausgabe:
fibSeq zeigt auf: 1
fibSeq (0): 1
fibSeq (1): 1
fibSeq (2): 2
fibSeq (3): 3
fibSeq (4): 5
Im obigen Beispiel deklarieren wir eine Zeigervariable fibPtr und lassen sie dann auf das Array zeigen, indem wir fibPtr den Namen des Arrays zuweisen. Wenn wir dies tun, machen wir den fibPtr-Punkt auf das erste Element des Arrays. Dann drucken wir alle Werte eines Arrays mit fibPtr.
Übergeben von Arrays an die Funktion
Wenn wir uns mit Funktionen befassen, übergeben wir Arrays auf ähnliche Weise an die Funktion, wie wir Variablen an die Funktion übergeben. Die Array-Variable vom Typ () wird jedoch nicht übergeben.
Stattdessen übergeben wir den Zeiger auf das Array, d. H. Den Namen des Arrays, der auf das erste Element des Arrays zeigt. Dann ist der formale Parameter, der diesen Zeiger akzeptiert, tatsächlich eine Arrayvariable. Wenn wir den Zeiger übergeben, können wir das Array innerhalb der Funktion direkt ändern.
Betrachten Sie das folgende Programm, das das Quadrat jedes Elements der ersten fünf Elemente in der Fibonacci-Sequenz berechnet, um die Übergabe eines Arrays an die Funktion zu demonstrieren.
#include #include using namespace std; void fibSeqSquare(int fibSeq()) { for(int i=0;i<5;i++) { fibSeq(i) *= fibSeq(i); } } int main() { int fibSeq(5) = {1,1,2,3,5}; fibSeqSquare(fibSeq); for(int i=0;i<5;i++) { cout<Im obigen Beispiel berechnen wir das Quadrat jedes Elements in einer Fibonacci-Sequenz. Dieses Quadrat wird innerhalb einer Funktion berechnet. Daher übergeben wir den Array-Namen an die Funktion „fibSeqSquare“, während wir die Funktion von main aus aufrufen. Innerhalb der Funktion berechnen wir die Quadrate jedes Elements.
Da wir den Verweis auf das Array über einen Zeiger übergeben haben, spiegeln alle Änderungen, die wir am Array innerhalb der Funktion vornehmen, das Array wider. Wenn wir also das Array in der Hauptfunktion drucken, erhalten wir die Quadrate jedes Elements als Ausgabe.
Im obigen Beispiel haben wir gesehen, dass das Array-Argument (formaler Parameter) der Funktion fibSeqSquare nicht die Größe des Arrays angibt, sondern nur die eckigen Klammern (()), um anzuzeigen, dass es sich um ein Array handelt. Dies ist eine Möglichkeit, die Array-Argumente anzugeben.
Eine andere Möglichkeit, das Array-Argument in der formalen Parameterliste anzugeben, besteht darin, die Größe des Arrays in eckigen Klammern anzugeben. Beide Argumente funktionieren ähnlich. Dies sind einfach die beiden Möglichkeiten, wie wir die Array-Argumente angeben.
Das folgende Beispiel zeigt ein mit size angegebenes Array-Argument.
#include #include using namespace std; void displayFibSeq(int fibSeq(5)) { for(int i=0;i<5;i++) { cout<Das obige Beispiel hat eine Funktion zum Anzeigen der Fibonacci-Sequenz. Die Funktion hat einen Parameter als Array, wobei wir auch die Größe des Arrays angegeben haben.
Auf die gleiche Weise wie oben gezeigt können wir auch mehrdimensionale Arrays an Funktionen übergeben.
SQL Server 2012 Interview Fragen und Antworten für erfahrene
Arrays von Funktionen zurückgeben
Wenn es darum geht, ein Array von einer Funktion zurückzugeben, können wir in C ++ nicht ein ganzes Array von der Funktion zurückgeben. Wir können jedoch eine Funktion erstellen, um einen Zeiger auf das Array zurückzugeben. Aber es gibt einen Haken darin.
Betrachten Sie den folgenden Code:
int* funcArray() { int arr(3) = {1,2,3}; return arr; } int main() { int* aryPtr = funcArray(); cout< Obwohl das obige Programm einfach den Zeiger von der Funktion auf das erste Element eines Arrays zurückgibt, funktioniert es nicht wie erwartet. Wir können nicht garantieren, dass das Programm die richtige Ausgabe liefert. Es kann die richtige Ausgabe geben oder nicht.
Dies liegt daran, dass wir die lokale Variable von function zurückgeben und nicht sicher sind, ob sie zum Zeitpunkt der Rückgabe im Gültigkeitsbereich sein wird oder nicht.
Kurz gesagt, C ++ bevorzugt nicht die Rückgabe von Arrays von Funktionen.
Wenn wir überhaupt Arrays von der Funktion zurückgeben müssen, müssen wir eine der folgenden Methoden verwenden:
# 1) Rückgabe dynamisch zugeordneter Arrays
Wir können den Array-Zeiger vom dynamisch zugewiesenen Array zurückgeben. Wir verwenden den Operator 'new', um das Array dynamisch zuzuweisen. Da es sich um ein dynamisches Array handelt, ist es im Geltungsbereich, es sei denn, wir löschen das Array. Daher läuft das Programm einwandfrei, wenn wir das Array zurückgeben.
wie man eine .eps-Datei öffnet
Dies wird im folgenden Beispiel gezeigt.
#include #include using namespace std; int* funcArray() { int* arr = new int(3); arr(0)=1; arr(1)=2; arr(2)=3; return arr; } int main() { int* aryPtr = funcArray(); cout< Ausgabe:
1 2 3
# 2) Rückgabe statischer Arrays
Da statische Variablen / Arrays im gesamten Programm einen Gültigkeitsbereich haben, können wir auch statische Arrays von Funktionen zurückgeben. Wir können ein Beispiel nehmen, um dies zu demonstrieren. Dies ist das gleiche wie im vorherigen Beispiel, mit dem einzigen Unterschied, dass wir in diesem Beispiel ein statisches Array anstelle des dynamisch zugewiesenen Arrays verwendet haben.
#include #include using namespace std; int* funcArray() { static int arr(3); arr(0)=1; arr(1)=2; arr(2)=3; return arr; } int main() { int* aryPtr = funcArray(); cout< Ausgabe:
1 2 3
Hinweis : Wir können auch eine Struktur verwenden, um das Array darin zu verpacken und diese Struktur dann zurückzugeben. Auf diese Weise geben wir natürlich ein Array von einer Funktion zurück. Dies ist jedoch keine sehr praktikable Methode zur Rückgabe von Arrays.
Fazit
Daher haben wir in diesem Tutorial Arrays in Bezug auf Funktionen im Detail besprochen. Wir hoffen, dass dieses Tutorial dazu beigetragen hat, alle Zweifel und Missverständnisse über C ++ - Arrays und -Funktionen auszuräumen.
=> Lesen Sie hier den perfekten C ++ - Schulungsleitfaden.
Literatur-Empfehlungen