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.

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

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?

MfG SideWinder

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?

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

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?

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>

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.

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.

// 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;
}