Min, Max, Summe...

void einlesen(int feld[])

{
int i = 0;

printf("Bitte geben Sie eine Zahl ein:\n");
printf("Zum abbrechen bitte die Null eingeben:");

for(i=0;i<=LAENGE;i++)

{
scanf("%d", &feld[i]);

if(feld[i]==0)
{
break;
}
}

feld[LAENGE]=0;

}

Die Funktion ,,einlesen" wird von main aufgerufen.
Nach dem Aufruf kann man Werte eingeben. Diese Werte werden von der Funktion in die Main Funktion übernommen bzw. übergeben. Dies geschieht mit dem Rückgabewert ,,void" der Funktion ,,einlesen". Meine Frage: Wie kann die Funktion die Werte aus an die Main-Funtkion übergeben, obwohl als Rückgabewert ,,void" deklariert wurde???

drakon

Nutz diese Code Tags!

Wenn du etwas aus einer Funktion zurückgeben willst und das nicht über den Rückgabewert machst, passiert das normalerweise über einen Zeiger, oder eine Referenz.

Nexus

leave- schrieb:

Meine Frage: Wie kann die Funktion die Werte aus an die Main-Funtkion übergeben, obwohl als Rückgabewert ,,void" deklariert wurde???

Die Information, die von der Funktion an main() zurückgegeben wird, geschieht nicht über den Rückgabetypen, sondern über den Parameter. Du übergibst einen Zeiger auf int ( int feld[] ist in der Parameterliste das Gleiche wie int* feld ), der auf das Array zeigt. Nun können die Werte dahinter innerhalb der Funktion verändert werden. Zurück in main() hat man dann das manipulierte Array.

Arrays können nicht wie andere Datentypen direkt (als Kopie) an Funktionen übergeben werden. Man muss Zeiger oder Referenzen auf sie übergeben. So passieren Änderungen, die man in der Funktion am Array durchführt, direkt am Original-Array.

Bitte benutze [cpp]-Tags; einfach vor dem Code [cpp] und danach [/cpp] schreiben (du kannst auch die erste weisse Schaltfläche unter dem Textfeld auswählen).

Du kannst nicht eine variable zurückgeben die genauso heißt wie die Funktion

Ist das in C++ anders als in C?

int main(int ac, char **av)
{
    int main = 42;
    return main;
}

Sollte folglich zumindest eine Warnung wegen falschen Typs von main ergeben, tut's aber nicht.

Vielen Dank ,,Nexus"!
Die Formatierung werde ich beim nächsten Mal, falls ich eine Frage habe, übernehmen.

Mich hatte es gewundert, dass man bei normalen Funktionen ein ,,return" machen muss, um den Wert zu übergeben (siehe min- oder max Funktion).
Ist das bei der Min- oder Max Funktion auch ein Zeiger??
Oder handelt es sich nur um die Übergabeparamenter?? Der Aufbau der Funktionen ist ja überall gleich.

Nexus

Man hat grundsätzlich mehrere Möglichkeiten, Informationen von einer Funktion an den Aufrufer zurückzugeben.

Die geläufigste ist wohl der Rückgabetyp. Innerhalb einer Funktion kann man Werte mit return zurückgeben. Bei void -Funktionen können keine Werte zurückgegeben werden, aber man kann mit return; die Funktion beenden. Mit einem Rückgabetyp kann man schreiben

int ArrayMax = max(Array);

Die Signatur der Funktion sieht dann z.B. so aus:

int max(int* Array);       // Rückgabetyp ist int, ein Parameter vom Typ int* (Zeiger auf int)
int max(int Array[]);      // genau das selbe. Oder besser:
int max(const int* Array); // Zeiger auf const int (Array-Werte können nicht verändert werden)

Bei Arrays funktioniert der Rückgabetyp allerdings nicht, da Arrays nicht als Objekte behandelt werden (und somit keine Kopien möglich sind). Zudem will man manchmal ein Array verändern (z.B. Werte einlesen). In diesem Falle kann man einen Zeiger an die Funktion übergeben:

int Array[LAENGE];
einlesen(Array);   // übergibt den Zeiger auf das Array, nicht das Array selbst.

Die Signatur wäre dann die folgende:

void einlesen(int* Array);

Ich würde dir raten, dich noch ein wenig genauer über Funktionen und Zeiger zu informieren.

Vielen Dank für die gute Info über Funktionen.
Das mache ich gerade. Mein Problem sind die Funktionen mit Zeigern!!!

Sorry
Aber ich habe hier ein gute Beispiel gefunden.

Das Programm soll das Produkt ausrechnen.
In der Main stehen beim Funtionsaufruf zwei Parameter:
,,produkt(array,MAX))". Aber ich muss die ,,MAX" von der Aufrufenden doch gar nicht übergeben, oder??

DANKE!

#include <stdio.h>
#define MAX 10

int produkt(int[],int);

int main(void)
{
	int array[MAX], count;

	for (count=0;count<MAX;count++)
	{
		printf("Eingabe integer-Wert: ");
		scanf("%d",&array[count]);
	}

	printf("\n\nDas Produkt der eingegebenen Wert betraegt %d\n",produkt(array,MAX));

	return 0;
}

int produkt(int feld[],int laenge)
{
	int count, produkt=1;

	for (count=0;count<MAX;count++)
		produkt*=*feld++;

	return produkt;
}

Nexus

Jetzt, wo du ein globales MAX hast, das für alle Arrays gilt, nicht. Aber damit bist du natürlich überhaupt nicht flexibel.

Die Funktion sollte die übergebenen Parameter schon verwenden (das machst du mit laenge jetzt nicht).

int produkt(int* feld, int laenge)
{
    int count;      // ich würde separate Deklarationen machen, das ist weniger
    int produkt=1;  // fehleranfällig, besonders bei Zeigern

    for (count=0; count<laenge; count++)
        produkt *= *feld++;     // kann man auch so machen, ich finds jedoch
        produkt *= feld[count]; // übersichtlicher so

    return produkt;
}

Dann kannst du in main() so etwas haben:

int Array1[5] = {1, 5, 3, 2, 4};
int Prod1 = produkt(Array1, 5);

int Array2[3] = {15, 2, 8};
int Prod2 = produkt(Array2, 3);

Mittels des sizeof -Operators brauchst du die Grösse nicht mehr explizit anzugeben:

int Prod2 = produkt(Array2, sizeof(Array2)/sizeof(*Array2));

Aber das geht nur bei Arrays, nicht bei Zeigern (Arrays werden an Funktionen als Zeiger übergeben, innerhalb des Arrays funktioniert sizeof nicht mehr wie gewollt).

Ich vestehe auch nicht ganz wie so wir die Länge übergeben sollten.
Der erste Teil bis ,,Dann kannst du in main() so etwas haben:" ist verständlich
Woher weiß die aufgerufene Funktion, dass der Paramenter ,,LAEANGE"
(int produkt(int feld[],int laenge)) auf einmal wieder MAX heißt?

for (count=0;count<MAX;count++)
produkt*=*feld++;

Der Name wechselt von MAX in der Main-Funktion zu LAENGE in der aufgerufenen zu MAX in der aufgerufenen Funktion selbst.

Hat sich erledigt. Trotzdem dank

Man kann nur den Namen ,,LAENGE" in der aufgerufenen Funktion verwenden