Ein C++ zu C# Veständigungs Problem

Frischling

28.01.2007, 04:14

Hallo erstmal.

Also ich hab da so ein Problemchen den C++ Code aus dem einen Tuto dieser Seite zu verstehen weil ich in C# schreibe und C++ nie gelernt habe.

Das hier meine ich.

Mein problem besteht aus diesen beiden passagen den rest hab ich übersetzt und ich hoffe mal Korrekt.

	Quellcode
1 2 3 4 5 6 7 8	bool LineHitsLine(const Vector2D& p, const Vector2D& u, const Vector2D& q, const Vector2D& v, Vector2D* const pHit = 0) if(pHit) pHit = p + s u; return true;

return ist klar.
bool ist klar
LineHits der Funktionsname. Const soll wohl fest sein.
Aber was sollen phit sein und warum wird es mit 0 initialisiert.
Was bedeuten & und * const Vector2D& v, Vector2D* dadrine.
Und das kapier ich sogarnicht if(pHit) *pHit = p + s * u; .

Erklärung zu meinem Code.
x und y dürften klar sein und a und b stehen jeweils für die
beiden x und y der Richtung des Vektors.
Und eigentlich will ich gar nicht den Schnittpunkt haben in dieser Funktion das soll in einer eigenen Funktion sein mir gehts allein um das Ja oder Nein das man sich schneidet oder auch nicht.
Bin für jede Erklärung sehr Dankbar komme einfach nicht weiter.
Hier mein übersetzter Text

Quellcode

public bool IsTrue(Vektoren.Vektoren2 StartVektor, Baum ZielVektor)
        {
                double t, D, Dt, s, Ds;
                double pHit = 0;
                Baum ZielTemp = ZielVektor;
                
                // Die Determinante D berechnen
                D = (StartVektor.b * ZielTemp.a) - (StartVektor.a * ZielTemp.b);

                // Wenn D null ist, sind die Linien parallel.
                if (D < 0.0001f && D > -0.0001f) return false;

                // Determinante Ds berechnen
                Ds = (ZielTemp.y - StartVektor.y) * ZielTemp.a - (ZielTemp.x - StartVektor.x) * ZielTemp.b;

                // s = Ds / D berechnen und prüfen, ob s in den Grenzen liegt
                s = Ds / D;
                if (s < 0.0f || s > 1.0f) return false;

                // Jetzt berechnen wir Dt und t.
                Dt = (ZielTemp.y - StartVektor.y) * StartVektor.a - (ZielTemp.x - StartVektor.x) * StartVektor.y;
                t = Dt / D;
                if (t < 0.0f || t > 1.0f) return false;

                // Die Linien schneiden sich!
                // Wir tragen den Schnittpunkt ein.
                if (pHit * pHit) = p + s * u);
                return true;
        }

* Editiert von koschka, das nächste mal bitte Codetags verwenden!

Zum Seitenanfang

Phil_GDM

Alter Hase

Beiträge: 443

Wohnort: Graz

Beruf: Student-Softwareentwicklung u. Wissensmanagement

2

28.01.2007, 09:23

Durch Vector2D* const phit ist es möglich, dass wenn man den Wert für phit in der Funktion ändert, dieser sich auch ausserhalb der Funktion mitändert, da man nicht auf einen lokale Variable zugreift, sonder über dein Zeiger auf eine Speicherstelle ausserhalb der Funktion referenziert.

*pHit ist die Dereferenzierung, denn du willst den Wert der Speicherstelle auf der der Zeiger zeigt ändern, und nicht den Zeiger an sich.

In C# würde der Code wohl ungefähr so aussehen

C-/C++-Quelltext

// Schneiden sich zwei 2D-Linien?

public bool LineHitsLine(const Vector2D p,
                  const Vector2D u,
                  const Vector2D q,
                  const Vector2D v,
                  out Vector2D pHit)
{
    // Die Determinante D berechnen

    const float D = u.y * v.x - u.x * v.y;

    // Wenn D null ist, sind die Linien parallel.

    if(D < 0.0001f && D > -0.0001f) return false;

    // Determinante Ds berechnen

    const float Ds = (q.y - p.y) * v.x - (q.x - p.x) * v.y;

    // s = Ds / D berechnen und prüfen, ob s in den Grenzen liegt

    const float s = Ds / D;
    if(s < 0.0f || s > 1.0f) return false;

    // Jetzt berechnen wir Dt und t.

    const float Dt = (q.y - p.y) * u.x - (q.x - p.x) * u.y;
    const float t = Dt / D;
    if(t < 0.0f || t > 1.0f) return false;

    // Die Linien schneiden sich!

    // Wir tragen den Schnittpunkt ein.

    //if(pHit) *pHit = p + s * u;

    phit = p + s * u;
    return true;
}

mfg Philipp

Zum Seitenanfang

chriss

Alter Hase

Beiträge: 624

3

28.01.2007, 15:35

Zitat von »"Phil_GDM"«

Durch Vector2D* const phit ist es möglich, dass wenn man den Wert für phit in der Funktion ändert, dieser sich auch ausserhalb der Funktion mitändert, da man nicht auf einen lokale Variable zugreift, sonder über dein Zeiger auf eine Speicherstelle ausserhalb der Funktion referenziert.

*pHit ist die Dereferenzierung, denn du willst den Wert der Speicherstelle auf der der Zeiger zeigt ändern, und nicht den Zeiger an sich.

In C# würde der Code wohl ungefähr so aussehen

C-/C++-Quelltext

// Schneiden sich zwei 2D-Linien?

public bool LineHitsLine(const Vector2D p,
                  const Vector2D u,
                  const Vector2D q,
                  const Vector2D v,
                  out Vector2D pHit)
{
    // Die Determinante D berechnen

    const float D = u.y * v.x - u.x * v.y;

    // Wenn D null ist, sind die Linien parallel.

    if(D < 0.0001f && D > -0.0001f) return false;

    // Determinante Ds berechnen

    const float Ds = (q.y - p.y) * v.x - (q.x - p.x) * v.y;

    // s = Ds / D berechnen und prüfen, ob s in den Grenzen liegt

    const float s = Ds / D;
    if(s < 0.0f || s > 1.0f) return false;

    // Jetzt berechnen wir Dt und t.

    const float Dt = (q.y - p.y) * u.x - (q.x - p.x) * u.y;
    const float t = Dt / D;
    if(t < 0.0f || t > 1.0f) return false;

    // Die Linien schneiden sich!

    // Wir tragen den Schnittpunkt ein.

    //if(pHit) *pHit = p + s * u;

    phit = p + s * u;
    return true;
}

Phil ich weiß nicht ob ich dich jetzt richtig versteh aber ich denke das stimmt so nicht ganz, oder man versteht es falsch.

Also wenn man in c# eine funktion hat die so aussieht,

	C-/C++-Quelltext
1 2 3 4	int myFunc(int Value) { return 0; }

dann werden die Werte kopiert. Also man bekommt den Wert, hat aber auf die Variablen außerhalb keinen Einfluss.

Schreibt man so etwas

	C-/C++-Quelltext
1 2 3 4	void myFunc(MyClass Object) { Object.Method(11); }

dann wird das Objekt nicht kopiert sondern nur die Referenz darauf. Also man arbeitet mit dem selben Objekt und alle Änderungen am Objekt selbst sind auch außerhalb der Funktion gültig da es sich ja um das selbe Objekt handelt.

Willst du aber ein neues Objekt anlegen und es soll in der Referenz außerhalb deiner Funktion gültig sein, musst du ein 'ref' anhängen

	C-/C++-Quelltext
1 2 3 4	void myFunc(ref MyClass Object) { Object = new MyClass(); }

verwendet wird das dann so

	C-/C++-Quelltext
1 2 3	MyClass ObjectMain = null; myFunc(ref ObjectMain);

Jetzt wird also eine referenz auf die Variable mitgegeben.

Für Datentypen wie int sieht das dann so aus

	C-/C++-Quelltext
1 2 3 4	void myFunc(ref int Value) { Value = 5; }

verwendung

	C-/C++-Quelltext
1 2 3	int MyInt = 2; myFunc(ref MyInt);

Am Ende hat 'MyInt' den Wert 5.

Ich hoffe das war soweit verständlich und hilft weiter.

Grüße

Zum Seitenanfang

Phil_GDM

Alter Hase

Beiträge: 443

Wohnort: Graz

Beruf: Student-Softwareentwicklung u. Wissensmanagement

4

28.01.2007, 16:31

Ich versteh nicht was da nicht stimmen sollte.

Der Text den ich geschrieben hab, hat sich ja auf C++ bezogen.

Und der der Code für C# sollte auch stimmen, sofern Vector2D ein struct ist.

mfg Philipp

Zum Seitenanfang

chriss

Alter Hase

Beiträge: 624

5

28.01.2007, 21:41

Gut dann hatte ich das nicht richtig verstanden. Da es um die Umsetzung in C# geht dachte ich das deine Lösung für C# sein soll.

@Armitage
Objekte des Typs Vector2D werden automatisch referenziert also kannst du das'const' und das '&' in C# einfach weglassen.