[centro]

int Function1();
void Function2();
void Function3();
void Function4();
void Function5();
void Function6();
void Function7();


int main()
{

char Zeichen;

do
{

printf("\n");
printf("Would you like to");
printf("a.Calculate the area fo a square?\n");
printf("b.Calculate the area fo a circle?\n");
printf("c.Calculate the volume of a cube?\n");
printf("d.Calculate the volume of a sphere?\n");
printf("e.Calculate the area of an equilateral triangle?\n");
printf("q.Quit.\n");

switch (Zeichen)// Die Frage die sich stellt?Wie kommt es dazu das beim zweiten Durchlauf der Schleife es zu einer doppelte Ausgabe der printf-anweisung kommt.
{


case'a':Function1();break;
case'b':Function2();break;
case'c':Function3();break;
case'd':Function4();break;
case'e':Function5();break;
case'f':Function6();break;
case'q':Function7();break;
}



printf("Geben sie bitte ein Buchstaben zwischne a-f ein:");
scanf("%c",&Zeichen);



}
while(Zeichen!='q');




return 0;
}
int Function1(){
printf("a\n");
printf("Geben Sie den Wert ein mit dem Sie die Funktion berechnen wollen:");
int temp;
scanf("%i",&temp);
int er=temp+100;
printf("%i\n",er);

return er;
}


void Function2(){
printf("b\n");
// das was in function1() steht hätte ich ja auch in die anderen reinschreiben können bin aber zu faul
}

void Function3(){
printf("c\n");

}

void Function4(){
printf("d\n");

}

void Function5(){
printf("e\n");

}

void Function6(){

printf("f\n");

}
void Function7(){

printf("Good bye Milan");

}

Eine andere frage hätte ich da noch diese Funkionen sind ja alles void sie haben somit keine
Rückgabewert wie kann ich den eine Funktion schreiben bei den ich zwei Werte eingebe sie dann wieder- gebe, also mir ist schon klar das ich return benutzen muß.
z.b
int function(int x ,int y);//funktionskopf
int main()
{
int function(int x,int y);
return 0;
}

int function(int x, int y)
{
printf("Zwei Werte");
scanf("%i ",&x );
printf("\n");
scanf("%i " ,&y);



return x,y;
}
DAS Programm funktionier nicht aber warum kann man den Rückgabewert so nicht schreiben return x,y;
oder kann der immer nur einen Wert wiedergeben wenn ?.
oder ist da einfehler bei der main .ach ja befor jemand sagt es fehlt #include <stdio.h>
#include <stdlib.h> habe mit eingebunden ist nur nicht gep..,, danke schon mal

Dieser Beitrag wurde von centro bearbeitet: 24. Februar 2008 - 14:28

[centro]

ich habe mal was ausprobiert und warum bekomme ich bei dem zweiten Wert nicht normales raus.
Wo ist mein fehler!

int produkt(int x, int y);

int main()
{
int a, b;
printf("Geben sie zwei Zahlen ein");
printf("\n");
printf("Erste Zahl:");
scanf("%i",&a);
printf("\n");
printf("Zweite Zahl:");
scanf("%i",&b);
int Ergebnis=produkt(a,b);
printf("ergebnis %i %i",Ergebnis);
return 0;
}
int produkt(int x,int y)
{
x=x+100;
y=y+100;

return y,x;
}

Dieser Beitrag wurde von centro bearbeitet: 24. Februar 2008 - 15:32

[Diewie]

Hi,

mit return kannst du nur einen Wert zurückgeben, daher funktionieren deine Beispiele nicht. Für deine Zwecke gibt es zum Beispiel Call-By-Reference, was jedoch voraussetzt, dass du dich mit Zeigern etwas auskennst.

Dein Problem mit der doppelten Ausgabe vom Menü, kommt davon, dass der Zeilenumbruch noch im Puffer ist und somit bei den weiteren Durchläufen als das eingelesene Char erkannt wird.
Dies kannst du z.B. nach dem scanf mit einem getchar() oder so einer Schleife mit getchar() erreichen.

while (getchar() != '\n');

Gruß,
Stefan

[centro]

int main()

{

int m, *m_ptr=&m;
float p, *p_ptr=&p;
*m_ptr=4;
*p_ptr= 3;

printf("%i\n",m_ptr);
printf("%i\n",*m_ptr);
printf("%i\n",&m_ptr);

printf("%f\n",p_ptr);
printf("%f\n",*p_ptr);

return 0;
Also ich habe mich mal schlau gemacht was du mit den Zeiger gemeint hast.
Zeiger werde benutzt auf eine Adresse einer Variabel zu zeigen und somit wird der Wert über geben.
Also int *p=&m sagt uns das der Pointer auf die Adresse von m zeigt.
Die frage die sich jetzt stellt ist. Da das das Programm von oben nach unten läuft muß ich den wert für n m unter der Deklaration schreiben so geht es oder .

Dieser Beitrag wurde von centro bearbeitet: 24. Februar 2008 - 18:34

[Diewie]

Hier mal dein obiges Beispiel mit Call-By-Reference realisiert. Du übergibst praktisch die Adresse der Variablen a und b an die Funktion produkt und dort werden die unter der Adresse gespeicherten Integer-Variablen um 100 erhöht. Nach dem Funktionsaufruf haben die Variablen a und b somit einen um 100 größeren Wert.

#include <stdio.h>

void produkt(int *x, int *y);

int main()
{
	int a, b;

	printf("Geben Sie zwei Zahlen ein.\n\n");

	printf("Erste Zahl: ");
	scanf_s("%i", &a);

	printf("Zweite Zahl: ");
	scanf_s("%i", &b);

	//Adresse von a und b an die Funktion übergeben
	produkt(&a, &b);

	printf("\nErgebnis:  a: %i, b: %i", a, b);

	return 0;
}

//Übergebene Integer um 100 größer machen
void produkt(int *x,int *y)
{
	*x += 100;
	*y += 100;
}

Der Rest sollte selbsterklärend sein.

Gruß,
Stefan

[centro]

Ok.
Also ,in dem ich die Adressen der Funktion übergebe, kann ich auf die Werte ,die ich dann einlese zugreifen .Soweit komme ich mit auch beim Aufbau des Programm ist alles klar .Was mich stört ist das das Programm ja aus der main in den Funktionskörper springt die Rechenoperation ausführt und dann die Werte ausgibt. Ich finde es einfach nicht schön dieses Rumgespringe .Bei dem Moment der Übergabe der Adressen in den Funktionskörper ist der Pionter ja deklariert worden mit *p=+100.
Also steht da ja nicht anders als . Durch Eingabe: m=3 dann folgt *p=&m , dadurch übergeben ich den Pointer die Adresse und den Wert auf den er zugreifen kann und am Ende gebe ich
*p aus über printf. Nur ich habe a und b stehen was im Grunde nicht anders ist oder. Ich muss ehrlich sagen als ich die Ausgabe gesehen habe von der Funktion habe ich erst gedacht das du die Adressen um 100 erhöht hättest , aber so ist ja nicht .
Wenn ich noch anmerken darf ist es noch schwierig sofort zu sehen das a und b die Ausgabe der Funktion sind .Ich verstehe es wenn ich es sehe aber es ist alt noch nur passive Wissen .
Somit glaube das die Leichtigkeit erst durch das Programmieren kommt . Danke für qualitative Hilfe noch eine schönen Sonntagabend wünsche ich dir .

Dieser Beitrag wurde von centro bearbeitet: 24. Februar 2008 - 22:29

[Diewie]

Welches "Rumgespringe" meinst du? Man lagert bestimmte Dinge in Funktionen aus, weil es den Code übersichtlicher macht und man die Funktionen einfach wieder verwenden kann ohne Redundanz im Code zum haben, usw.

Der Aufruf mit produkt(&a, &b); von void produkt(int *x, int *y) bedeutet ausgeschrieben eigentlich nichts anderes als:

int *x = &a;
int *y = &b;

Ab jetzt ist in x und y die Adresse a bzw. b gespeichert. Will man nun den Wert der unter der Adresse gespeicherten Variable verändern, so kann man dies mit *x bzw. *y machen. Würde man hingegen sowas wie x++; machen, so würde der Pointer x nun auf eine andere Adresse zeigen und würde somit Datenmüll produzieren (der evtl. sogar dieses oder andere Programme zum Absturz bringen könnte), wenn man mit *x etwas verändert.

Wenn man *x und *y verändert, dann sind die unter den Adressen von a und b gespeicherten Werte ebenfalls verändert. Deshalb stehen die Änderungen nach Rücksprung auch in main zur Verfügung.

Das Prinzip von Call-By-Reference kannst du dir so vorstellen. Du gibst einem Bekannten einen von dir geschriebenen Bericht und der liest ihn und korrigiert ihn direkt in deinem Entwurf. Danach erhältst du den geänderten Bericht zurück.

Übergibst du einen Variable jedoch "normal" (By-Value), so ist dies, als wie du deinem Bekannten nur eine Kopie deines Berichtes gibst. Wenn er dir diesen wieder zurückgibt (return), so ist dein Entwurf (die übergebene Variable) aber noch unverändert.

Ich hoffe das hilft weiter.

Gruß,
Stefan

[centro]

Echt nett von dir.
Mit den Pointer habe ich es verstanden . Es fehlt mir halt noch die Übung.
Verstanden habe ich es .
Aber ich glaube du wirst nicht das letzte mal von mir gehört haben .

Dieser Beitrag wurde von centro bearbeitet: 24. Februar 2008 - 23:48