Flächeninhalt bestimmen

[hustbaer]

@Swordfish

@Switch_24 sagte in Flächeninhalt bestimmen:

  art_von_dreieck(7,7,7);
p= art_von_dreieck();

Sind zwei Funktionsaufrufe einer Funktion Namens art_von_dreieck. Einmal rufst Du sie auf und übergibst ihr drei Parameter (7, 7 und 7) und einmal rufst Du sie ohne Parameter auf. ???

In C wird das sogar kompilieren. Sollte eine Warning geben, aber laut Standard ist das soweit ich weiss immer noch erlaubt.

Ich hatte mir auch erst gedacht dass das gar nicht gehen kann weil da kein Prototype für die Funktion ist, aber in C ist das eben erlaubt.

Falsch ist es natürlich trotzdem.

[rustyoldguy]

Hallo Switch_24!

Bei einem Dreieck ist die Summe zweier Seiten(egal welche), immer länger als die dritte Seite:

(a + b) > c
(a + c ) > b
(b + c) > a

Wenn allerdings zum Beispiel (a + b) <= c ist, dann liegt entweder eine fehlerhafte Eingabe oder eine Gerade vor.

Zudem kannst du die Fläche nur aus dem Seitenlängen mit der Formel des Heron von Alexandria bestimmen.
Wenn du die Seiten dann der Länge nach sortierst und die (Fläche * 2) / Längste_Seite berechnest, ist das die
Grundlage, alle drei Winkel am Dreieck zu berechnen.

Beim Vergleichen von Fließkommatypen egal ob float, double oder long double solltest du Vorsicht walten lassen.
Schreibe dir eine Funktion, bei der du bestimmen kannst in wie weit die Variablen bei den Nachkommastellen gleich sind.
Hier dazu nur ein kleines Beispiel:

#include <iostream>
#include <iomanip>
#include <cmath>
#include <limits>
 
int compdouble(double da, double db, int stellen)
{
 int rewer = -1, nachint_a = 0, nachint_b = 0, i, faktor = 1, vka, vkb;
 double nachkomma_a, vorkomma_a;
 double nachkomma_b, vorkomma_b;
 
  
 nachkomma_a = std::modf(da, &vorkomma_a);
 nachkomma_b = std::modf(db, &vorkomma_b);
 
 vka = vorkomma_a;
 vkb = vorkomma_b;
 
 std::cout << "Nachkomma_a: " << nachkomma_a << std::endl;
 std::cout << "Nachkomma_b: " << nachkomma_b << std::endl;
 
 if(vka == vkb)
 for (i = 0; i <= stellen; i++)
  {
   faktor *= 10;
   nachint_a = nachkomma_a * faktor;
   nachint_b = nachkomma_b * faktor;
   std::cout <<"nachint_a: " << std::setw(8) << nachint_a<< "   nachint_b: " << std::setw(8) <<  nachint_b << "   i:" << i << std::endl;
   if(nachint_a != nachint_b) break;
  }
 
  rewer = i;  // Gibt an, bis zu welcher Nachkommastelle die Zahlen gleich sind
 
 return rewer;	
}

int main()
{
    int erge = 0;
	double da, db;
	
	std::cout << "Bitte double-Wert eingeben: " ;
	std::cin >> da;
	std::cout << "Bitte 2ten double-Wert eingeben: " ;
	std::cin >> db;
 
    erge = compdouble(da, db, 8);    
    std::cout << "Gleich bis Nachkomma-Stelle: " << erge << std::endl;
	
 return 0;
}
Selbst bei ultralangen Schenkeln(etwa bei spitzwinkeligen Dreiecken), die gleich sind, kannst du einen der Schenkel hernehmen, um damit die Höhe zu bestimmen, welche zu 90 Grad rechtwinkelig auf diesem Schenkel steht, um damit die Winkel zu bestimmen. Bei einem rechtwinkeligen Dreieck ist die längste Seite immer die Hypotenuse. Teilt man diese in exakt zwei gleiche Teile und Zeichnet einen Halbkreis herum, so liegt der Schnittpunkt beider Schenkel auf dem Halbkreis.
Bei stumpfwinkeligen Dreiecken ist die längste Seite eh immer die, auf welche die Höhe (90 Grad zur längsten Seite), das Dreieck quasi in zwei Teile zerteil und man so über asin, acos, atan die Winkel berechnen kann. Die Höhe so über die längst Seite zu berechnen hat später Vorteile, etwa weil diese als eine Art Richtungsanzeiger fungiert, wenn man den
Kreis berechnet, der dieses Dreieck umschließt. Damit auch den Kreismittelpunkt dieses Kreises. Ist zum Beispiel interessant, wenn man etwa eine Stahlplatte hat, mit drei Passbohrungen darin in dem je ein Passstift steckt. Damit kann man dann den Durchmesser des Kreises berechnen, auf dem diese Drei Bohrungen liegen und dessen Kreismittelpunkt.
Da wird zuerst über die Kartesischen Koordinaten der Bohrungen die Seiten des Dreiecks berechnet, dann die Fläche, die Winkel, Die Höhe und die Laqe der längsten Seite(n). Erst dann kannst du die Lage des Kreismittelpunktes berechnen der den Kreis bildet, auf dem die Bohrungen sitzen.

Da du ja nur die Seitenlängen hast, musst du zuerst den Flächeninhalt berechnen, dann mindestens einen der Winkel.
Erst dann kannst du den Sinussatz anwenden.

[wob]

@rustyoldguy sagte in Flächeninhalt bestimmen:

int compdouble(double da, double db, int stellen)

Phew, ganz schön lang.

Meistens ist es ausreichend, einfach die Differenz mit einem Wert nahe 0 zu vergleichen:

bool almost_equal(double a, double b, double epsilon) {
   return std::abs(a - b) < epsilon;
}

Reicht für mich praktisch immer aus. Auch wenn man manchmal vielleicht lieber eine relative Ähnlichkeit testen will (also $a/b \approx 1$ statt $|a-b| \approx 0$)

[Swordfish]

@rustyoldguy @wob Das ist ja alles nett, aber der OP ist bei Zahlen vs. Zeichen.

@rustyoldguy In Deinem Post fehlt ein ``` nach Deinem Code.

[Th69]

Außerdem wird in seinem Code ja gar nicht mit Fließkommazahlen, sondern nur mit ganzen Zahlen, gerechnet.

[rustyoldguy]

Für Leute mit gcc, welche
Kompatibilität zu Microsofts 'double Epsilon' suchen:

double Epsilon(void)
{
double floatEps = 1;

    while (1 + floatEps / 2 != 1)
        floatEps /= 2;
return floatEps;
}

Das kleine Proggi war nur ein Beispiel. Quasi ein Vorschlag was man kochen könnte. Kein fertiges Rezept.

[wob]

@rustyoldguy sagte in Flächeninhalt bestimmen:

Für Leute mit gcc, welche
Kompatibilität zu Microsofts 'double Epsilon' suchen:

Hm? Wer sucht das hier? Wozu kann man es in diesem Zusammenhang nutzen?

In C++ könnte deine Funktion durch
std::numeric_limits<double>::epsilon()
ersetzt werden. Vielleicht gibt es in C auch etwas entsprechendes fertiges?

[SeppJ]

Bloß ist der Epsilonvergleich völlig sinnlos, weil er die wichtigste Eigenschaft von Fließkommazahlen, Skalierbarkeit, nicht berücksichtigt. Besser: Auf den Abstand gucken, im Sinne von wie viele Floatwerte zwischen den beiden Werten liegen können. Das ist bei IEEE 754 Zahlen sogar bewusst einfach gemacht, da diese auf Binärebene so codiert sind, dass dieser Abstand gleich der Differenz der Integerinterpretation der Binärcodierung ist.

[rustyoldguy]

Hallo SeppJ!

Auf stackoverflow habe ich dazu folgenden Kommentar gefunden:

"I don't know what they were smoking when they wrote that. Double.Epsilon is the smallest representable non-denormal floating point value that isn't 0. All you know is that, if there's a truncation error, it will always be larger than this value. Much larger."

https://stackoverflow.com/questions/2411392/double-epsilon-for-equality-greater-than-less-than-less-than-or-equal-to-gre

Der Erste Teil des Kommentar bezieht sich anscheinend auf die Programmierer von MS.

[*john 0]

@rustyoldguy sagte in Flächeninhalt bestimmen:

Für Leute mit gcc, welche
Kompatibilität zu Microsofts 'double Epsilon' suchen:

double Epsilon(void)

Es gibt dafür extra ein Makro

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

int main () {
    printf ("%e\n", DBL_EPSILON);

    return EXIT_SUCCESS;
}

Wenn man so Fragen hat sollte man sich mit dem Inhalt von float.h unbedingt vertraut machen.

[EinNutzer0]

So hätte ich das gemacht; hoffe, habe nix übersehen:

#include <iostream>
#include <map>
#include <math.h>

using namespace std;

enum Typ_Dreieck
{
    gleichschenklig = 1,
    rechtwinklig = 2,
    beliebig = 0
};

class Dreieck
{
private:
public:
    Dreieck(float a, float b, float c);
    ~Dreieck();
    float a, b, c;
    const float e = 0.1;

    bool is_equal(float a, float b) const
    {
        return fabs(a - b) - e <= 0;
    }

    bool is_gleichschenklig() const
    {
        return is_equal(a, b) || is_equal(a, c) || is_equal(b, c);
    }

    bool is_rechtwinklig() const
    {
        float a2 = a * a;
        float b2 = b * b;
        float c2 = c * c;
        if (is_equal(a, b))
            return is_equal(a2 + b2, c2);
        if (is_equal(a, c))
            return is_equal(a2 + c2, b2);
        if (is_equal(b, c))
            return is_equal(b2 + c2, a2);
        return false;
    }

    Typ_Dreieck get_type() const
    {
        if (is_rechtwinklig())
            return Typ_Dreieck::rechtwinklig;
        if (is_gleichschenklig())
            return Typ_Dreieck::gleichschenklig;
        return Typ_Dreieck::beliebig;
    }
};

Dreieck::Dreieck(float a, float b, float c) : a{a}, b{b}, c{c} {};

Dreieck::~Dreieck()
{
}

const char *type_to_string(Typ_Dreieck e)
{
    const map<Typ_Dreieck, const char *> my_map{
        {Typ_Dreieck::beliebig, "beliebig (type 0)"},
        {Typ_Dreieck::gleichschenklig, "gleichschenklig (type 1)"},
        {Typ_Dreieck::rechtwinklig, "rechtwinklig (type 2)"}};
    auto it = my_map.find(e);
    return it == my_map.end() ? "Out of range" : it->second;
}

ostream &operator<<(ostream &strm, const Dreieck &d)
{
    return strm << "Dreieck(" << d.a << ", " << d.b << ", " << d.c << ", " << type_to_string(d.get_type()) << ")";
}

int main(int argc, char **argv)
{
    cout << Dreieck(1.414, 1.414, 2) << endl;
    cout << Dreieck(1, 2, 3) << endl;
    cout << Dreieck(4, 4, 0.001) << endl;
    return EXIT_SUCCESS;
}

---

Edit: Ach klar habe ich etwas übersehen...:

    bool is_rechtwinklig() const
    {
        float a2 = a * a;
        float b2 = b * b;
        float c2 = c * c;
        return is_equal(a2 + b2, c2) || is_equal(a2 + c2, b2) || is_equal(b2 + c2, a2);
    }

int main(int argc, char **argv)
{
    cout << Dreieck(15, 20, 25) << endl;
    cout << Dreieck(1.414, 1.414, 2) << endl;
    cout << Dreieck(1, 2, 3) << endl;
    cout << Dreieck(4, 4, 0.001) << endl;
    return EXIT_SUCCESS;
}

Ersteres Dreieck wäre ohne Änderung nicht rechtwinklig gewesen...

[EinNutzer0]

Sorry, immer noch falsch.
Ein beliebiges oder gleichschenkliges Dreieck KANN rechtwinklig oder nicht rechtwinklig sein. Das eine bedingt oder schließt das andere nicht aus. Man braucht zwei enum: Typ_Schenkel_Dreieck und Typ_Winkel_Dreieck.

[EinNutzer0]

Das sollten jetzt alle Fälle sein...

#include <iostream>
#include <map>
#include <string>
#include <math.h>

using namespace std;

enum Typ_Schenkel_Dreieck
{
    beliebig,
    gleichschenklig,
    gleichseitig
};

enum Typ_Winkel_Dreieck
{
    spitzwinklig,
    stumpfwinklig,
    rechtwinklig
};

class Dreieck
{
private:
public:
    float a, b, c;
    const float e = 0.1;
    float aw, bw, cw;
    Dreieck(float a, float b, float c) : a{a}, b{b}, c{c}
    {
        float a2 = a * a, b2 = b * b, c2 = c * c;
        aw = acosf((b2 + c2 - a2) / (2 * b * c)) * (180 / 3.14159265358979323846);
        bw = acosf((a2 + c2 - b2) / (2 * a * c)) * (180 / 3.14159265358979323846);
        cw = acosf((a2 + b2 - c2) / (2 * a * b)) * (180 / 3.14159265358979323846);
    };

    ~Dreieck()
    {
    }

    bool is_equal(float a, float b) const
    {
        return fabs(a - b) - e <= 0;
    }

    Typ_Schenkel_Dreieck get_type_schenkel() const
    {
        if (is_equal(a, b) && is_equal(b, c))
            return Typ_Schenkel_Dreieck::gleichseitig;
        if (is_equal(a, b) || is_equal(a, c) || is_equal(b, c))
            return Typ_Schenkel_Dreieck::gleichschenklig;
        return beliebig;
    }

    Typ_Winkel_Dreieck get_type_winkel() const
    {
        if (is_equal(aw, 90) || is_equal(bw, 90) || is_equal(cw, 90))
            return Typ_Winkel_Dreieck::rechtwinklig;
        if (aw >= 90 || bw >= 90 || cw >= 90)
            return Typ_Winkel_Dreieck::stumpfwinklig;
        return Typ_Winkel_Dreieck::spitzwinklig;
    }
};

const char *type_to_string(Typ_Schenkel_Dreieck es, Typ_Winkel_Dreieck ew)
{
    string s1, s2;
    switch (es)
    {
    case Typ_Schenkel_Dreieck::beliebig:
        s1 = "beliebig, ";
        break;
    case Typ_Schenkel_Dreieck::gleichschenklig:
        s1 = "gleichschenklig, ";
        break;
    case Typ_Schenkel_Dreieck::gleichseitig:
        s1 = "gleichseitig, ";
        break;
    default:
        s1 = "not defined";
        break;
    }
    switch (ew)
    {
    case Typ_Winkel_Dreieck::spitzwinklig:
        s2 = "spitzwinklig";
        break;
    case Typ_Winkel_Dreieck::stumpfwinklig:
        s2 = "stumpfwinklig";
        break;
    case Typ_Winkel_Dreieck::rechtwinklig:
        s2 = "rechtwinklig";
        break;
    default:
        s2 = "not defined";
        break;
    }
    return (s1 + s2).c_str();
}

ostream &operator<<(ostream &strm, const Dreieck &d)
{
    return strm << "Dreieck(" << d.a << ", " << d.b << ", " << d.c << ", " << d.aw << ", " << d.bw << ", " << d.cw << ","
                << endl
                << type_to_string(d.get_type_schenkel(), d.get_type_winkel()) << ")";
}

int main(int argc, char **argv)
{
    cout << Dreieck(15, 20, 25) << endl;
    cout << Dreieck(1.414, 1.414, 2) << endl;
    cout << Dreieck(2, 2, 3) << endl;
    cout << Dreieck(4, 4, 1) << endl;
    return EXIT_SUCCESS;
}

[*john 0]

@EinNutzer0 Dir ist hoffentlich aufgefallen, dass das Thema unter der Rubrik C eingestellt ist und nicht unter C++?

[Th69]

Und wegen

const char *type_to_string(...)
{
  // ...
  return (s1 + s2).c_str();
}

auch noch UB (nimm also string als Rückgabetyp).

[EinNutzer0]

@john-0 sagte in Flächeninhalt bestimmen:

@EinNutzer0 Dir ist hoffentlich aufgefallen, dass das Thema unter der Rubrik C eingestellt ist und nicht unter C++?

Naja aber lässt sich ja, wenn er <math.h> inkludiert, einfach nach C übertragen - da muss er eben alles in eine Funktion schreiben.

@Th69 sagte in Flächeninhalt bestimmen:

nimm also string als Rückgabetyp

Danke.

[Swordfish]

@EinNutzer0 sagte in Flächeninhalt bestimmen:

    ~Dreieck()
    {
    }

Why, oh why

[EinNutzer0]

Hier einmal der C-Code:

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

typedef struct Dreieck
{
    float a, b, c, aw, bw, cw;
} Dreieck;

Dreieck *get_Dreieck(float a, float b, float c)
{
    float a2 = a * a, b2 = b * b, c2 = c * c;
    Dreieck *d = (Dreieck *)malloc(sizeof(Dreieck *));
    d->a = a;
    d->b = b;
    d->c = c;
    d->aw = acos((b2 + c2 - a2) / (2 * b * c)) * (180 / 3.14159265358979323846);
    d->bw = acos((a2 + c2 - b2) / (2 * a * c)) * (180 / 3.14159265358979323846);
    d->cw = acos((a2 + b2 - c2) / (2 * a * b)) * (180 / 3.14159265358979323846);
    if (d->aw == 0 || d->bw == 0 || d->cw == 0)
    {
        printf("Unmögliches Dreieck angegeben!!\n");
        free(d);
        return 0;
    }
    return d;
}

int is_equal(float a, float b)
{
    return fabs(a - b) - 0.1 <= 0;
}

void print_Dreieck(Dreieck *d)
{
    float s, A;
    if (d == 0)
        return;
    printf("Dreieck: %f %f %f %f %f %f\n", d->a, d->b, d->c, d->aw, d->bw, d->cw);
    if (is_equal(d->a, d->b) && is_equal(d->b, d->c))
        printf("Das Dreieck ist gleichseitig\n");
    else if (is_equal(d->a, d->b) || is_equal(d->a, d->c) || is_equal(d->b, d->c))
        printf("Das Dreieck ist gleichschenklig\n");
    else
        printf("Das Dreieck ist beliebig\n");

    if (is_equal(d->aw, 90) || is_equal(d->bw, 90) || is_equal(d->cw, 90))
        printf("Das Dreieck ist rechtwinklig\n");
    else if (d->aw >= 90 || d->bw >= 90 || d->cw >= 90)
        printf("Das Dreieck ist stumpfwinklig\n");
    else
        printf("Das Dreieck ist spitzwinklig\n");

    s = (d->a + d->b + d->c) * 0.5;
    A = sqrt(s * (s - d->a) * (s - d->b) * (s - d->c));
    printf("Der Flächeninhalt entspricht: %f\n\n", A);
}

int main()
{
    print_Dreieck(get_Dreieck(1, 2, 3));
    print_Dreieck(get_Dreieck(2, 2, 3));
    print_Dreieck(get_Dreieck(15, 20, 25));
    print_Dreieck(get_Dreieck(3, 3, 3));
    return 0;
}

Bitte mit -lm compilieren!!

$ ./Dreieck.out 
Unmögliches Dreieck angegeben!!
Dreieck: 2.000000 2.000000 3.000000 41.409622 41.409622 97.180756
Das Dreieck ist gleichschenklig
Das Dreieck ist stumpfwinklig
Der Flächeninhalt entspricht: 1.984313

Dreieck: 15.000000 20.000000 25.000000 36.869896 53.130100 90.000000
Das Dreieck ist beliebig
Das Dreieck ist rechtwinklig
Der Flächeninhalt entspricht: 150.000000

Dreieck: 3.000000 3.000000 3.000000 60.000000 60.000000 60.000000
Das Dreieck ist gleichseitig
Das Dreieck ist spitzwinklig
Der Flächeninhalt entspricht: 3.897114

Nu hab ich endlich alle Fälle abgefrühstückt,
daran, dass ein gegebenes Dreieck natürlich auch ungültig sein kann, hab ich erst wieder nicht gedacht!!

[wob]

Du hast ein Speicherleck eingebaut.

Deine Funktion get_Dreieck erzeugt ein NEUES Dreieck, das aber nie freigegeben wird.

Und das hier:

Dreieck *d = (Dreieck *)malloc(sizeof(Dreieck *));

WTF? Der Cast ist in C nicht nötig und sizeof von einem Pointer?

[Swordfish]

@wob sagte in Flächeninhalt bestimmen:

Der Cast ist in C nicht nötig

Ein C/C++-Programmierer ...

@EinNutzer0 Vielleicht auch mal drüber nachdenken daß man Variablen auch auf den ersten Blick verständliche Namen geben kann ohne groß über die rechte Seite von = nachdenken zu müssen.