Mehrere Variablen an Prozedur übergeben

Hallo ich würde gerne wissen wie man mehrere Variablen an eine Prozedur übergibt

würde gerne

//Prototyp
float rechnung float float;

int main ()
...
...
// Anwender gibt ZAHL und TOLERANZ ans
...
...
printf("Ihre %f lautet %f", ZAHL, rechnung(ZAHL, TOLERANZ));

float rechnung (float x, y)
{
...
...
...
return x
}

// Ziel wäre es 2 Werte zu übergeben aber nur einen zurück zu geben
// und in der Ausgabe dann auch nur die Variable ZAHL auszugeben.
// TOL soll nur einmal übergeben werden um damit rechnen zu können.

Jemand eine Idee wie es richtig geht?

SeppJ

float rechnung (float x, float y)

printf("Ihre %f lautet %f", ZAHL, rechnung(ZAHL, TOLERANZ));

Also brauch ich nicht zu befürchten, dass TOLERANZ ausgegeben wird oder eine Fehlermeldung kommt ?

Ich will dass ZAHL und rechnung(ZAHL) daraufhin ausgegeben werden sollenm aber TOLERANZ ist ja auch noch da also wie muss ich das angehen?

cooky451

So wie das da steht wird die Funktion "rechnung" mit zwei Argumenten aufgerufen und der Rückgabewert wird ausgegeben? Willst du ein anderes Verhalten? Wenn ja welches? Deine Frage ist ehrlich gesagt irgendwie etwas unverständlich..

Also ich gebe euch mal den kompletten Code

/* */
#include <stdio.h>

float rechnung float float;

int main ()
{
  float ZAHL, TOL;

  printf("Geben Sie die Zahl an, von der Sie die Wurzel ziehen wollen: ");
  scanf("%f", &ZAHL);

  printf ("Die Toleranz: ");
  scanf("%f",&TOL);

  printf("Die Wurzel von %f lautet %f %f", ZAHL, rechnung(ZAHL, TOL));

  return 0;
}

float rechnung (float zahl, float tol)
{
  int counter=0;
  int x[counter];

   x[counter] = zahl;
   while (tol > (x[counter]-x[counter-1]))
   {
     counter++;
     x[counter]= 0.5*(x[counter-1] + (zahl/counter-1));
   }
    return x[counter];
}

Und der Fehlercode beim Compilen

`

babylon.c:4: error: expected ‘=’, ‘,’, ‘;’, ‘asm’ or ‘attribute’ before ‘float’

babylon.c:4: error: two or more data types in declaration specifiers

babylon.c: In function ‘main’:

babylon.c:17: warning: format ‘%f’ expects type ‘double’, but argument 3 has type ‘int’

babylon.c:17: warning: too few arguments for format

babylon.c: At top level:

babylon.c:22: error: conflicting types for ‘rechnung’

babylon.c:17: note: previous implicit declaration of ‘rechnung’ was here

`

Das ganze nennt sich Babylonisches Wurzel ziehen ist ja auch egal was das Programm macht, jedenfalls ich will folgendes:

MAIN: ZAHL TOLERANZ ---zu Prozedur--> Prozedur: zahl ---zu Main--> AUSGABE von ZAHL

Ich hab grad gemekrt dass bei der main ein %f zu viel steht.

Soll ja nur ZAHL und rechnung(ZAHL) ausgegeben werden.
AM fehlercode ändert es trozdem nix

gary1195

x[y] ist vom Typ int rechnung muss aber einevariable vom typ float zurück geben siehe: float rechnung(.....)

gary1195

Dein code sieht insgesamt etwas seltsam aus.

Ja habs fast, danke für die int geschichte, die andere Sache war nur die Schreibweise meines Prototypen.

Eine Sache kriege ich jetzt noch als Fehlermeldung:

/* */
#include <stdio.h>

int rechnung (float, float);

int main ()
{
  float ZAHL, TOL;

  printf("Geben Sie die Zahl an, von der Sie die Wurzel ziehen wollen: ");
  scanf("%f", &ZAHL);

  printf ("Die Toleranz: ");
  scanf("%f",&TOL);

  printf("Die Wurzel von %f lautet %f", ZAHL, rechnung(ZAHL, TOL));

  return 0;
}

int rechnung (float zahl, float tol)
{
  int counter=0;
  int x[1000];

   x[counter] = zahl;
   while (tol > (x[counter]-x[counter-1]))
   {
     counter++;
     x[counter]= 0.5*(x[counter-1] + (zahl/counter-1));
   }
    return x[counter];
}

`

babylon.c: In function ‘main’:

babylon.c:17: warning: format ‘%f’ expects type ‘double’, but argument 3 has type ‘int’

`

Was muss da gemacht werden?

gary1195

du musst das bei printf entsprechend ändern

printf("Die Wurzel von %f lautet %d", ZAHL, rechnung(ZAHL, TOL));

int rechnung (float zahl, float tol)
{
  int counter=0;
  int x[1000];

   x[counter] = zahl;                        // Hier weist du einem int ein float zu, da verlierst du Information.
   while (tol > (x[counter]-x[counter-1]))   // Hier greifst du im ersten Durchgang auf x[-1] zu. FEHLER!
   {
     counter++;
     x[counter]= 0.5*(x[counter-1] + (zahl/counter-1));
   }
    return x[counter];
}

Was passiert wenn die Toleranz erst nach 1001 Schritten unterschritten wird?
Wozu brauchst du überhaupt das Array?