Auch ein Problem mit Templates =(

Hi,

Wenn ich versuche folgende Funktion zu compilieren

template<class tC1,class tC2,class tC3> tC1 GetDistance(Vector2<tC2> vector_a,Vector2<tC3> vector_b)
{

    Vector2<tC1> re_Vec;
    re_Vec.data.x=vector_b.data.x-vector_a.data.x;
    re_Vec.data.y=vector_b.data.y-vector_a.data.y;

    tC1 d;
    re_Vec.Getl<tC1>();
    return  d;

}

komme diese Fehler:

expected primary-expression before '>' token
expected primary-expression before ')' token

Ich kann mir diesen aber nicht erklären.
Habe ich irgendewas übersehen?

Bin für jede Hilfe dankbar.

Mathias

Naja... sagen wirs mal so, einen 2D-Vector als Template-Klasse zu definieren... weiss nicht ob das so geschickt ist.
Ansonsten lässt sich anhand deines Codes nicht wirklich sagen wo das Problem liegt.

Werner Salomon

Hallo Wolly,

der von Dir gepostete Code hat in sich keinen Syntax-Fehler. Der Fehler muss also in Code liegen, den Du nicht gepostet hast.
Darüber hinaus sind aber ein paar 'Ungereimheiten' ersichtlich.

Wolly schrieb:

tC1 d;
    re_Vec.Getl<tC1>();
    return  d;

Die Variable 'd' wird nicht initialisiert, nicht verändert und anschließend als Ergebnis zurück gegeben. Das kann nur falsch sein!

Die Template-Methode Getl (ich unterstelle mal Get-Länge) macht als Template keinen Sinn.

Dem Vector2 scheinen ein Konstruktor und ein operator- zu fehlen - ich unterstelle hier, dass Vector2 einen Punkt bzw. math. Vektor in der Ebene darstellen soll.

Und schließlich solltest Du die Übergabe-Parameter in 'GetDistance' als const refence deklarieren.

Gruß
Werner

Hi,

Hier ist nochmal der ganze Quelltext:

template<class myClass> class Vector2{
public:
    // Vector-Daten
    struct {
        myClass x;
        myClass y;
    } data;

    // Operatoren 
    Vector2<myClass> operator+(Vector2<myClass> ob2);
    Vector2<myClass> operator-(Vector2<myClass> ob2);
    Vector2<myClass> operator*(Vector2<myClass> ob2);
    Vector2<myClass> operator/(Vector2<myClass> ob2);

    // Get-Methoden
    template<class my_Class> my_Class Getl();
};

//Getl()
template<class myClass> template<class my_Class> my_Class Vector2<myClass>::Getl()
{
    my_Class lenght;

    lenght=sqrt(pow(data.x,2)+pow(data.y,2));
    return lenght;

}

// Operator+
template<class myClass> Vector2<myClass> Vector2<myClass>::operator+(Vector2<myClass> ob2)
{
        Vector2<myClass> re;

        re.data.x=data.x+ob2.data.x;
        re.data.y=data.y+ob2.data.y;

        return re;   
}
//Operator-
template<class myClass> Vector2<myClass> Vector2<myClass>::operator-(Vector2<myClass> ob2)
{
        Vector2<myClass> re;

        re.data.x=data.x-ob2.data.x;
        re.data.y=data.y-ob2.data.y;

        return re;   
}
//Operator*
template<class myClass> Vector2<myClass> Vector2<myClass>::operator*(Vector2<myClass> ob2)
{
        Vector2<myClass> re;

        re.data.x=data.x*ob2.data.x;
        re.data.y=data.y*ob2.data.y;

        return re;   
}
//Operator/
template<class myClass> Vector2<myClass> Vector2<myClass>::operator/(Vector2<myClass> ob2)
{
        Vector2<myClass> re;

        re.data.x=data.x/ob2.data.x;
        re.data.y=data.y/ob2.data.y;

        return re;   
}

template<class tC1,class tC2,class tC3> tC1 GetDistance(Vector2<tC2> vector_a,Vector2<tC3> vector_b)
{

    Vector2<tC1> re_Vec;
    re_Vec.data.x=vector_b.data.x-vector_a.data.x;
    re_Vec.data.y=vector_b.data.y-vector_a.data.y;

    tC1 d;
    d=re_Vec.Getl<tC1>();
    return  d;

}

Die Fehler bleiben die selben.
Eine Frage habe ich aber noch.Lohnt es sich überhaupt die Vector-Klasse
als Template zu machen? Oder soll ich lieber eine für int und eine double Werte schreiben?

SideWinder

In welcher Zeile tauchen die Fehler auf. Ich habe mal ohne drüberzuschauen das ganze unter meinem MSVC compiliert - Kein Fehler.

MfG SideWinder

Er tritt bei

template<class tC1,class tC2,class tC3> tC1 GetDistance(Vector2<tC2> vector_a,Vector2<tC3> vector_b)
{

    Vector2<tC1> re_Vec;
    re_Vec.data.x=vector_b.data.x-vector_a.data.x;
    re_Vec.data.y=vector_b.data.y-vector_a.data.y;

    tC1 d;
    d=re_Vec.Getl<tC1>(); // <- Hier kommen die Fehler
    return  d;
}

auf.
Sie lauten:

expected primary-expression before '>' token
expected primary-expression before ')' token

Ich benutze Dev c++, könnte es daran liegen?

virtuell Realisticer

Nabend,

mach das '<tC1>' hinter Getl weg. Du musst hier keinen Typ angeben, das hast du
ja bereits bei der Deklaration von re_Vec gemacht.

mfg
v R

CStoll

Wolly schrieb:

template<class my_Class> my_Class Getl();

//Getl()
template<class myClass> template<class my_Class> my_Class Vector2<myClass>::Getl()
{
    my_Class lenght;
    
    lenght=sqrt(pow(data.x,2)+pow(data.y,2));
    return lenght;
    
}

Wieso ist das Gebilde eigentlich als Template definiert? Die Länge sollte doch eigentlich den selben Typ besitzen wie deine Vektor-Elemente, oder?

Der Rückgabewert soll eben nicht den gleichen Typ haben wie die Klasse.
Beispiel:
2d-Welt => Ich benutze

Vector2<int>

coord da Komma-Wert Sinnlos wären.

Nun möchte ich aber die Entfernung zwischen 2 Punkten wissen und die möchte ich dann genauer haben.

Vector2<int> v1;

v1.Getl<double>

Mathias

2d-Welt => Ich benutze Ganzzahl-Koordinaten da Komma-Wert sinnlos wären.

Das halt ich aber für ein ziemliches Gerücht. Das Arbeiten mit Ganzzahlen hat an der Stelle den Vorteil, dass man dadurch um die Flieskommadarstellung herum kommt.
Die Distanz jedoch als double-Wert berechenen zu wollen zeigt, dass da in deinem Konzept was nicht passt. Dein gewähltes Raster (Ganzzahlen) ist im allgemeinen zu grob.
Ist ziemlich doof wenn man z.B. eine Distanz von 2,975234 misst und man nicht in der Lage ist seine Koordinaten so zu verändern, dass z.B. 3 heraus kommt, nur weil die Linie schärg liegt und man nur Ganzzahlen eingeben kann.

CStoll

An deiner Stelle würde ich eher eine Möglichkeit bereitstellen, verschiedene Vektoren ineinander umzurechnen (z.B. mit einem Template-Konstruktor).

Und außerdem - bei deiner Abstandsberechnung verwendest du schon einen Vektor<Zieltyp> für die interne Berechnung - also ist es doppelt gemoppelt, von dem noch eine Template-Längenfunktion aufzurufen.

camper

kleiner tip: es ist i.allg. sinnvoll, auch += -= etc. zu definieren und dann +- etc. freistehend und durch diese operationen auszudrücken. ausserdem ist es häufig günstiger, per referenz auf const zu übergeben statt per value:

// Operator+
template<class myClass> Vector2<myClass>& Vector2<myClass>::operator+=(const Vector2<myClass>& ob2)
{
        data.x+=ob2.data.x;
        data.y+=ob2.data.y;

        return *this;  
}
template<class myClass> Vector2<myClass> operator+(Vector2<myClass> ob1, const Vector2<myClass>& ob2)
{
        return ob1+=ob2;
}