Hallo, ich habe eine Aufgabe, indem man soll ein Folge von beliebigen Startzahl x erzeugen:.... Aber kommt noch eine Fehler: "to many argument to function ulam()". wie kann ich den Fehler lösen? /*3 regeln der Folge: 1.wenn x = 1, stop 2.x ist gerade, wird sie halbiert->nach 1. 3.x ungerade,verdreifacht und um eins vermehr->1 */ #include"stdio.h" #include"conio.h" #include"stdlib.h" int main() { long int x; long int ulam(); printf("Geben ein ganze Zahl: ",x); scanf("%ld",&x); printf("%ld\n", ulam(x)) } long int ulam(long int x) { if(x<=1) return (1); else return(printf("%8ld",x),(x%2)?ulam(3*x+1):ulam(x/2)) getch(); }
Der Prototyp: long int ulam() muss aus der main() raus, und muss die Typen der Parameter deklarieren.
@ Bob ist nicht drin, sieht nur so aus :) Zweimal Semikolon an der richtigen Stelle sollte auch etwas bringen...
also hier muss ich auch schon mal überlegen, für mich macht das auch kein sinn return( printf("%8ld",x) , (x%2)?ulam(3*x+1):ulam(x/2) ) und dann noch ohne ; muss mal als anfänger gleich alles auf eine zeile schreiben? Deswegen wird der code auch nicht kleiner.
> Aber kommt noch eine Fehler: "to many argument to > function ulam()". wie kann ich den Fehler lösen? Den bekomm ich hier nicht, dafür einen ganzen Stapel anderer (Syntax)Fehler.. ich war mal so frei den Code zu bereinigen (und etwas aufzuhypschen):
1 | include"stdio.h" |
2 | //#include"conio.h" |
3 | //#include"stdlib.h" |
4 | |
5 | long int ulam(long int x) |
6 | { |
7 | if (x <= 1) |
8 | return 1; |
9 | else { |
10 | printf("%ld\n", x); |
11 | return (x%2) |
12 | ? ulam(3 *x +1) |
13 | : ulam(x/2); |
14 | } |
15 | } |
16 | |
17 | |
18 | int main() |
19 | { |
20 | long int x; |
21 | long int ulam(); |
22 | printf("Geben ein ganze Zahl: "); |
23 | scanf("%ld",&x); |
24 | printf("%ld\n", ulam(x)); |
25 | |
26 | return 0; |
27 | } |
..achja und der Kommaoperator.. naja, nur wenns unbedingt auf möglichst funkionalen Programmierstil hingeprügelt werden soll, sonst führt der gerne vollkommen sinnfrei zu völlig unnötigen Verwirrungen.. HTH und HF
> und wozu soll das gut sein?
Zum auskommentieren. Hier die korrigierte Version für Pedanten:
// long int ulam();
HTH und nix für ungut.
g457 schrieb: > (Syntax)Fehler.. ich war mal so frei den Code zu bereinigen (und etwas > aufzuhypschen): > >
1 | > long int ulam(long int x) |
2 | > { |
3 | > if (x <= 1) |
4 | > return 1; |
5 | > else { |
6 | > printf("%ld\n", x); |
7 | > return (x%2) |
8 | > ? ulam(3 *x +1) |
9 | > : ulam(x/2); |
10 | > } |
11 | > } |
12 | > |
Ist mir ehrlich gesagt immer noch zu kryptisch. Ich würds so schreiben
1 | long int ulam(long int x) |
2 | {
|
3 | if (x <= 1) |
4 | return 1; |
5 | |
6 | printf("%ld\n", x); |
7 | |
8 | if (x%2 != 0) |
9 | return ulam(3 *x +1); |
10 | |
11 | return ulam(x/2); |
12 | }
|
nach einem return in einem if ein else zu machen ist sehr oft entbehrlich ohne das es der Klarheit schadet. Ganz im Gegenteil gewinnt IMHO der Code oft an Klarheit dadurch. Und das Rätselraten beim schnellen Hinschauen ob es einen Weg durch die Funktion gibt, in dem kein return vorkommt ist dann auch gleich weg. > ..achja und der Kommaoperator.. naja, nur wenns unbedingt auf möglichst > funkionalen Programmierstil hingeprügelt werden soll, sonst führt der > gerne vollkommen sinnfrei zu völlig unnötigen Verwirrungen.. Full ACK! Grossen Bogen drumm machen. Mit dem Komma-Operator schiesst man sich sehr viel öfter unnötig ins Knie, als einem lieb ist.
Eventuell übersehe ich ja was, aber die Funktion gibt sowieso immer "1" zurück, man könnte sich die gnaze Rekursion also auch irgendwie sparen... Alos etwa so:
1 | long int ulam(long int x) { |
2 | while(x > 1) { |
3 | printf("%ld\n", x); |
4 | if (x % 2 != 0) { |
5 | x = 3 * x + 1; |
6 | } else { |
7 | x = x / 2; |
8 | }
|
9 | }
|
10 | return 1; |
11 | }
|
(wozu man dann einen longint dafür braucht ist mir dann auch schleierhaft). Ist die Funktion überhaupt steng monoton fallend oder kommt man ggf sogar in eine Endlosschleife? Kenn mich mit der "ulam" Funktion leider nicht so gut aus ;P
Läubi .. schrieb: > Eventuell übersehe ich ja was, aber die Funktion gibt sowieso immer "1" > zurück, man könnte sich die gnaze Rekursion also auch irgendwie > sparen... Wenn du das beweisen kannst, nimmst du den Mathematikern wieder was zum spielen weg scnr http://de.wikipedia.org/wiki/Collatz-Problem > Alos etwa so: >
1 | long int ulam(long int x) { |
2 | > while(x > 1) { |
3 | > printf("%ld\n", x); |
4 | > if (x % 2 != 0) { |
5 | > x = 3 * x + 1; |
6 | > } else { |
7 | > x = x / 2; |
8 | > } |
9 | > } |
10 | > return 1; |
11 | > } |
(wozu man dann einen longint dafür braucht ist mir dann auch > schleierhaft). Ist die Funktion überhaupt steng monoton fallend oder > kommt man ggf sogar in eine Endlosschleife? Kenn mich mit der "ulam" > Funktion leider nicht so gut aus ;P
Mathematik hin oder her, ich sehe einfach nicht das die Funktion entweder 1 zurückgibt, oder nie endet, aber gut zu wissen das es das Collatz-Problem ist ;) Wenn dies aber die einzige Fälle sind verwirrt die "return ...." Sache nur und ich würde außerdem eine maximale Rekursionstiefe vorgeben und nicht hoffen das irgendwann ein Stackoverflow mir anzeigt das es keine Lösung gibt oder es sich um einen "Kreis" handelt. Da machen wir wohl mal wieder für andere Leute ihre Hausaufgabe.
Läubi .. schrieb: > Mathematik hin oder her, ich sehe einfach nicht das die Funktion > entweder 1 zurückgibt, oder nie endet, aber gut zu wissen das es das > Collatz-Problem > ist ;) > Wenn dies aber die einzige Fälle sind verwirrt die "return ...." Sache > nur und ich würde außerdem eine maximale Rekursionstiefe vorgeben und > nicht hoffen das irgendwann ein Stackoverflow mir anzeigt das es keine > Lösung gibt oder es sich um einen "Kreis" handelt. Bei den heutigen Compilern kann man auch noch hoffen, dass sie die Endrekursion erkennen.. Oder es ist, wie bei der Fakultät, einer der Fälle, in denen es unbedingt rekursiv sein muss, egal ob sinnvoll oder nicht. > Da machen wir wohl mal wieder für andere Leute ihre Hausaufgabe.
Hallo, noch andere Aufgabe habe ich auch genauso ein Error 11...'\Dev-Cpp\komp.cpp too many arguments to function `COMPLEX kompadd()...' kann jemand für mich kurz erklären, wieso tritt den Fehler allgemein, also "too many arguments to function". Wie kann ich den Fehler vermeiden. danke !!!! //komplexe Zahlen #include"stdio.h" #include"conio.h" #include"stdlib.h" #include"math.h" #define sqr(x) ((x)*(x)) typedef struct komplex {float re, im;} COMPLEX; int main() { COMPLEX a,b,c; /*Fehler an dieser Zeile:11*/ COMPLEX kompadd(), kompsub(), kompmul(), kompdiv(); void ausgabe(); printf("Gib 1.Komplexe Zahl ein: "); scanf("%f %f",&a.re,&a.im); printf("Gib 2.Komplexe Zahl ein: "); scanf("%f %f",&b.re,&b.im); c = kompadd(a,b); printf("Summe: "); ausgabe(c); c = kompsub(a,b); printf("Differenz: "); ausgabe(c); c = kompmul(a,b); printf("Produkt: "); ausgabe(c); c = kompdiv(a,b); printf("Quotient: "); ausgabe(c); getch(); } COMPLEX kompadd(COMPLEX x, COMPLEX y) { COMPLEX z; z.im = x.im + y.im; z.re = x.re + y.re; return (z); } COMPLEX kompsub(COMPLEX x, COMPLEX y) { COMPLEX z; z.im = x.im - y.im; z.re = x.re - y.re; return (z); } COMPLEX kompmul(COMPLEX x, COMPLEX y) { COMPLEX z; z.im = x.im * y.re + x.re * y.im; z.re = x.re * y.re - x.im*y.im; return (z); } COMPLEX kompdiv(COMPLEX x, COMPLEX y) { COMPLEX z; z.im = x.im * y.re - x.re * y.im; z.re = (x.re * y.re + x.im * y.im)/ (sqr(y.re)+sqr(y.im)) ; return (z); } void ausgabe(COMPLEX x) { double fabs(); if(x.im>=0) printf("%f + %f*i\n",x.re,x.im); else printf("%f - %f*i\n",x.re,fabs(x.im)); }
Pep Max schrieb: > kann jemand für mich kurz erklären, wieso tritt den Fehler allgemein, > also "too many arguments to function". Weil du es als C++ übersetzt. > Wie kann ich den Fehler vermeiden. Als C übersetzen. Besser wäre allerdings, wenn du die Funktionen explizit mit Parametern deklarierst, statt mit unbestimmter Parameterliste. Das macht man eigentlich seit ANSI-C nicht mehr, auch wenn es in C erlaubt ist.
auch ist es nicht üblich funktionen in der main die Deklarieren, das mach man vor der main funktion, die meisten schreiben auch die Funktionen vor die Main dan braucht man schon meist keine deklaration mehr.
Du verwendest Funktionsprototypen zur Deklaration der Funktionen, die einerseits am falschen Ort untergebracht sind, nämlich /innerhalb einer Funktion/, und andererseits deklarierst Du die Funktionen so, daß ihnen keine Argumente übergeben werden: COMPLEX kompadd(), kompsub(), kompmul(), kompdiv(); Die Definition der Funktionen aber sieht anders aus: COMPLEX kompadd(COMPLEX x, COMPLEX y)
Rufus t. Firefly schrieb: > Du verwendest Funktionsprototypen zur Deklaration der Funktionen, die > einerseits am falschen Ort untergebracht sind, nämlich /innerhalb > einer Funktion/, Erlaubt ist das aber, wenn auch meist nicht sinnvoll. > und andererseits deklarierst Du die Funktionen so, daß > ihnen keine Argumente übergeben werden: In C++ ja. In C bedeutet die Deklaration, daß die Funktion eine an dieser Stelle unbekante Zahl von Parametern hat. Auch das ist nicht unbedingt sinnvoll, aber erlaubt. Wenn man eine Funktion deklarieren will, die keine Parameter hat, muß man die Parameterliste als (void) angeben.
Bitte melde dich an um einen Beitrag zu schreiben. Anmeldung ist kostenlos und dauert nur eine Minute.
Bestehender Account
Schon ein Account bei Google/GoogleMail? Keine Anmeldung erforderlich!
Mit Google-Account einloggen
Mit Google-Account einloggen
Noch kein Account? Hier anmelden.