"to many argument to function"

[Pep M. (picpoc)]

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();
}

[Bob (Gast)]

Der Prototyp:
    long int  ulam()
muss aus der main() raus, und muss die Typen der Parameter deklarieren.

[hp-freund (Gast)]

@ Bob
ist nicht drin, sieht nur so aus :)

Zweimal Semikolon an der richtigen Stelle sollte auch etwas bringen...

[Peter (Gast)]

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.

[g457 (Gast)]

> 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):

include"stdio.h"
//#include"conio.h"
//#include"stdlib.h"

long int ulam(long int x)
{
   if (x <= 1)
      return 1;
   else {
      printf("%ld\n", x);
      return (x%2)
         ? ulam(3 *x +1)
         : ulam(x/2);
   }
}


int main()
{
    long int x;
    long int  ulam();
    printf("Geben ein ganze Zahl:   ");
    scanf("%ld",&x);
    printf("%ld\n", ulam(x));

    return 0;
}

..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

[Peter (Gast)]

g457 schrieb:
> long int  ulam();

und wozu soll das gut sein?

[g457 (Gast)]

> und wozu soll das gut sein?

Zum auskommentieren. Hier die korrigierte Version für Pedanten:

// long int  ulam();

HTH und nix für ungut.

[Karl H. (kbuchegg)]

g457 schrieb:

> (Syntax)Fehler.. ich war mal so frei den Code zu bereinigen (und etwas
> aufzuhypschen):
>
>

> long int ulam(long int x)
> {
>    if (x <= 1)
>       return 1;
>    else {
>       printf("%ld\n", x);
>       return (x%2)
>          ? ulam(3 *x +1)
>          : ulam(x/2);
>    }
> }
>

Ist mir ehrlich gesagt immer noch zu kryptisch.

Ich würds so schreiben

long int ulam(long int x)
{
  if (x <= 1)
    return 1;

  printf("%ld\n", x);

  if (x%2 != 0)
    return ulam(3 *x +1);

  return ulam(x/2);
}

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.

[Läubi .. (laeubi)]

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:

long int ulam(long int x) {
  while(x > 1) {
    printf("%ld\n", x);
    if (x % 2 != 0) {
      x = 3 * x + 1;
    } else {
      x = x / 2;
    }
  }
  return 1;
}

 (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

[Arc N. (arc)]

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:
>

long int ulam(long int x) {
>   while(x > 1) {
>     printf("%ld\n", x);
>     if (x % 2 != 0) {
>       x = 3 * x + 1;
>     } else {
>       x = x / 2;
>     }
>   }
>   return 1;
> }

 (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 .. (laeubi)]

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.

[Arc N. (arc)]

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.

[Pep Max (Gast)]

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));
    }

[Rolf Magnus (Gast)]

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.

[Peter (Gast)]

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.

[Rufus Τ. F. (rufus)]

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)

[Rolf Magnus (Gast)]

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.