[C++] template error: member function already defined

[.oisyn]

Ik heb een template structure, die een template member function heeft (operator =):

C++:

template<int i> struct S
{
    template<int j> S & operator = (const S<j> &)
    {
        return *this;
    }
};

S<0> s;

Onder VC7 krijg ik de error:

error C2535: 'S<i> &S<i>::operator =(const S<> &)' : member function already defined or declared

Terwijl ik toch niets fouts aan de code zie
(S<i> & returnen ipv S & werkt ook niet)

Ligt dit aan de compiler of doe ik gewoon iets fout?

[.oisyn]

hmmm als ik van de template argumenten een class maak ipv int dan werkt het wel

.edit: en het ligt ook alleen aan operator =
Als ik er een andere operator van maak dan werkt het prima

[.oisyn]

AHA!

ik denk dat het komt omdat de compiler een default assignment operator genereert. Als ik het returntype namelijk verander dan krijg ik een error dat ik 2 functies heb die alleen verschillen kwa return typen.

Als ik een extra operator = definieer die gewoon een S verwacht, dan verdwijnt de error:

C++:

template<int i> struct S
{
    S & operator = (const S &)
    {
        return *this;
    }

    template<int j> S & operator = (const S<j> &)
    {
        return *this;
    }
};

S<0> s;

Ok, probleem is dus opgelost Maar wat ik me nu afvraag: is dit een van MSVC7's quirks of moet het gewoon zo volgens de C++ standaard. Ik denk eerlijk gezegd dat eerste, maar goed ... ik heb net de Ansi C++ Draft, '96 working paper doorgelezen, en daar kan ik zo snel niet iets over vinden.

Oh trouwens met class ipv int deed ie het wel, dus het zal wel aan VC liggen

[curry684]

Handig, 'iemand' plaatst een post en lost 'm zelf binnen 3 kwartier op

[.oisyn]

als iedereen hier dat nou deed

[Soultaker]

Ter informatie: gcc geeft geen kik bij het compileren van de allereerste code. Het lijkt dus toch op een MSVC wazigheidje.

Ik ben trouwens benieuwd wat deze klasse gaat doen?

[.oisyn]

Soultaker: ah ok weten we dat ook weer. Compiled het 2e stukje trouwens ook? (ivm de mogelijk dubbele functie of ambigiuteit als je de ene S<0> aan de andere S<0> assignt. Moet je wel even code toevoegen die die assignment uitvoert natuurlijk )

Wat de klasse gaat doen: deze struct is natuurlijk compleet gestript van alle dingen die totaal niets met deze topic te maken hadden, zodat zowel ik als de mensen die dit lezen zeker weten dat niets anders de boosdoener is

En als je wilt weten waarvoor ik het nodig heb: ik ben mijn 3d math lib aan het uitbreiden zodat je element swizzling kunt toepassen.

voorbeeldcode:

C++:

Vector v1, v2;   // een Vector heeft een x, y, z en w element

v1 = 1, 2, 3, 4;  // v1 wordt nu (1, 2, 3, 4)

// deze 2 statements doen hetzelfde, v1 wordt v2
v2 = v1;
v2 = v1[x|y|z|w];

// met swizzling
v2 = v1[y|z|w|x];   // v2.x = v1.y,  v2.y = v1.z,  v1.z = v2.w,  v2.w = v1.x
v2[w|x|y|z] = v1;   // idem
v2 = v1[x|x|x|x];   // alle elementen van v2 wordt v1.x
v2[w|y|z|x] = 1, 2, 3, 4; // je raad het al :)

[.oisyn]

oh en hier trouwens de code: (dit is klad: ik moet nog wat doen aan de naamgeving enzo, plus het w-element zit er niet in)

C++:

struct Vector;


template<int i1> struct indexer1 { };
template<int i1, int i2> struct indexer2 { };
template<int i1, int i2, int i3> struct indexer3 { };

template<int i1, int i2> indexer2<i1, i2> operator | (indexer1<i1>, indexer1<i2>)
{
    return indexer2<i1, i2> ();
}

template<int i1, int i2, int i3> indexer3<i1, i2, i3> operator | (indexer2<i1, i2>, indexer1<i3>)
{
    return indexer3<i1, i2, i3> ();
}

indexer1<0> x;
indexer1<1> y;
indexer1<2> z;

indexer3<0, 1, 2> xyz;
indexer3<2, 1, 0> zyx;



template<int i1> struct setter1
{
    Vector & operator , (float f)
    {
        reinterpret_cast<Vector &> (*this)[i1] = f;
        return reinterpret_cast<Vector &> (*this);
    }
};

template<int i1, int i2> struct setter2
{
    setter1<i2> & operator , (float f)
    {
        reinterpret_cast<Vector &> (*this)[i1] = f;
        return reinterpret_cast<setter1<i2> &> (*this);
    }
};

template<int i1, int i2, int i3> struct setter3
{
    setter2<i2, i3> & operator = (float f)
    {
        (*this)()[i1] = f;
        return reinterpret_cast<setter2<i2, i3> &> (*this);
    }

    Vector & operator () ()
    {
        return reinterpret_cast<Vector &> (*this);
    }

    const Vector & operator () () const
    {
        return reinterpret_cast<const Vector &> (*this);
    }

    setter3 & operator = (const Vector & v)
    {
        (*this)()[i1] = v[0];
        (*this)()[i2] = v[1];
        (*this)()[i3] = v[2];
        return *this;
    }

    setter3 & operator = (const setter3 & s)
    {
        (*this)() = s ();
        return *this;
    }

    template<int i4, int i5, int i6> setter3 & operator = (const setter3<i4, i5, i6> & s)
    {
        (*this)()[i1] = s ()[i4];
        (*this)()[i2] = s ()[i5];
        (*this)()[i3] = s ()[i6];
        return *this;
    }
};



struct Vector
{
public:
    float x, y, z;

    const float & operator [] (int index) const
    {
        return *(&x + index);
    }

    float & operator [] (int index)
    {
        return *(&x + index);
    }

    template<int i1, int i2, int i3> setter3<i1, i2, i3> & operator [] (indexer3<i1, i2, i3>)
    {
        return reinterpret_cast<setter3<i1, i2, i3> &> (*this);
    }

    setter2<1, 2> & operator = (float f)
    {
        x = f;
        return reinterpret_cast<setter2<1, 2> &> (*this);
    }

    template<int i1, int i2, int i3> Vector & operator = (const setter3<i1, i2, i3> & s)
    {
        x = s ()[i1];
        y = s ()[i2];
        z = s ()[i3];
        return *this;
    }

    friend std::ostream & operator << (std::ostream & os, const Vector & v)
    {
        return os << '(' << v.x << ", " << v.y << ", " << v.z << ')';
    }
};

en die reinterpret_casts zijn ook niet zo netjes, maar dat scheelt weer een extra datamember en kan het dus beter geoptimalizeert worden

Oh de reden van deze topic was dus de struct setter3

[MSalters]

Vage bug, voornamelijk omdat die member helemaal niet geinstantieerd hoort te worden ->bodies zouden helemaal niet moeten uitmaken. Er is een expliciete regel die zegt (grofweg) dat de declaratie van een template (member) functie nooit de declaratie van een non-template (member) functie onmogelijk maakt. [13.3.3 Best Viable Function]