3. Gerade als Klasse deklarieren

Gerade als Klasse deklarieren

  • K

    Nabend!
    Mein Problem ist folgendes:
    Ich möchte zwei Geraden als KLassen deklarieren und anschliessend prüfen
    ob die nen gemeinsamen Schnittpunkt haben. Ich weiss jez nicht wie ich das schreiben soll (p1.x, p1.y...)

    Weiss da ev. jemand weiter? Thx, John

    0
  • X

    kaestlinger01 schrieb:

    Nabend!
    Mein Problem ist folgendes:
    Ich möchte zwei Geraden als KLassen deklarieren und anschliessend prüfen
    ob die nen gemeinsamen Schnittpunkt haben. Ich weiss jez nicht wie ich das schreiben soll (p1.x, p1.y...)

    Weiss da ev. jemand weiter? Thx, John

    struct Punkt {
    int x;
    int y;
    };

    class Gerade {
    public:
    Punkt Startpunkt;
    Punkt Endpunkt;
    };

    Gerade g;
    Gerade h;

    (bestimmt kein guter Code...)

    Da gibts bestimmt ne lustige Formel 😛

    0
  • M
     

    bool Gerade::HatGemeinsamenSchnittpunktMit(Gerade const& dieAndereGerade) const
{
	return !(b != dieAndereGerade.b && m == dieAndereGerade.m);
}
    0
  • F

    Hallo, ich würds ungefär so machen:

    class Gerade
{
public:
	Gerade(double steigung, double yabstand) :
	  _m(steigung), _y(yabstand)
	{
	}

    bool hatSchnittpunkt(Gerade const& gerade)
	{
		return ! (gerade._y == _y);
	}

	double getschnittpunkt(Gerade const& gerade)
	{
		return (gerade._y - _y) / (_m - gerade._m);
	}

	double wert(double x)
	{
		return _m * x + _y; 
	}

private:
	double _m; // steigung
	double _y; // y-achsenabstand
};

int main()
{
	Gerade a(2, 5), b(3, 4);

	if(!a.hatSchnittpunkt(b)) {
		return 1;
	}

	double schnittpunkt = a.schnittpunkt(b);
	cout << "Schnittpunkt an Stelle x = " << schnittpunkt << endl;
	cout << "Y-Wert am Schnittpunkt f(x) = " << a.wert(schnittpunkt) << endl;

	return 0;
}

    edit: ach verdammt zu langsam 🤡

    Gruß

    0
  • B

    xindon schrieb:

    kaestlinger01 schrieb:

    Nabend!
    Mein Problem ist folgendes:
    Ich möchte zwei Geraden als KLassen deklarieren und anschliessend prüfen
    ob die nen gemeinsamen Schnittpunkt haben. Ich weiss jez nicht wie ich das schreiben soll (p1.x, p1.y...)

    Weiss da ev. jemand weiter? Thx, John

    struct Punkt {
    int x;
    int y;
    };

    class Gerade {
    public:
    Punkt Startpunkt;
    Punkt Endpunkt;
    };

    Gerade g;
    Gerade h;

    (bestimmt kein guter Code...)

    Da gibts bestimmt ne lustige Formel 😛

    Eine Gerade kann durch zwei Punkte festgelegt werden, aber sie hat weder Start- noch Endpunkt, oder hab ich was verpasst?

    0
  • X

    Brutus schrieb:

    Eine Gerade kann durch zwei Punkte festgelegt werden, aber sie hat weder Start- noch Endpunkt, oder hab ich was verpasst?

    Ja, mit Start- und Endpunkt wäre es eine Strecke. Man brauch wie schon gesagt 2 Punkte

    0
  • W

    kaestlinger01 schrieb:

    Mein Problem ist folgendes:
    Ich möchte zwei Geraden als Klassen deklarieren und anschliessend prüfen
    ob die nen gemeinsamen Schnittpunkt haben. Ich weiss jez nicht wie ich das schreiben soll (p1.x, p1.y...)

    Hallo John,

    zunächst einmal solltest Du Dir darüber im Klaren sein, ob Deine Gerade eine Geraden-Gleichung - wie von FireFlow vorgeschlagen - oder eine Gerade in der Ebene oder im Raum ist. Für letztere hat Xindon bereits angedeutet, dass man dafür außer einer Geraden auch noch einen Punkt - bzw. einen Vektor (im mathematischen Sinne) benötigt.
    Weiter wäre festzulegen, in welcher Form die Gerade gegeben ist - siehe http://de.wikipedia.org/wiki/Geradengleichung.

    Das ganze könnte dann in der Ebene (2D) im einfachsten Fall so aussehen:

    #include <iostream>
#include <cmath>    // std::sqrt
#include <utility>  // std::pair

class Vektor
{
public:
    Vektor() : m_x( 0.0 ), m_y( 0.0 ) {}
    Vektor( double x, double y ) : m_x( x ), m_y( y ) {}

    // --   Skalarprodukt
    double operator*( const Vektor& b ) const
    {
        return m_x * b.m_x + m_y * b.m_y;
    }
    // --   Division durch einen Skalar
    Vektor operator/( double teiler ) const
    {
        return Vektor( m_x / teiler, m_y / teiler );
    }

    double X() const { return m_x; }
    double Y() const { return m_y; }

    friend std::ostream& operator<<( std::ostream& out, const Vektor& v )
    {
        return out << "(" << v.m_x << "; " << v.m_y << ")";
    }
private:
    double m_x, m_y;
};
double abs( const Vektor& v )
{
    return std::sqrt( v.X() * v.X() + v.Y() + v.Y() );
}

class Gerade
{
public:
    // Konstruktor für Normalform
    Gerade( const Vektor& normale, const Vektor& punkt )
        : m_n( normale / abs( normale ) )
        , m_c( punkt * m_n )
    {}
    friend std::pair< Vektor, bool > 
        schnittpunkt( const Gerade& g1, const Gerade& g2 );
private:
    // --   interne Darstellung in Hessescher Normalform
    Vektor m_n; // abs( m_n ) == 1
    double m_c;
};

std::pair< Vektor, bool > schnittpunkt( const Gerade& g1, const Gerade& g2 )
{
    const double EPS = 1.E-8;
    const double det = g1.m_n.X() * g2.m_n.Y() - g2.m_n.X() * g1.m_n.Y();
    if( std::abs( det ) < EPS  )
        return std::make_pair( Vektor(), false );
    return std::make_pair( Vektor( 
        g1.m_c     * g2.m_n.Y() - g2.m_c     * g1.m_n.Y(),
        g1.m_n.X() * g2.m_c     - g2.m_n.X() * g1.m_c     ) / det, true );
}

    Eine kleines Testprogramm sähe dann so aus:

    int main()
{
    using namespace std;
    //         Normale          Punkt auf der Geraden
    Gerade g1( Vektor( 3, -1 ), Vektor( 4, 0 ) );
    Gerade g2( Vektor(-1,  2 ), Vektor( 1, 1 ) );
    std::pair< Vektor, bool > ret = schnittpunkt( g1, g2 );
    if( ret.second )
        cout << "Schnittpunkt liegt bei: " << ret.first << endl;

    Gerade g1_parallel( Vektor( 6, -2 ), Vektor( 5, 7 ) );
    ret = schnittpunkt( g1, g1_parallel );
    if( !ret.second )
        cout << "kein Schnittpunkt von g1 und g1_parallel" << endl;
    return 0;
}

    Gruß
    Werner

    0
Anmelden zum Antworten