Folgende Frage.

Ich habe eine Struktur:

struct meineStruktur
{
int variable;
}

und eine Funktion:

void meineFunktion(meineStruktur feld[100])
{
feld[1].variable=5;
}

In der Hauptfunktion greife ich folgendermaßen darauf zu:

int main()
{
meineStruktur feld[100];
meineFunktion(feld);
return 0;
}

Ist dies korrekt?
Mir kommt die übergabe an die Funktion in main etwas skeptisch vor...

void meineFunktion(meineStruktur [b]&[/b] feld[100])
{
    feld[1].variable=5;
}

Referenzen sind also noch nicht gelehrt worden und die Aufgabe muss trotzdem lösbar sein.

Es geht mir auch mehr darum ob hier:

meineFunktion(feld);

die Übergabe richtig ist, also ob das Array ohne [] oder sonst etwas angegeben wird und ob der Zugriff innerhalb einer Funtion auf die Struktur so genutzt werden kann?

mfg

Übergib das Feld per Referenz, sonst wird das ganze Array kopiert.

void meineFunktion(meineStruktur [b]&[/b] feld[100])
{
    feld[1].variable=5;
}

Das bringt gar nicht, denn Arrays werden immer als Zeiger übergeben.

Beispiel:

void meineFunktion(meineStruktur feld[100])
{
    std::cout << sizeof(feld) << '\n'; //gibt sizeof(&meineStruktur), (vermutlich 4), weils als Zeiger uebergeben wird
    feld[1].variable=5;
}	

int main()
{
    meineStruktur feld[100];
    std::cout << sizeof(feld) << '\n'; //gibt 100 * sizeof(feld) weils ein Array ist (vermutlich 400)
    meineFunktion(feld); //'feld' wird als Zeiger uebergeben!
    return 0;
}

Am Besten, Du übergibst Arrays als Zeiger + Längenanbgabe:

void meineFunktion(meineStruktur * feld, size_t n)
{
    //...irgendwas
}

Das macht Dich innerhalb der Funktion größenunabhängig.
Noch besser wäre es, die Standardlibrary-Container zu benutzen. Schau Dir z.B. mal den std::vector<T> an.

Übergib das Feld per Referenz, sonst wird das ganze Array kopiert.

Sicher?

@44203215ext
Die Übergabe ist schon richtig. Arrays werden in C++ immer als Zeiger auf das erste Element übergeben. D.h. alle Änderungen die in der Funktion durchgeführt werden betreffen das Originalarray.

Es ist auch Egal ob deine Funktionsdeklaration

void meineFunktion(meineStruktur feld[100])

oder

void meineFunktion(meineStruktur feld[])

oder

void meineFunktion(meineStruktur* feld)

lautet.

Den Compiler interressieren nur die für die Zeigerarithmetik nötigen Informationen.

Du musst allerdings selbst darauf achten die Arraygrenzen nicht zu überschreiten.

Innerhalb der Funktion wäre auch der Zugriff

feld[999].variable=5;

möglich, was aber natürlich später dann zu einem Laufzeitfehler führt.

Häufig macht es daher Sinn auch die Arraygröße an die Funktion zu übergeben.

Ver#?*#? !! War zu langsam.

Entweder habe ich ein Dejà vue, oder wir hatten gestern genau die gleiche Situation. (Kopie, du fragst sicher und bist zu langsam.. :p)

Übergib das Feld per Referenz, sonst wird das ganze Array kopiert.

void meineFunktion(meineStruktur [b]&[/b] feld[100])

Zu allem Überfluss ist das auch noch ein Array aus Referenzen -- sowas gibt es nicht. Wenn du ein Array per Referenz übergeben willst, müsste das so aussehen:

void meineFunktion(meineStruktur (&feld)[100])

Einfache Frage:

Ist das richtig:

structurname feld[100];
function(feld);

Die function greif dann auf die elemente von structurname zu.

...

Es wurde schon ein paar Mal gesagt, dass es so zwar geht, aber dass man besser die Größe des Arrays mit übergeben sollte.

Das bringt gar nicht, denn Arrays werden immer als Zeiger übergeben.

Nein, das stimmt nicht. Man kann Arrays entweder als Zeiger (auf das erste Element) oder als Referenz (auf das Array als Objekt) übergeben. Bashar hat ja ein Beispiel gezeigt.

Mit Templates kann das praktisch sein, weil dann die Grösse nicht mehr zusätzlich übergeben werden muss und trotzdem keine Information verliert:

template <size_t N>
void meineFunktion(meineStruktur (&feld)[N]);

...

Das funktioniert leider nur für statische Arrays. Bei dynamischen Arrays funktioniert das leider nicht mehr, weil die benötigte Information anonym und nicht verfügbar ist. Solche Konstrukte sind eher gefährlich denn nützlich.
Die Übergabe mit Zeiger+Größe hat ja den Sinn, ggf. beliebige Arrays beliebiger Länge verarbeiten zu können. Das ist bei der Variante mit Ref+Template nicht mehr gegeben.

Kritiker schrieb:

Ver#?*#? !! War zu langsam.

Entweder habe ich ein Dejà vue, oder wir hatten gestern genau die gleiche Situation. (Kopie, du fragst sicher und bist zu langsam.. :p)

Gar nicht gemerkt, dass das Wort an mich gerichtet wurde.

Ja, als unregistrierter Outsider bleibt einem ja nur die Möglichkeit einen Kommentar hinzuzufügen, wenn der eigene Beitrag zu spät kommt und praktisch dasselbe aussagt wie der vom Vordermann dem Schnellschreiber.

Das funktioniert leider nur für statische Arrays. Bei dynamischen Arrays funktioniert das leider nicht mehr, weil die benötigte Information anonym und nicht verfügbar ist. Solche Konstrukte sind eher gefährlich denn nützlich.

Ja, es funktioniert nur mit statischen Arrays. Aber zu sagen, Arrays könnten nur als Zeiger übergeben werden, ist dennoch falsch. Vor allem, weil mit "Array" in erster Linie ein statisches Array bezeichnet wird. Und warum soll die Übergabe als Referenz gefährlich sein? Wenn man etwas anderes als ein statisches Array übergibt, gibts einen Compilerfehler. Sicherer kann man ein Array (an sich) nicht übergeben.

Tachyon schrieb:

Die Übergabe mit Zeiger+Größe hat ja den Sinn, ggf. beliebige Arrays beliebiger Länge verarbeiten zu können. Das ist bei der Variante mit Ref+Template nicht mehr gegeben.

Da hast du schon Recht. Allerdings kommt es in der Praxis sowieso selten vor, dass man auf rohen Arrays arbeitet. Wenn, dann eher innerhalb einer Datenstruktur, und da könnte die Templatelösung bei statischen Arrays schon von Vorteil sein. Aber ich verwende zumindest immer std::tr1::array , wenn ich statische Arrays brauche, und ansonsten die STL-Container.

Kritiker schrieb:

Ja, als unregistrierter Outsider bleibt einem ja nur die Möglichkeit einen Kommentar hinzuzufügen, wenn der eigene Beitrag zu spät kommt und praktisch dasselbe aussagt wie der vom Vordermann dem Schnellschreiber.

Wieder ein Grund, sich anzumelden. Dann kannst du auch vermeiden, dass Flamewars unter deinem Namen ausgetragen werden.