Ich programmiere jetzt seit 1 Woche in c++ und habe irgendwelche sachen gesucht die ich mit meinen bescheidenen Programmierkenntnissen im Moment schon machen kann. Also kam ich auf die Idee den dritten Schnittpunkt der beiden Funktionen x^2 und 2^x so genau wie möglich zu bestimmen. Ich bin dann auf folgendes Programm gekommen:

#include<iostream>
#include<conio.h>
using namespace std;

double Funktionen(double);
double Funktion1 (double);
double Funktion2 (double);

int main ()
{
    double x=0;
    double dy1,dy2;
    double z=1;

    anfang:
    dy1=Funktionen(x);                              
    x=x+z;
    dy2=Funktionen(x);

    if ((dy1=0) || (dy2=0))                         //Wenn eine Differenz null wäre würden ja beide Graphen den
    {                                               //gleichen Punkt haben und den versuche ich ja herauszufinden.Dieser Absatz ist aber noch nicht fertig...
         cout<<"x="<<x<<"     y="<<y2;
         goto ende;
    }

    if (dy2<dy1)                                    //Wenn die zweite Differenz kleiner ist wäre ich ich dem
    {                                               //Schnittpunkt schonmal näher gekommen.
        double y1,y2;
        y1=Funktion1(x);
        y2=Funktion2(x);
        if (y1<y2)                                  //Ich gebe den kleinere y-Wert aus, damit man die Annäherung
        {                                           //an den Schnittpunkt im laufenden Programm besser sehen kann.
             cout<<"x="<<x<<"     y="<<y1;          
        }
        if (y1>y2)
        {
             cout<<"x="<<x<<"     y="<<y2;
        }
        goto anfang;
    }

    if (dy1<=dy2)                                    //Wenn die zweite Differenz größer oder gleich ist wäre ich dem
    {                                                //Schnittpunkt nicht näher gekommen, darum keine Ausgabe.
        x=x-z;                                       
        z=z/(-2);                                       
        goto anfang;
    }

ende:
cout<<"x="<<x<<"     y="<<y2;    
getch();    
}    

double Funktionen(double x)
{
        double y1=Funktion1(x);

        double y2=Funktion2(x);                      

        double dy;                       //In diesem Absatz wird der Abstand zwischen den beiden y-Werten bestimmt
            dy=y1-y2;
            dy=dy*dy;                    //Hier wird die Differenz hoch 2 genommen um einen positiven Wert zu finden

        return dy;                       
}

double Funktion1(double x)               //Die Funktion 2^x wird berechnet
{
        double y1=1;                      
        for(int i=0;i<x;++i)          
        {
            y1=y1*2;
        }
        return y1;
}

double Funktion2(double x)               //Die Funktion x^2 wird berechnet
{
       double y2;
       y2=x*x;
       return y2;
}

Mein Problem ist, dass das Programm keine Ausgabe erzeugt. Durch ausprobieren habe ich herausgefunden, dass es immer denkt die beiden Differenzenquadrate(ka ob es das Wort gibt) wären gleich. Ich habe sogar einmal den Differenzquadraten bestimmte Werte zugewiesen:

statt:

dy1=Funktionen(x);                              
x=x+z;
dy2=Funktionen(x);

habe ich das gesetzt:

dy1=2;
dy1=1;

es funktioniert trotzdem nicht. Der Computer glaubt immer noch das beide Zahlen gleich sind. Liegt es daran, dass beide double-Werte sind. Und wenn ja gibt es einen anderen Kommzahl Typ mit dem das funktionieren würde?

if ((dy1=0) || (dy2=0))

du weist schon was "dy1 = 0" bewirkt??

dy1 wird mit 0 belegt, und da da eigendlich nichts schiefgehen kann ist die bedingung wahr

da c++ lazy evaluation kennt (also es reicht wenn ein ausdruck true ergit bei einem oder in if, dann wird der zweite gar nicht erst geprüft) bleibt dy2 auf dem init wert

aber dy1 ist 0

versuchs mal mit

if ( (dy1 == 0) || (dy2 == 0) )

B1@d3 schrieb:

if ((dy1=0) || (dy2=0))

du weist schon was "dy1 = 0" bewirkt??

dy1 wird mit 0 belegt, und da da eigendlich nichts schiefgehen kann ist die bedingung wahr

Die Bedingung ist nicht wahr. Der Ausdruck dy1 = 0 weist 0 an dy1 zu und gibt danach 0 zurück. 0 wird im bool-Kontext als false interpretiert, also hat (dy1=0) den Wert false. Der zweite Ausdruck (dy2=0) wird also doch ausgewertet, ergibt aber ebenfalls false, sodass in jedem Fall in den else-Zweig gesprungen wird.

Skym0sh0 schrieb:

da c++ lazy evaluation kennt (also es reicht wenn ein ausdruck true ergit bei einem oder in if, dann wird der zweite gar nicht erst geprüft) bleibt dy2 auf dem init wert

Normalerweise nennt man das eher short ciruiting, lazy evaluation ist was anderes. Lazy evaluation bedeutet eher, dass eine Anweisung oder ein Funktionsaufruf oder ähnliches nicht ausgeführt wird, wenn er hingeschrieben wird, sondern erst dann, wenn das Ergebnis benötigt wird. Das bietet C++ nicht.

Musste auch für 2^x eine neue Funktion nehmen, weil meine Funktion nur funktionierte wenn x eine ganze positive Zahl war...

hab es dann mit pow(2,x) gemacht. Hier mein Endquellcode:

#include<iostream>
#include<conio.h>
#include <cmath> 
#include <iomanip>
using namespace std;

double Differenz(double);

int main ()
{
    double x=0;
    double dy1,dy2;
    double z=1;

    anfang:
    dy1=Differenz(x);                              
    x=x+z;
    dy2=Differenz(x);
    if ((dy1==0) || (dy2==0))                       //Wenn eine Differenz null wäre würden ja beide Graphen den
    {                                               //gleichen Punkt haben und den versuche ich ja herauszufinden.                        
       goto ende;
    }

    if (dy2<dy1)                                    //Wenn die zweite Differenz kleiner ist wäre ich ich dem
    {                                               //Schnittpunkt schonmal näher gekommen.
        double y1 = pow(2, x);
        double y2 = pow(x, 2);
        getch();
        if (y1<y2)                                  //Ich gebe den kleinere y-Wert aus, damit man die Annäherung
        {                                           //an den Schnittpunkt im laufenden Programm besser sehen kann.
             cout<<"x="<<setprecision(20)<<setw(24)<<x<<"     y="<<setprecision(20)<<setw(24)<<y1<<"\n";          
        }
        if (y1>y2)
        {
             cout<<"x="<<setprecision(20)<<setw(24)<<x<<"     y="<<setprecision(20)<<setw(24)<<y2<<"\n";
        }
        goto anfang;
    }

    if (dy1<=dy2)                                    //Wenn die zweite Differenz größer oder gleich ist wäre ich dem
    {                                                //Schnittpunkt nicht näher gekommen, darum keine Ausgabe.
        x=x-z;                                       
        z=z/(-2);                                       
        goto anfang;
    }
ende:
cout<<"x="<<setprecision(20)<<setw(10)<<x<<"     y="<<setprecision(20)<<setw(24)<<pow(x,2)<<"\n";  
getch();    
}    

double Differenz(double x)
{
        double y1=pow(2, x);             //Hier wird die Funktion 2^x berechnet

        double y2=pow(x, 2);             //Hier wird die Funktion x^2 berechnet         

        double dy;                       //In diesem Absatz wird der Abstand zwischen den beiden y-Werten bestimmt
            dy=y1-y2;
            dy=dy*dy;                    //Hier wird die Differenz hoch 2 genommen um einen positiven Wert zu finden

        return dy;                       
}                       
}

Um einiges kürzer als der vorher^^

x= leerleerleerleerleerle-0.x (statt leer leerzeichen)
x= leerleerleerleerle-0.xxxx
x= -0.xxxxxxxxxxxxxxxxxxx
.
.
.

Wie schafft man es das es so aussieht:

x= -0.xxx
x= -0.xxxxxx
x= -0.xxxxxxxxxxxxxxxxxx
.
.
.

???

Grüssli