Array an Funktion übergeben (Zeiger)

paddymann

Mitglied
Moin!

Ich will ein globales Array an eine Funktion übergeben. Das sollte man doch mithilfe eines Zeigers machen richtig? Warum eigentlich?

Ja und dann hab ich das mal versucht und ich weissnicht wie ich einen Zeiger auf ein Array an eine Funktion übergeben soll. Hier mal mein Code bisher:

Code:
#include <iostream>

using namespace std;

int someInt;
unsigned short int someArray[9];

//someInt und someArray sollen an diese Funktion übergeben werden
void arrayAusgeben(int *, unsigned short int *[9]); //1?

int main (int argc, char * const argv[]) {
	int i; //Zählervariable
	
	someInt = 5;
	for(i=0;i<10;i++)
		someArray[i] = i*2;
	
	//someInt und someArray durch Funktion auf Bildschirm ausgeben lassen
	arrayAusgeben(&someInt,&someArray[0]); //2?
	
	
	
	//(Konsole nicht sofort schließen)
	int wait;
	cin >> wait;
    return 0;
}


void arrayAusgeben(int * number, unsigned short int *array[9]) { //3?
	int i;
	for(i=0;i<10;i++)
		cout << *array[i] << endl;
}


Also bei 1) hab ich überhaupt keine Ahnung, wie ich dem klar machen könnte, dass ich einen Zeiger auf ein Array übergeben will.
Ists richtig bei 2) die Adresse vom ersten Element des Arrays zu übergeben?
Ja und bei drei is quasi wieder das gleiche wie bei 2).

Mir fällt echt nichts ein wie ich das machen könnte. Also würd mich über Hilfe freuen.
besten Dank schonmal im Voraus.

Beste Grüße!
 
Hi.

Ein Array "zerfällt" in einem Zeiger-Kontext implizit in einen Zeiger auf das erste Element des Arrays. D.h. ein Array ist einfach nur ein Block im Speicher der an einer bestimmten Adresse beginnt.
C++:
int array[55];

int* pArray = array; // Zeiger-Kontext
int* pNochmal = &array[0]; // äquivalent zu drüber

pArray == pNochmal; // true!
Für die Übergabe gibt es 2 Möglichkeiten:
C++:
void arrayAusgeben(int, unsigned short int[9]);

// oder:

void arrayAusgeben(int, unsigned short int *);
In der Regel würde man allerdings die 2. Möglichkeit vorziehen, da dort Arrays beliebiger Größe übergeben werden können. Außerdem solltest du die Größe des Arrays übergeben und nicht fest in der Funktion kodieren.

Was willst du mit der Übergabe von someInt überhaupt erreichen?

Und warum definierst du das Array überhaupt global?

Gruß
 
Danke für die Antwort!

Was willst du mit der Übergabe von someInt überhaupt erreichen?

Das war nur für mich damit ich sehe wies bei einer normalen Variablen klappt und bei einem Array nicht ;-) oder so...

Und warum definierst du das Array überhaupt global?
Gute Frage eigentlich^^ Also eigentlich möchte ich aus mehreren unterschiedlichen Funktionen auf das Array zugreifen können und es verändern können. Wenn ichs global deklariere kann ich ja eigentlich aus allen Funktionen ganz normal drauf zugreifen wie mir grad auffällt.
Ich hab someInt und someArray jetzt mal lokal in main() definiert, damit die Problematik erhalten bleibt...

Also so hab ich versucht den Code zu verbessern:

Code:
#include <iostream>

using namespace std;

//someInt und someArray sollen an diese Funktion übergeben werden
void arrayAusgeben(int *, unsigned short int *); //1?

int main (int argc, char * const argv[]) {
	int someInt;
	unsigned short int someArray[9];
	
	int i; //Zählervariable
	unsigned short int *pSomeArray = someArray;
	
	someInt = 5;
	for(i=0;i<10;i++)
		someArray[i] = i*2;
	
	//someInt und someArray durch Funktion auf Bildschirm ausgeben lassen
	arrayAusgeben(&someInt,pSomeArray); //2?
	
	
	
	//(Konsole nicht sofort schließen)
	int wait;
	cin >> wait;
    return 0;
}


void arrayAusgeben(int * number, unsigned short int *pArray) { //3?
	int i;
	for(i=0;i<10;i++)
		cout << *pArray[i] << endl; //4
}

Ist die Übergabe der Werte bei 1),2) und 3) jetzt richtig? Bei 4) bekomme ich einen Fehler: "invalid type argument 'unary *'.

Gruß!
 
Hi.
Also so hab ich versucht den Code zu verbessern:

Code:
void arrayAusgeben(int * number, unsigned short int *pArray) { //3?
	int i;
	for(i=0;i<10;i++)
		cout << *pArray[i] << endl; //4
}

Ist die Übergabe der Werte bei 1),2) und 3) jetzt richtig?
Ja. Du mußt aber auch nicht den "Umweg" über eine extra Variable machen, du kannst auch einfach das Array an die Funktion übergeben:
C++:
arrayAusgeben(&someInt, someArray); // Zeiger-Kontext beim Array
Bei 4) bekomme ich einen Fehler: "invalid type argument 'unary *'.
Der Zugriff auf ein bestimmtes Arrayelement über den Indexoperator ist nichts weiter als Zeigerarithmetik:
C++:
int array[5];

array[3] = 55;

// oder:

*(array + 3) = 55; // das gleiche wie drüber.

// schrittweise:

int* pArray = array;

*(pArray + 3) = 55;

// oder:
pArray[3] = 55; // das gleiche wie drüber
Gruß
 
Zuletzt bearbeitet:
Ja cool, der Code funktioniert dann jetzt soweit. Danke dafür!

Mal noch eine generelle Frage:
Wenn ich auf ein Array aus mehreren Funktionen zugreifen will, ist es doch am einfachsten das Array global zu deklarieren oder nicht? Dann bräuchte ich gar nichts an die jeweilige Funktion zu übergeben... Frage mich nur wann es denn dann sinnvoll ist einen Zeiger an eine Funktion zu übergeben?
 
Stimmt schon, wenn du es schon Global hast, brauchst du natürlich keinen Pointer übergeben.
Zum SInn davon fällt mir ur ein, dass man die Funktion vielleicht auch einmal in einem anderen Programm verwende möchte, in dem das Array nicht global ist...entweder müsstest du dann die Funktion ändern oder das restliche Programm :), das erspart man sich damit
 
Ja cool, der Code funktioniert dann jetzt soweit. Danke dafür!

Mal noch eine generelle Frage:
Wenn ich auf ein Array aus mehreren Funktionen zugreifen will, ist es doch am einfachsten das Array global zu deklarieren oder nicht? Dann bräuchte ich gar nichts an die jeweilige Funktion zu übergeben... Frage mich nur wann es denn dann sinnvoll ist einen Zeiger an eine Funktion zu übergeben?
Wenn du in deinem ganzen Programm in allen Funktion nur ein einzelnes Array verarbeiten willst, kannst du das Array ruhig global definieren und direkt in den Funktionen verwenden ohne Übergabe des Zeigers.

Wenn du aber mehr als ein Array verwendest und du willst diese Arrays ausgeben, müßtest du ja dann für jedes Array eine eigene Funktion definieren, die sich dann nur im Namen des verwendeteten Arrays unterscheiden. Das ist dann nicht wirklich sinnvoll und wird früher oder später zu einem Wartungsalbtraum.

Gruß
 
Würde dir anstelle die Größe als Parameter zu übergeben eher folgendes empfehlen:
C++:
std::ostream& print_array(std::ostream& out, int* ptr_begin, int* ptr_end)
{
    for (int* ptr_it = ptr_begin; ptr_it != ptr_end; ++ptr_it)
        out << *ptr_it;
    // std::copy(ptr_begin, ptr_end, std::ostream_iterator<int>(out, "")); ginge dann z.B. auch :P
    return out;
}

int main()
{
    int array[] = {0, 1, 2, 3 };
    std::cout << print_array(std::cout, array, array + 4) << std::endl;
}
;)
 
Zurück