Array an Funktion übergeben

[Understood]

Guten Morgen.

Ich habe eine Funktion geschrieben, die die Anzahl an Indizes im Array, das von der main()-Funktion übergeben wird, ausgibt.
Leider verläuft dieser Programmablauf fehlerhaft, den Fehler selber finde ich nicht, auch nach mehrmaligem Durchsuchen sieht eigtl. alles recht richtig aus.

Hier ist der ausschlaggebende Teil meines Programmcodes, der Rest ist, denke ich mal, wurscht:

#include <iostream>
#include <conio.h>

using namespace std;

void OUTPUT(int ARRAYOUTPUT[])
{
     cout << sizeof(ARRAYOUTPUT)/sizeof(int) << endl;
}

int main()
{
    int ARRAY[5];
    
    OUTPUT(ARRAY);
    
    getch();
    return 0;
}

Vielen Dank im Vorraus.

MfG, US.

 

[Cromon]

Hallo Understood

Der operator sizeof wird zu Komplizierzeit angewandt, nicht zu Laufzeit. Da es da noch nicht bekannt ist, wer was wann und wie die Funktion aufruft kann gar kein Wert angenommen werden. So viel zum einfach verständlichen, bzw praxisorientierten Teil.

Was die Theorie zusätzlich dahinter anbelangt kurz ein Zitat aus dem Standard bzgl. Funktionsparameter:

After determining the type of each parameter, any parameter of type “array of T” or “function returning T” is adjusted to be “pointer to T” or “pointer to function returning T,” respectively.

Mit anderen Worten: void OUTPUT(int ARRAYOUTPUT[]) wird zu void OUTPUT(int* ARRAYOUTPUT) und sizeof(int*) ist abhängig von der Plattform auf bzw. für die du compilierst und ist auf normalen x86 Umgebungen 4, auf normalen x64 Umgebungen 8. sizeof(int) ist auch variabel (einzige Anforderung: sizeof(int) >= 1). Entsprechend erhälst du als Ergebnis einfach 1 (x86).

Du musst die Länge des Arrays an die Funktion mitgeben. Aus diesem Grund verwendet der moderne Programmierer auch veraltete C-Arrays nur noch wenn man ihn entweder mit der Waffe am Kopf dazu zwingt (wobei einige wohl lieber sterben als ein Array zu verwenden) oder es wirklich gar keine andere Lösung mehr gibt.

In deinem Falle:

#include <iostream>
#include <array>

template<uint32 size>
void OUTPUT(const std::array<int, size>& arrayOutput) {
	std::cout << size << std::endl;
}

int main() {
	std::array<int, 5> dataArray{ { 0, 1, 2, 3, 4 } };
	OUTPUT(dataArray);

	std::cin.get();
	return 0;
}

Wie du siehst verzichtet der moderne Programmierer auch auf using namespace. Dies erzeugt mehr Probleme ohne einen Nutzen zu generieren. Wenn es dir zu viel Aufwand ist std::cout zu schreiben, dann sollte es dir nicht zu viel Aufwand sein std::cout zu schreiben. Wenn dich das dennoch nicht überzeugen kann mache ausschliesslich in dem Scope in dem du es verwendest eine using-Direktive (z.B. using std::cout;). Aber auch das hat nichts im globalen Scope verloren.

Viele Grüsse
Cromon

 

[deepthroat]

Wenn es dir zu viel Aufwand ist std::cout zu schreiben, dann sollte es dir nicht zu viel Aufwand sein std::cout zu schreiben.

Also ich hab mir den Satz jetzt mind. 5 x durchgelesen... aber irgendwie krieg ich's nicht auf die Reihe.

 

[Cromon]

Hehe, das sollte zum Ausdruck bringen, dass in dem Fall ein grundsätzliches Umdenken stattfinden sollte.