Zeiger vergleichen

MrMilk

Hallo,

wieder einmal stehe ich wie ein Ochs vorm Berge. Mein Klassen Template sieht wie folgt aus:

template
<
    int i,
    class c
>
class A
{
    //...
    template
    <
         int i1,
         class c1
    >
    A& operator= (A<i1,c1>& ref);
};

und später die Implementierung:

template
<
    int i,
    class c
>
template
<
    int i1,
    class c1
>
A<i,c>& A<i,c>::operator= (A<i1,c1>& ref)
{
    if(this != &ref)
    {
        //...
    }

    return *this;
}

Jetzt wird mein Compiler brumming, wenn es unterschiedliche Spezialisierungen des Klassen Templates sind. Kann ich so weit auch noch nachvollziehen. Aber was macht man nun am besten?

Vielleicht vorher eine solche Abfrage:

if(i == i1 && c == c1)

Oder gibt es vielleicht eine Lösung die 'sauberer' ist?

Viele grüße und einen guten Morgen
MM

pumuckl

Die Frage ist, ob es überhaupt sinn machen kann, einem A<i,c> ein A<i2, c2> zuzuweisen. Der Zuweisungsoperator impliziert ja, dass das Objekt später den gleichen Zustand hat wie das Argument. Wenn es sich aber um zwei völlig verschiedene Typen handelt (und das ist der Fall, wenn es sich um zwei verschiedene Spezialisierungen des gleichen Templates handelt), dann kann das nicht wirklich der Fall sein. Was versuchst du mit den A's zu modellieren?

MrMilk

Hallo pumuckl,

das es völlig verschiedene Typen sind ist mir schon klar. Innerhalb der Template Klasse A gibt es noch ein paar Variablen die ich ohne Probleme zuweisen kann. Und mehr möchte ich auch nicht nicht.

Viele Grüße
MM

Sebastian Pizer

MrMilk schrieb:

Jetzt wird mein Compiler brumming, wenn es unterschiedliche Spezialisierungen des Klassen Templates sind.

Und was meinst Du damit?

edit: Achso. Der Zeichervergleich. Hättest Du ruhig mal erwähnen können. Als ich das gelesen hatte, hatte ich den Namen des Threads doch schon wieder vergessen.

MrMilk schrieb:

Vielleicht vorher eine solche Abfrage:
if(i == i1 && c == c1)
Oder gibt es vielleicht eine Lösung die 'sauberer' ist?

Die Existenz eines Templates für operator= oder dem copy-constructor hindert den Compiler übrigens nicht daran, seine eigenen Versionen zu generieren.

edit:
Du brauchst einfach diesen Zeigervergleich beim Template nicht und schreibst zusätzlich noch ein nicht-Template operator= (mit Zeigervergleich). Das musst Du ja sowieso machen, um den Compiler-generierten operator= zu ersetzen.