C++: while do-Schleife mit OR-Inhalt

[Cyrics]

ich hab echte Probleme das mit den Funktionen zu verstehen!
Es scheitert bisher alles...

also denn irgendwie funktionieren meine Funktionien immer nur mit statischen Parametern, und da sind ja Funktionen herzlich nutzlos...

*grrr* das doofe ist, ich will das heute noch fertig kriegen, und muss mich jetzt hier erstmal über das Problem aufregen, und finde in 3 Stunden sciher die Lösung dafür...

also:
Problem: feld erzeugen als Funktion!

Prototyp ist erstellt mit:

void feld_erzeugen(int feld[NMAX]);

Funktionsaufruf:

feld_erzeugen(feld[NMAX]);

Funktionsdefinition:

void feld_erzeugen(int feld[NMAX])
{
 for (i=0, anz=0;i<NMAX; i++)
     {
           feld[i]= random(zufall);
     }
}

Man sieht... da ist irgendwie ein Denkfehler drin... ich verstehe ja auch, dass CPP einen Wert für Feld übertragen haben will, aber den kann ich ihm einfach nicht liefern, den soll er mir liefern... NMAX ist als const gegeben und feld als int global deklariert. Wenn ich es so wie oben durchgehe, dann kommt der Fehler:

[Linker error] undefined reference to `feld_erzeugen(int)'

ich kann einfach nicht mehr definieren... ich will doch bloss, dass er mir das Feld feld[NMAX] durch das Programm über alle Funktionen rüberschiebt... und das geht anscheinend nur, wenn ich ihm sage: irgendeineZahl[NMAX]

NMAX ist ja eine Zahl, nämlich eine konstante 100. Feld ist int, und wartet auf irgendeinen Wert, dem ich ihm nicht liefern kann und er selbst herausfinden soll... schwierige Sache, aber ich glaub da sprech ich einen unterschiedlichen Dialekt mit CPP, bzw. es versteht mich nicht so recht...

genug aufgeregt... weiter ans Werk, auch wenn ich keine Ahnung hab, wie ich CPP beibringen kann mich zu verstehen.
Vielleicht habt ihr ja eine Idee.

 

[Cyrics]

die Lösung des Problems liegt nicht in der Funktionsdeklaration sondern an der Übergabe...
man kann keine Variablen nicht unbestimmt übergeben, aber Zeiger kann man so übergeben! Das ist dafür sogar sehr sehr günstig dafür...

das viel mir da direkt nicht so ein... also man deklariert einen Zeiger mit dem Wertebereich integer z.B.

int *zeiger;

man gibt diesem eine endliche Grenze hier NMAX;

int NMAX=100;

zeiger = new int[NMAX]

als Alternative kann man dies variabel durch eine Eingabe machen ala:
cout <<"Wieviel Objekte sollen aufgenommen werden?";
cin>>anzahl;
zeiger = new int[anzahl];

die Übergabe bei einer Funktion würde nun durch die Adresse des Zeigers einfach nur überwiesen werden....

int Zeigerfeld_berechnen(int *zeiger)
{...
return zeiger;
};

int main()
neuer_zeiger = new int[anzahl]

{ neuer_zeiger = Zeiger_berechnen(&zeiger);
}

dadurch wird nun die Adresse des Zeigers an die Funktion Zeigerfeld_berechnen überwiesen. Dieser Zeiger hat eine bestimmte Länge, die nun ausgefüllt wird, und rücküberwiesen wird durch ein return in der Funktion. Dieser Wert wird dann an neuer_zeiger gegeben, damit man man diesem temporären Zeiger arbeiten kann ohne den anderen Zeiger zu benutzen, aber das kann ja jeder für sich machen.
Wenigstens war dies dann die Lösung meines Problems...

Formfehler sind da auf jeden Fall enthalten, und ja, Prototypen stehen oben, Funktionen unten und da sind sicher ein paar Fehler mehr drin... aber ich habs mir selbst erarbeitet! *hah*

ich geh nun shclafen... und bin ein bissel sauer wie kompliziert eine Programmiersprache sein muss, damit auch wirklich nur die klügsten 5% übrig bleiben um professionel das ganze anzugehen. Schade! Aber naja... bin gerade in so einer komischen Stimmung deswegen

 

[tjp]

also denn irgendwie funktionieren meine Funktionien immer nur mit statischen Parametern, und da sind ja Funktionen herzlich nutzlos...

void feld_erzeugen(int feld[NMAX]);

Du hast Probleme mit Arrays und nicht mit den Funktionen. Du definierst einen eine Funktion für einen speziellen Datentyp: einem Array of ints der Größe NMAX. Du kannst später nur Felder dieses Typs übergeben.

Wenn Du Felder von Int Werten beliebiger Größe übergeben willst mußt Du das so machen.

void feld_erzeugen (size_t const size, int& feld[]);

Die Feldgröße separat zu übergeben ist hier notwendig, da ein Feld keinerlei Information über seine Größe beinhaltet. Die Schreibweise feld[] ist nichts anderes als einen Zeiger auf Feld zu definieren. Die Klammer in [] C++ sind bei PODs nichts anderes als syntaktische Spielerei, erst der operator[] ändert das.

Was Du willst läßt sich mit einem std::vector sehr viel leichter und stringenter lösen.

void feld_erzeugen (std::vector<int>& feld);

 

[tjp]

und bin ein bissel sauer wie kompliziert eine Programmiersprache sein muss, damit auch wirklich nur die klügsten 5% übrig bleiben um professionel das ganze anzugehen.

Du kämpfst gerade mit den C-Altlasten von C++. Übrigens haben Deine Funktionen immer noch den fundamental Fehler, daß sie keine Übergabe der Feldlänge beinhalten. Seg Faults sind da vorprogrammiert.

In C enthält eine Feld niemals die Feldlänge. Wenn man an Funktionen Zeiger auf uninitialisierte Felder übergibt, muß man ebenfalls die Feldlänge als Parameter übergeben. Ansonsten ist die C Philosophie, daß man Felder unbestimmter Länge übergibt und das letzte Elemente eine Null-Zeiger enthält.

Eine C++ Lösung sieht anders aus, dazu nimmt man Container Klassen wie zum Beispiel std::vector.