4. HILFE! WICHTIG! VIELEN DANK! Datentypen , printf

HILFE! WICHTIG! VIELEN DANK! Datentypen , printf

  • J

    Hallo!
    Hab nen mega Problem, und muß den kram heut noch fertig bekommen:

    printf ("Moegliche Kombination:\n");
printf ("R1 : %s Ohm\n", value_as_text (e12[i], mult));
printf ("R2 : %s Ohm\n", value_as_text (e12[j], mult));
printf ("R3 : %s Ohm\n", value_as_text (e12[k], mult));
printf ("Gesamtwiderstand      : %s Ohm\n", value_as_text (rges_ergebnis, mult));

printf ("Gewuenscht  wurden    : %.2f Ohm\n", x);
double abweichung = rges_ergebnis - x ;				   
printf ("Abweichung in Ohm     :  %.2f Ohm\n", abweichung);

    also ich habe die werte "rges_ergebnis" und "x".
    Ich benötige nun die Differenz der beiden. Jedoch funtzt das nicht, ich probier nun schon stunden herum.

    Liegt das an den unterschiedlichen Datentypen? (double x)

    VIELEN DANK für schnelle HILFE!!!!

    0
  • Z

    was hat den rges_ergebnis für einen Datentyp?

    0
  • J

    DANKE für die schnelle Antwort:

    "double rges_ergebnis;"

    0
  • J

    hier mal der gesamte quellcode....wär super wenn da jemand was machen kann...ich weiß nicht mehr weiter...

    #include <stdio.h>
#include <math.h>
#include <float.h>

double rges_rechnen (double r1, double r2, double r3);            	
char *value_as_text (double value, double mult);
void ignore();
void durchtest (double r, double mult, double e12[], double x);

/***********************************************************************
* Name: main
* Zweck: 
* Prototy: int main();
* Parameter: keine
* Funktionswert: 0
***********************************************************************/  

int main()
{
   char menue;
   int eingfehler;
   double e12[] = {DBL_MIN, 1.0, 1.2, 1.5, 1.8, 2.2, 2.7, 3.3, 3.9, 4.7, 5.6,
                   6.8, 8.2, DBL_MAX};
   double x, mult, norm; 

   do
   {	
       x = 1;
       eingfehler = 0;

	   printf("\nWiderstandsberechnung\n\n");
	   printf("Schaltungsskizze - Nicht normgerecht :\n");

	   printf("o----[R1]-----o\n");
	   printf("|             |\n");
	   printf("|             |\n");
	   printf("o--[R2]-[R3]--o\n\n"); 

	   printf("E12-Reihe : 1.0 1.2 1.5 1.8 2.2 2.7 3.3 3.9 " 
	          "4.7 5.6 6.8 8.2 Ohm\n\n");
	   printf("Dieses Programm wird Ihnen fuer einen gewuenschten" 
	          "Gesamtwiderstand\ndie moeglichen Widerstandskombinationen,"
	          " bei verwenden von Widerstaenden der\nE12er-Reihe, "
	          "auflisten.\n\n");	
       do 
	   {	 
          printf("Bitte den Wert eingeben :\n");
	      eingfehler = scanf("%lf", &x); /*Eingabe des Wertes für "x"*/

	      if (eingfehler != 1)		/*Eingabefehler: Buchstabe eingegeben*/
          {
             printf("\nEingabe darf kein Buchstabe sein...\n");
		     x = 1;
	      }		
	      if (x < 0)		/*Eingabefehler: Eingegebener Wert ist negativ*/
          {
		     printf("\nEingabe darf nicht negativ sein...\n");
		     eingfehler = 0;	
          } 	  
	      ignore();  /*Eingabepuffer wird geleert*/

       } while(eingfehler != 1);

       mult = pow(10,floor(log10(x))); 
	   /*pow(x,y) --> x^y
         log10(x)liefert den Zehnerlogarithmus von x,
	     floor(x)rundet auf ganze Zahl ab.
         Wird dann 10 mit dieser beschnittenen Zahl potenziert,
	     hat man nicht x wieder zurueck, sondern die Zehnerpotenz des Bereiches
	     in dem sich x befindet.*/

       norm = x/mult;

       durchtest (norm, mult, e12, x);   /*Funktionsaufruf von 'durchtest'*/

       printf("\n\nProgramm neustarten, (j)a oder (n)ein ?\n"); /*Neustart?*/
       scanf("%c",&menue);
       getchar();

       if (menue == 'n' )
       {
          printf("\n\nAuf Wiedersehen !");
          getchar();
       }
       else
          menue = menue;

       printf ("Menue : %c \n", menue);

   } while (menue == 'j' );

   return 0;
}

char *value_as_text (double value, double mult)
{
    static char txt[256];                 /*speicher fuer sprintf reservieren*/  
    if (value == DBL_MAX)                 /*wenn der wert riesengross ist...*/
        return "Weglassen / Unendlich";   /*'weglassen' zurueckgeben 
	                                      und funktion verlassen*/
    if (value <= DBL_MIN)                 /*wenn der wert total klein ist...*/ 	
        return "Drahtbruecke / 0";        /*'drahtbruecke' zurueckgeben 
	                                      und funktion verlassen*/
    sprintf (txt, "%1.1lf", mult*value);  /*Ausgabe wird in den 
                                          Zeichenvektor s geschrieben*/
    return txt;                           /*txt zurueckgeben und       
                                          funktion verlassen */    
}

void ignore() /*Leert den Eingabepuffer*/
{
    int c;
    while ((c=getchar()) != '\n' && c != EOF); 
}

void durchtest (double r, double mult, double e12[], double x) /*Probiert Moeglichkeiten durch*/
{
   int i, j, k;
   double diff = DBL_MAX;
   double rges_ergebnis;
    for (i=0; i<14; i++) 
      for (j=0; j<14; j++)
         for (k=0; k<14; k++)
         {
            rges_ergebnis = rges_rechnen (e12[i], e12[j], e12[k]);
            if (fabs(rges_ergebnis - r) < diff)
            {
               diff = fabs(rges_ergebnis - r); /*fabs(x) -->absoluter Wert,
                                               Betrag X liefert den Absolutwert 
                                               einer Gleitkommazahl neg. 
                                               wird pos.*/					  
			   printf ("Moegliche Kombination:\n");
               printf ("R1 : %s Ohm\n", value_as_text (e12[i], mult));
               printf ("R2 : %s Ohm\n", value_as_text (e12[j], mult));
               printf ("R3 : %s Ohm\n", value_as_text (e12[k], mult));
     	       printf ("Gesamtwiderstand      : %s Ohm\n", value_as_text(rges_ergebnis, mult));
			   printf ("Gewuenscht  wurden    : %.2f Ohm\n", x);
			   double abweichung = rges_ergebnis-x;				   
			   printf ("Abweichung in Ohm     :  %s Ohm\n", abweichung);

			}
         }   
}

/***********************************************************************
* Name: rges_rechnen            
* Zweck: 
* Prototyp: double rges_rechnen (double r1, double r2, double r3);
* Parameter: r1: (E)  Gewählter Wert aus der E12er Reihe für R1 oder so
*            r2: (E)  auch sowas
*            r3: (E)  ein heiterer Wert :)
* Funktionswert: keiner
***********************************************************************/				
double rges_rechnen (double r1, double r2, double r3) /*Rges Errechnen */
{
    return (r1+r2)*r3/(r1+r2+r3);
}
    0
  • Z

    Und was genau bekommst du für eine Fehlermeldung?
    Kannst du vielleicht ein wenig mehr vom Code zeigen?

    Also von den Datentypen sollte das kein Problem sein, weil beides vom Typ double ist...

    Dann ist es eher die Deklaration double abweichung = rges_ergebnis - x ; die mitten im Programm steht...
    versuch mal zu beginn des Programms double abweichung = 0;
    und dann im programm selber abweichung = rges_ergebnis - x ;

    Lg, David

    0
  • Z

    ja, so gehts..

    Habs soeben ausprobiert..

    0
  • J

    ui, bei mir wills net, magst du es kurz reinsttellen? DANKE!!

    0
  • Z
     

    #include <stdio.h> 
#include <math.h> 
#include <float.h> 

double rges_rechnen (double r1, double r2, double r3);                
char *value_as_text (double value, double mult); 
void ignore(); 
void durchtest (double r, double mult, double e12[], double x); 

/*********************************************************************** 
* Name: main 
* Zweck: 
* Prototy: int main(); 
* Parameter: keine 
* Funktionswert: 0 
***********************************************************************/   

int main() 
{ 
   char menue; 
   int eingfehler; 
   double e12[] = {DBL_MIN, 1.0, 1.2, 1.5, 1.8, 2.2, 2.7, 3.3, 3.9, 4.7, 5.6, 
                   6.8, 8.2, DBL_MAX}; 
   double x, mult, norm; 

   do 
   {    
       x = 1; 
       eingfehler = 0; 

       printf("\nWiderstandsberechnung\n\n"); 
       printf("Schaltungsskizze - Nicht normgerecht :\n"); 

       printf("o----[R1]-----o\n"); 
       printf("|             |\n"); 
       printf("|             |\n"); 
       printf("o--[R2]-[R3]--o\n\n"); 

       printf("E12-Reihe : 1.0 1.2 1.5 1.8 2.2 2.7 3.3 3.9 " 
              "4.7 5.6 6.8 8.2 Ohm\n\n"); 
       printf("Dieses Programm wird Ihnen fuer einen gewuenschten" 
              "Gesamtwiderstand\ndie moeglichen Widerstandskombinationen," 
              " bei verwenden von Widerstaenden der\nE12er-Reihe, " 
              "auflisten.\n\n");    
       do 
       {      
          printf("Bitte den Wert eingeben :\n"); 
          eingfehler = scanf("%lf", &x); /*Eingabe des Wertes für "x"*/ 

          if (eingfehler != 1)        /*Eingabefehler: Buchstabe eingegeben*/ 
          { 
             printf("\nEingabe darf kein Buchstabe sein...\n"); 
             x = 1; 
          }        
          if (x < 0)        /*Eingabefehler: Eingegebener Wert ist negativ*/ 
          { 
             printf("\nEingabe darf nicht negativ sein...\n"); 
             eingfehler = 0;    
          }       
          ignore();  /*Eingabepuffer wird geleert*/ 

       } while(eingfehler != 1); 

       mult = pow(10,floor(log10(x))); 
       /*pow(x,y) --> x^y 
         log10(x)liefert den Zehnerlogarithmus von x, 
         floor(x)rundet auf ganze Zahl ab. 
         Wird dann 10 mit dieser beschnittenen Zahl potenziert, 
         hat man nicht x wieder zurueck, sondern die Zehnerpotenz des Bereiches 
         in dem sich x befindet.*/ 

       norm = x/mult; 

       durchtest (norm, mult, e12, x);   /*Funktionsaufruf von 'durchtest'*/ 

       printf("\n\nProgramm neustarten, (j)a oder (n)ein ?\n"); /*Neustart?*/ 
       scanf("%c",&menue); 
       getchar(); 

       if (menue == 'n' ) 
       { 
          printf("\n\nAuf Wiedersehen !"); 
          getchar(); 
       } 
       else 
          menue = menue; 

       printf ("Menue : %c \n", menue); 

   } while (menue == 'j' ); 

   return 0; 
} 

char *value_as_text (double value, double mult) 
{ 
    static char txt[256];                 /*speicher fuer sprintf reservieren*/   
    if (value == DBL_MAX)                 /*wenn der wert riesengross ist...*/ 
        return "Weglassen / Unendlich";   /*'weglassen' zurueckgeben 
                                          und funktion verlassen*/ 
    if (value <= DBL_MIN)                 /*wenn der wert total klein ist...*/     
        return "Drahtbruecke / 0";        /*'drahtbruecke' zurueckgeben 
                                          und funktion verlassen*/ 
    sprintf (txt, "%1.1lf", mult*value);  /*Ausgabe wird in den 
                                          Zeichenvektor s geschrieben*/ 
    return txt;                           /*txt zurueckgeben und       
                                          funktion verlassen */     
} 

void ignore() /*Leert den Eingabepuffer*/ 
{ 
    int c; 
    while ((c=getchar()) != '\n' && c != EOF); 
} 

void durchtest (double r, double mult, double e12[], double x) /*Probiert Moeglichkeiten durch*/ 
{ 
   int i, j, k; 
   double diff = DBL_MAX; 
   double rges_ergebnis; 
   double abweichung = 0;
    for (i=0; i<14; i++) 
      for (j=0; j<14; j++) 
         for (k=0; k<14; k++) 
         { 
            rges_ergebnis = rges_rechnen (e12[i], e12[j], e12[k]); 
            if (fabs(rges_ergebnis - r) < diff) 
            { 
               diff = fabs(rges_ergebnis - r); /*fabs(x) -->absoluter Wert, 
                                               Betrag X liefert den Absolutwert 
                                               einer Gleitkommazahl neg. 
                                               wird pos.*/                      
               printf ("Moegliche Kombination:\n"); 
               printf ("R1 : %s Ohm\n", value_as_text (e12[i], mult)); 
               printf ("R2 : %s Ohm\n", value_as_text (e12[j], mult)); 
               printf ("R3 : %s Ohm\n", value_as_text (e12[k], mult)); 
                printf ("Gesamtwiderstand      : %s Ohm\n", value_as_text(rges_ergebnis, mult)); 
               printf ("Gewuenscht  wurden    : %.2f Ohm\n", x); 
               abweichung = rges_ergebnis-x;                    
               printf ("Abweichung in Ohm     :  %s Ohm\n", abweichung); 

            } 
         }   
} 

/*********************************************************************** 
* Name: rges_rechnen             
* Zweck: 
* Prototyp: double rges_rechnen (double r1, double r2, double r3); 
* Parameter: r1: (E)  Gewählter Wert aus der E12er Reihe für R1 oder so 
*            r2: (E)  auch sowas 
*            r3: (E)  ein heiterer Wert :) 
* Funktionswert: keiner 
***********************************************************************/                
double rges_rechnen (double r1, double r2, double r3) /*Rges Errechnen */ 
{ 
    return (r1+r2)*r3/(r1+r2+r3); 
}
    0
  • J

    Mensch das gibts doch nicht, ich hab da immer falsche Werte...
    Hier nochmal eine unverpfuschte version...hab da jetzt nur die 2 zeilen reingesetzt:

    Wenn man zb mit 7 ohm testet, stimmt das ergebnis, mit 500 jedoch nicht.

    Wäre super wenn Du/Ihr da nochmal schauen könntet!

    THX!

    #include <stdio.h>
#include <math.h>
#include <float.h>

double rges_rechnen (double r1, double r2, double r3);            	
char *value_as_text (double value, double mult);
void ignore();
void durchtest (double r, double mult, double e12[], double x);

/***********************************************************************
* Name: main
* Zweck: 
* Prototy: int main();
* Parameter: keine
* Funktionswert: 0
***********************************************************************/  

int main()
{
   char menue;
   int eingfehler;
   double e12[] = {DBL_MIN, 1.0, 1.2, 1.5, 1.8, 2.2, 2.7, 3.3, 3.9, 4.7, 5.6,
                   6.8, 8.2, DBL_MAX};
   double x, mult, norm; 

   do
   {	
       x = 1;
       eingfehler = 0;

	   printf("\nWiderstandsberechnung\n\n");
	   printf("Schaltungsskizze - Nicht normgerecht :\n");

	   printf("o----[R1]-----o\n");
	   printf("|             |\n");
	   printf("|             |\n");
	   printf("o--[R2]-[R3]--o\n\n"); 

	   printf("E12-Reihe : 1.0 1.2 1.5 1.8 2.2 2.7 3.3 3.9 " 
	          "4.7 5.6 6.8 8.2 Ohm\n\n");
	   printf("Dieses Programm wird Ihnen fuer einen gewuenschten" 
	          "Gesamtwiderstand\ndie moeglichen Widerstandskombinationen,"
	          " bei verwenden von Widerstaenden der\nE12er-Reihe, "
	          "auflisten.\n\n");	
       do 
	   {	 
          printf("Bitte den Wert eingeben :\n");
	      eingfehler = scanf("%lf", &x); /*Eingabe des Wertes für "x"*/

	      if (eingfehler != 1)		/*Eingabefehler: Buchstabe eingegeben*/
          {
             printf("\nEingabe darf kein Buchstabe sein...\n");
		     x = 1;
	      }		
	      if (x < 0)		/*Eingabefehler: Eingegebener Wert ist negativ*/
          {
		     printf("\nEingabe darf nicht negativ sein...\n");
		     eingfehler = 0;	
          } 	  
	      ignore();  /*Eingabepuffer wird geleert*/

       } while(eingfehler != 1);

       mult = pow(10,floor(log10(x))); 
	   /*pow(x,y) --> x^y
         log10(x)liefert den Zehnerlogarithmus von x,
	     floor(x)rundet auf ganze Zahl ab.
         Wird dann 10 mit dieser beschnittenen Zahl potenziert,
	     hat man nicht x wieder zurueck, sondern die Zehnerpotenz des Bereiches
	     in dem sich x befindet.*/

       norm = x/mult;

       durchtest (norm, mult, e12, x);   /*Funktionsaufruf von 'durchtest'*/

       printf ("Von Ihnen gewuenscht waren: %.3lf Ohm\n", x);

       printf("\n\nProgramm neustarten, (j)a oder (n)ein ?\n"); /*Neustart?*/
       scanf("%c",&menue);
       getchar();

       if (menue == 'n' )
       {
          printf("\n\nAuf Wiedersehen !");
          getchar();
       }
       else
          menue = menue;

       printf ("Menue : %c \n", menue);

   } while (menue == 'j' );

   return 0;
}

char *value_as_text (double value, double mult)
{
    static char txt[256];                 /*speicher fuer sprintf reservieren*/  
    if (value == DBL_MAX)                 /*wenn der wert riesengross ist...*/
        return "Weglassen / Unendlich";   /*'weglassen' zurueckgeben 
	                                      und funktion verlassen*/
    if (value <= DBL_MIN)                 /*wenn der wert total klein ist...*/ 	
        return "Drahtbruecke / 0";        /*'drahtbruecke' zurueckgeben 
	                                      und funktion verlassen*/
    sprintf (txt, "%1.1lf", mult*value);  /*Ausgabe wird in den 
                                          Zeichenvektor s geschrieben*/
    return txt;                           /*txt zurueckgeben und       
                                          funktion verlassen */    
}

void ignore() /*Leert den Eingabepuffer*/
{
    int c;
    while ((c=getchar()) != '\n' && c != EOF); 
}

void durchtest (double r, double mult, double e12[], double x) /*Probiert Möglichkeiten durch*/
{
   int i, j, k;
   double diff = DBL_MAX;
   double rges_ergebnis;
   double abweichung = 0;
   for (i=0; i<14; i++) 
      for (j=0; j<14; j++)
         for (k=0; k<14; k++)
         {
            rges_ergebnis = rges_rechnen (e12[i], e12[j], e12[k]);
            if (fabs(rges_ergebnis - r) < diff)
            {
               diff = fabs(rges_ergebnis - r); /*fabs(x) -->absoluter Wert,
                                               Betrag X liefert den Absolutwert 
                                               einer Gleitkommazahl neg. 
                                               wird pos.*/					  
			   printf ("Moegliche Kombination:\n");
               printf ("R1 : %s Ohm\n", value_as_text (e12[i], mult));
               printf ("R2 : %s Ohm\n", value_as_text (e12[j], mult));
               printf ("R3 : %s Ohm\n", value_as_text (e12[k], mult));
     	       printf ("Gesamtwiderstand : %s Ohm\n", 
                       value_as_text (rges_ergebnis, mult));
			   abweichung = rges_ergebnis - x ;
		       printf ("(Differenz:%lf)\n\n", abweichung);
			}
         }   
}

/***********************************************************************
* Name: rges_rechnen            
* Zweck: 
* Prototyp: double rges_rechnen (double r1, double r2, double r3);
* Parameter: r1: (E)  Gewählter Wert aus der E12er Reihe für R1 oder so
*            r2: (E)  auch sowas
*            r3: (E)  ein heiterer Wert :)
* Funktionswert: keiner
***********************************************************************/				
double rges_rechnen (double r1, double r2, double r3) /*Rges Errechnen */
{
    return (r1+r2)*r3/(r1+r2+r3);
}
    0
  • Z

    Hallo Joker...

    Ich befürchte, dass dir ein wenig die Theorie dahinter fehlt...

    Dein Programm funktioniert nicht, weil du bei beim Ausgeben der Abweichung folgende Zeile programmiert hast:

    printf ("Abweichung in Ohm     :  %s Ohm\n", abweichung);

    und nachher dann

    printf ("(Differenz:%lf)\n\n", abweichung);

    Ausgehend vom Datentyp musst du bei printf folgende Zeichen verwenden:
    - int: %d
    - double: %f
    - char: %s

    Ausgehend vom Datentyp musst du bei scanf folgende Zeichen verwenden:
    - int: %d
    - double: %lf
    - char: %s

    d.h. du hast einmal das Einlesen für scanf verwendet und einmal die Eingabe von char...

    Verwende stattdessen %f und das Programm funktioniert..

    Lg, David

    0
  • J

    VIELEN Dank David,

    ich hab das nun so geändert, das %s gegen %f, leider immer noch falsche Werte bei 500 ohm eingabe.

    Mir fehlt tatsächlich die Theorie, vor allem aber auch die übung 😞

    So schauts aus:

    #include <stdio.h>
#include <math.h>
#include <float.h>

double rges_rechnen (double r1, double r2, double r3);                
char *value_as_text (double value, double mult);
void ignore();
void durchtest (double r, double mult, double e12[], double x);

/***********************************************************************
* Name: main
* Zweck:
* Prototy: int main();
* Parameter: keine
* Funktionswert: 0
***********************************************************************/  

int main()
{
   char menue;
   int eingfehler;
   double e12[] = {DBL_MIN, 1.0, 1.2, 1.5, 1.8, 2.2, 2.7, 3.3, 3.9, 4.7, 5.6,
                   6.8, 8.2, DBL_MAX};
   double x, mult, norm;

   do
   {    
       x = 1;
       eingfehler = 0;

       printf("\nWiderstandsberechnung\n\n");
       printf("Schaltungsskizze - Nicht normgerecht :\n");

       printf("o----[R1]-----o\n");
       printf("|             |\n");
       printf("|             |\n");
       printf("o--[R2]-[R3]--o\n\n");

       printf("E12-Reihe : 1.0 1.2 1.5 1.8 2.2 2.7 3.3 3.9 "
              "4.7 5.6 6.8 8.2 Ohm\n\n");
       printf("Dieses Programm wird Ihnen fuer einen gewuenschten"
              "Gesamtwiderstand\ndie moeglichen Widerstandskombinationen,"
              " bei verwenden von Widerstaenden der\nE12er-Reihe, "
              "auflisten.\n\n");    
       do
       {      
          printf("Bitte den Wert eingeben :\n");
          eingfehler = scanf("%lf", &x); /*Eingabe des Wertes für "x"*/

          if (eingfehler != 1)        /*Eingabefehler: Buchstabe eingegeben*/
          {
             printf("\nEingabe darf kein Buchstabe sein...\n");
             x = 1;
          }        
          if (x < 0)        /*Eingabefehler: Eingegebener Wert ist negativ*/
          {
             printf("\nEingabe darf nicht negativ sein...\n");
             eingfehler = 0;    
          }      
          ignore();  /*Eingabepuffer wird geleert*/

       } while(eingfehler != 1);

       mult = pow(10,floor(log10(x)));
       /*pow(x,y) --> x^y
         log10(x)liefert den Zehnerlogarithmus von x,
         floor(x)rundet auf ganze Zahl ab.
         Wird dann 10 mit dieser beschnittenen Zahl potenziert,
         hat man nicht x wieder zurueck, sondern die Zehnerpotenz des Bereiches
         in dem sich x befindet.*/

       norm = x/mult;

       durchtest (norm, mult, e12, x);   /*Funktionsaufruf von 'durchtest'*/

       printf("\n\nProgramm neustarten, (j)a oder (n)ein ?\n"); /*Neustart?*/
       scanf("%c",&menue);
       getchar();

       if (menue == 'n' )
       {
          printf("\n\nAuf Wiedersehen !");
          getchar();
       }
       else
          menue = menue;

       printf ("Menue : %c \n", menue);

   } while (menue == 'j' );

   return 0;
}

char *value_as_text (double value, double mult)
{
    static char txt[256];                 /*speicher fuer sprintf reservieren*/  
    if (value == DBL_MAX)                 /*wenn der wert riesengross ist...*/
        return "Weglassen / Unendlich";   /*'weglassen' zurueckgeben
                                          und funktion verlassen*/
    if (value <= DBL_MIN)                 /*wenn der wert total klein ist...*/    
        return "Drahtbruecke / 0";        /*'drahtbruecke' zurueckgeben
                                          und funktion verlassen*/
    sprintf (txt, "%1.1lf", mult*value);  /*Ausgabe wird in den
                                          Zeichenvektor s geschrieben*/
    return txt;                           /*txt zurueckgeben und      
                                          funktion verlassen */    
}

void ignore() /*Leert den Eingabepuffer*/
{
    int c;
    while ((c=getchar()) != '\n' && c != EOF);
}

void durchtest (double r, double mult, double e12[], double x) /*Probiert Moeglichkeiten durch*/
{
   int i, j, k;
   double diff = DBL_MAX;
   double rges_ergebnis;
   double abweichung = 0;
    for (i=0; i<14; i++)
      for (j=0; j<14; j++)
         for (k=0; k<14; k++)
         {
            rges_ergebnis = rges_rechnen (e12[i], e12[j], e12[k]);
            if (fabs(rges_ergebnis - r) < diff)
            {
               diff = fabs(rges_ergebnis - r); /*fabs(x) -->absoluter Wert,
                                               Betrag X liefert den Absolutwert
                                               einer Gleitkommazahl neg.
                                               wird pos.*/                      
               printf ("Moegliche Kombination:\n");
               printf ("R1 : %s Ohm\n", value_as_text (e12[i], mult));
               printf ("R2 : %s Ohm\n", value_as_text (e12[j], mult));
               printf ("R3 : %s Ohm\n", value_as_text (e12[k], mult));
                printf ("Gesamtwiderstand      : %s Ohm\n", value_as_text(rges_ergebnis, mult));
               printf ("Gewuenscht  wurden    : %.2f Ohm\n", x);
               abweichung = rges_ergebnis-x;                    
               printf ("Abweichung in Ohm     :  %f Ohm\n", abweichung);

            }
         }  
}

/***********************************************************************
* Name: rges_rechnen            
* Zweck:
* Prototyp: double rges_rechnen (double r1, double r2, double r3);
* Parameter: r1: (E)  Gewählter Wert aus der E12er Reihe für R1 oder so
*            r2: (E)  auch sowas
*            r3: (E)  ein heiterer Wert :)
* Funktionswert: keiner
***********************************************************************/                
double rges_rechnen (double r1, double r2, double r3) /*Rges Errechnen */
{
    return (r1+r2)*r3/(r1+r2+r3);
}
    0
  • Z

    Hallo Joker,

    Kein Problem... Zumindest läuft das Programm jetzt mal
    Leider hab ich jetzt keine Zeit mir den Rest anzuschauen, aber ich denke, wenn einzelne Werte nicht stimmen, dass es dann mit der Rechnung was auf sich haben wird.

    Da hast du recht.. die Übung ist verdammt wichtig beim Programmieren. Also übe soviel du kannst, dann wird das schon...

    Viel Glück noch,
    Lg, David

    0
  • J

    Danke David!

    Gutn8 🙂

    0
  • T

    du lieber himmel!
    was hab' ich da nur angerichtet...
    :xmas2:

    0
Anmelden zum Antworten