Binären und-operator überladen auf eine Vorlagen-Klasse

War ich vor kurzem versucht, um zu Messen, mein operator überladen/template Fähigkeiten und wie ein kleiner test, erstellt der Container-Klasse unten. Während dieser code kompiliert fein und funktioniert korrekt unter MSVC 2008 (zeigt 11), die beide MinGW/GCC und Comeau choke auf die operator+ überlastung. Als ich Ihnen Vertrauen mehr als MSVC, ich versuche, herauszufinden, was ich falsch mache.

Hier ist der code:

#include <iostream>

using namespace std;

template <typename T>
class Container
{
      friend Container<T> operator+ <> (Container<T>& lhs, Container<T>& rhs);
   public: void setobj(T ob);
     T getobj();
      private: T obj;
};

template <typename T>
void Container<T>::setobj(T ob)
{
   obj = ob;
}

template <typename T>
T Container<T>::getobj()
{
   return obj;
}

template <typename T>
Container<T> operator+ <> (Container<T>& lhs, Container<T>& rhs)
{
      Container<T> temp;
      temp.obj = lhs.obj + rhs.obj;
      return temp;
}

int main()
{    
    Container<int> a, b;

 a.setobj(5);
    b.setobj(6);

 Container<int> c = a + b;

 cout << c.getobj() << endl;

    return 0;
}

Dies ist der Fehler, Comeau gibt:

Comeau C/C++ 4.3.10.1 (Oct  6 2008 11:28:09) for ONLINE_EVALUATION_BETA2
Copyright 1988-2008 Comeau Computing.  All rights reserved.
MODE:strict errors C++ C++0x_extensions

"ComeauTest.c", line 27: error: an explicit template argument list is not allowed
          on this declaration
  Container<T> operator+ <> (Container<T>& lhs, Container<T>& rhs)
               ^

1 error detected in the compilation of "ComeauTest.c".

Ich habe eine harte Zeit versucht zu bekommen Comeau/MingGW ball zu spielen, so dass ist, wo Wende ich mich an Euch. Es ist schon eine lange Zeit, da mein Gehirn geschmolzen ist, so viel unter dem Gewicht der C++ - syntax, also ich fühle mich ein wenig peinlich ;).

BEARBEITEN: Beseitigt eine (irrelevante) lvalue aufgelisteten Fehler in der anfänglichen Comeau dump.

InformationsquelleAutor GRB | 2009-06-07

c++operator-overloading operators templates

Ich die Lösung gefunden Dank zu diesem forum posting. Im wesentlichen müssen Sie ein Funktionsprototyp, bevor Sie Sie verwenden können, 'Freund', auf die es innerhalb der Klasse, aber Sie müssen auch die Klasse deklariert werden, um richtig zu definieren, die die Funktion Prototyp. Also, die Lösung ist, haben zwei Prototyp-Definitionen (von der Funktion und der Klasse) an der Spitze. Der folgende code kompiliert werden, unter allen drei Compiler:

#include <iostream>

using namespace std;

//added lines below
template<typename T> class Container;
template<typename T> Container<T> operator+ (Container<T>& lhs, Container<T>& rhs); 

template <typename T>
class Container
{
      friend Container<T> operator+ <> (Container<T>& lhs, Container<T>& rhs);
      public: void setobj(T ob);
              T getobj();
      private: T obj;
};

template <typename T>
void Container<T>::setobj(T ob)
{
      obj = ob;
}

template <typename T>
T Container<T>::getobj()
{
      return obj;
}

template <typename T>
Container<T> operator+ (Container<T>& lhs, Container<T>& rhs)
{
      Container<T> temp;
      temp.obj = lhs.obj + rhs.obj;
      return temp;
}

int main()
{    
    Container<int> a, b;

    a.setobj(5);
    b.setobj(6);

    Container<int> c = a + b;

    cout << c.getobj() << endl;

    return 0;
}

InformationsquelleAutor GRB

template <typename T>
Container<T> operator+ <> (Container<T>& lhs, Container<T>& rhs)

Hier die "<>" nach operator+ sollte entfernt werden, da Sie nur deklarieren Sie eine neue Vorlage, die nicht spezialisiert eine Allgemeine eine. Auch mindestens g++ sehen will, der template-Deklaration vor der friend-Deklaration, so muss es verschoben werden, bevor die Erklärung der Container. Also folgende Reihenfolge der Deklarationen funktioniert:

//forward declaration of Container<T>
template <typename T>
class Container;

template <typename T>
Container<T> operator+(Container<T>& lhs, Container<T>& rhs)
{ ... }

template <typename T>
class Container
{
      friend Container<T> operator+ <> (Container<T>& lhs, Container<T>& rhs);
      ...
};

InformationsquelleAutor sth

1

Diese gab ich einen Schuss unter GCC und habe es zu kompilieren und auszuführen mit ein paar änderungen. Es waren zwei änderungen, die ich hatte zu machen, um GCC glücklich.

War die Deklaration der friend-Vorlage-Funktion. Es ist eine eigene template-Deklaration separat von der Klasse eins, so habe ich U anstelle der Container-Klasse' T es. Ich habe auch losgeworden, die <> nach dem operator+. Ich glaube nicht, dass Sie brauchen diese, es sei denn, Sie schreiben eine template-Spezialisierung.
```
      template<typename U>
      friend Container<U> operator+ (Container<U>& lhs, Container<U>& rhs);
```
Beiden, die Linie
```
Container<int>& c = a + b;
```
nicht Fliegen mit GCC, weil Sie Fragen zum speichern einer Referenz auf ein temporäres (Ergebnis der addition). Ich entfernte das kaufmännische und-Zeichen so, dass es einen Ort zum speichern des Ergebnisses.

Sah ich Ihren Beitrag erst jetzt, dass Sie auch funktioniert, da der forward-Deklaration. Ich denke, ich werde dies auf jeden Fall als eine alternative, die nicht von Ihnen verlangen. Natürlich habe ich nur getestet, GCC...
- Ich fand dies in einem anderen posting online und dies wäre meine persönliche Präferenz der beiden (präziser).
- Diese gewähren Zugriff auf alle template-Spezialisierungen (also operator+<int> zugreifen konnte private Container<float>). Der code der Fragesteller gewähren will nur den Zugriff auf operator+<T> (nur operator+<float> Zugriff auf die privaten Container<float>)
- Ich sah, dass das Thema erwähnt, aber ich habe Probleme beim einrichten von einem solchen Szenario. Könnten Sie ein Beispiel-code-snippet, wo die int-überlastung greift auf eine float-private Mitglieder?
- Sie können immer konstruieren solchen Fällen künstlich. Ob oder nicht das passiert, auf die Wirklichkeit in Ihrem code ist nicht so sehr eine Frage. Die bloße Möglichkeit, dass, wenn es passiert (durch einen Unfall), gibt es nicht eine Fehlermeldung ist genug, um es ausschließen. Die Idee, Konzepte wie "const" und "privat" und "Freund" ist zu dokumentieren, Abhängigkeiten und gleichzeitig die Dinge so versteckt und lose wie möglich.
- Ich verstehe, dass der code da ist, kann nicht dazu führen, dass dies geschehen ist, was ich habe Probleme mit erstellen eines solchen künstlichen Fall. Ich kann mir persönlich nicht vorstellen, das man, so Frage ich mich, wenn Sie könnte.
- Ein häufiges Beispiel zu tun einige böse Dinge mit Soldaten ist diese: struct ScaryDude { }; template<> Container<ScaryDude> operator+ (Container<ScaryDude>& LS, Container<ScaryDude>& rhs) { /* jetzt haben wir Zugang zu Soldaten von alle Container-Objekte hier 🙂 */ } Aber das sollte nicht der Grund für die Zurückweisung der Ansatz. Der Grund sollte sein, dass diese unnötig verbreitert sich der Bereich von Freund-Funktionen, nicht, dass einige scary dude schreibt einige hacks zu bekommen, um Ihre Geschlechtsteile.
- ah, jetzt sehe ich, was du sagst; ich kann sehen, wie diese ausgenutzt werden können. Vielen Dank für die Verdeutlichung.
InformationsquelleAutor ryan_s

Du besser aus der Definition der Funktion direkt in die Klasse. Auch Sie sollten die übergabe der Parameter als const Referenzen.

template <typename T>
class Container
{
public:
    friend Container operator+ (Container const & lhs, Container const & rhs)
    {
        //...
    }
};

InformationsquelleAutor avakar

0

'operator+' ist nicht ein Mitglied die Funktion, und es ist nicht Vorlagen. Es ist nur den operator+, der nimmt die Vorlagen-Parameter.'
```
 template <typename T>
 Container<T> operator+ (Container<T>& lhs, Container<T>& rhs)
```
- Ich denke, dass der operator+ ist eine Vorlagen-Funktion, ist es nicht? Container<int> und a Container<double> zwei verschiedene Typen, so wird der compiler generieren müssen zwei verschiedene operator+ - Funktionen, um mit Ihnen umzugehen. Bedeutet das nicht, daß operator+ ist eine vorgefertigte Funktion?
- Es wird eine Funktion Vorlage. Aber du hast Recht, in dem weglassen des "<>" aus der definition der Vorlage. ("<>" wird nur verwendet, wenn die Angabe einer Funktion template call, und auch dann ist nur erforderlich, wenn eine nicht-template-Funktion mit dem gleichen Namen vorhanden ist.)
InformationsquelleAutor James Curran

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.