Friend Methode für Template außerhalb definieren .

Reply to Friend Methode für Template außerhalb definieren . on Sat, 02 Apr 2011 17:29:26 GMT

Bacid90210 — Sat, 02 Apr 2011 17:29:26 GMT

Hallo Leute ich schreibe gerade ein Template mit dem Namen Array.
Nun habe ich den << operator als friend überladen.
Habe diesen aber intern definiert . Und würde gerne wissen wie die Syntax für diese Operatordefinition außerhalb der Klassendefinition auszusehen hätte.

Folgendes Template :

#include 
using std::ostream;
template 

class Array
{
    private:

        static int defaultsize;
        T *internArray;
        int size;

    public:

        int getDefaultSize()const; // 
        int getActualSize()const; // 
        void setDefaultSize(int Value); //
        T getElement(int place)const;
        void setElement(T obstacle,int place);
        Array();
        Array(int _size);
        ~Array();
        Array(const Array&);
        Array& operator=(const Array& rhs);
        Array operator+(const Array& rhs);

        //STREAM OPERATIONS
        friend ostream& operator <<(ostream& stream,const Array& rhs)
        {
            for ( int i = 0 ; i < rhs.getActualSize() ; i ++)
            {
             stream << " Array an Stelle : " << i << " : " << rhs.getElement(i) << endl;
            }
        return stream;
    }
};

Idee :

ostream& ostream::operator <<(ostream& stream,const Array& rhs)
        {
            for ( int i = 0 ; i < rhs.getActualSize() ; i ++)
            {
             stream << " Array an Stelle : " << i << " : " << rhs.getElement(i) << endl;
            }
        return stream;}

Allerdings funktioniert dies nicht .. könnte mir jemand kurz erklären was ich hier falsch gemacht habe ?

Mfg

Reply to Friend Methode für Template außerhalb definieren . on Sat, 02 Apr 2011 17:31:23 GMT

HighLigerBiMBam — Sat, 02 Apr 2011 17:31:23 GMT

Dir fehlt das template für den Operator.

Reply to Friend Methode für Template außerhalb definieren . on Sat, 02 Apr 2011 17:34:20 GMT

Bacid90210 — Sat, 02 Apr 2011 17:34:20 GMT

HighLigerBiMBam schrieb:

Dir fehlt das template für den Operator.

Der Operator bezieht sich doch aber auf die Klasse ostream.
Ich sage ihm doch über das Friend nur dass er Zugriff auf die Member von Array hat oder habe ich da etwas falsch verstanden ?

Reply to Friend Methode für Template außerhalb definieren . on Sat, 02 Apr 2011 18:03:42 GMT

HighLigerBiMBam — Sat, 02 Apr 2011 18:03:42 GMT

Der operator ist eine freie Funktion, du sagst innerhalb der Klasse nur, dass dieser auf die privaten Member zugreifen darf.

Außerdem gibt es iostream.h nicht.

template 
class Array
{
    private:

        static int defaultsize;
        T *internArray;
        int size;

    public:

        int getDefaultSize()const; // 
        int getActualSize()const; // 
        void setDefaultSize(int Value); //
        T getElement(int place)const;
        void setElement(T obstacle,int place);
        Array();
        Array(int _size);
        ~Array();
        Array(const Array&);
        Array& operator=(const Array& rhs);
        Array operator+(const Array& rhs);

        template 
        friend ostream& operator <<(ostream& stream,const Array& rhs);
};

template 
ostream& operator <<(ostream& stream,const Array& rhs)
{
    for ( int i = 0 ; i < rhs.getActualSize() ; i ++)
    {
        stream << " Array an Stelle : " << i << " : " << rhs.getElement(i) << endl;
    }
	return stream;
}

Reply to Friend Methode für Template außerhalb definieren . on Sat, 02 Apr 2011 17:48:27 GMT

Bacid90210 — Sat, 02 Apr 2011 17:48:27 GMT

Bei diesem Ansatz bekomme ich 2 Fehlermeldungen

//Bei : 
template  
//"template parameter list matching the non-templated nested type 1 should be //empty('template<>') "

//und bei
ostream& ostream::operator <<(ostream& stream,const Array& rhs)  
//overloaded 'operator<<' must be a binary operator (has 3 parameters)"

Reply to Friend Methode für Template außerhalb definieren . on Sat, 02 Apr 2011 17:53:04 GMT

CStoll — Sat, 02 Apr 2011 17:53:04 GMT

bei dem Beispiel ist auch ein "ostream::" zu viel.

Ansonsten: Du kannst natürlich auch globale Funktionen als Template definieren - ist in dem Beispiel auch notwendig, weil du nicht berechtigt bist, neue Operatoren in die Klasse ostream zu packen.

(genau genommen gibt es keine "Klasse ostream" nur ein "typedef basic_ostream ostream;" ;))

Reply to Friend Methode für Template außerhalb definieren . on Sat, 02 Apr 2011 18:13:26 GMT

HighLigerBiMBam — Sat, 02 Apr 2011 18:13:26 GMT

Das geht mit Sicherheit auch mit friend.

Edit: ich habe meinen vorherigen Post dahingehend editiert.
Edit2: Der Linker muss wissen, dass die friend funktion (keine methode) auch ein template ist.

#include 

using namespace std; 

template 
class A
{
public:
	A(T var): var(var){}

	template 
	friend ostream& operator << (ostream& ostr, const A& a);

private:
	T var;
};

template
ostream& operator << (ostream& ostr, const A& a)
{
	ostr << a.var;
	return ostr;
}

int main() 
{
	A a(5);
	cout << a;
}

Reply to Friend Methode für Template außerhalb definieren . on Sat, 02 Apr 2011 18:28:02 GMT

Bacid90210 — Sat, 02 Apr 2011 18:28:02 GMT

Warum muss ich denn vor der Operatordefinition noch template angeben ..
Der Operator bezieht sich doch nicht auf die template Klasse ?

Jetzt funktioniert es , allerdings bekomme ich einen Linker error durch folgende Zeile :

#include 
#include "ArrayTemplate.h"
using std::cout;
using std::ostream;
using std::endl;

int main (int argc, const char * argv[])
{

    srand(100);
    Array IntegerArray(25);
    Array IntegerCopy(10);
    IntegerArray.setElement(6,7);

    //IntegerArray = IntegerCopy;
    cout << IntegerArray; // DIESE ZEILE VERURSACHT LINKER ERROR 
    return 0;
}

LINKER ERROR:

Undefined symbols for architecture x86_64:
"operator<<(std::ostream&, Array const&)", referenced from:
_main in main.o
ld: symbol(s) not found for architecture x86_64
clang: error: linker command failed with exit code 1 (use -v to see invocation)

Reply to Friend Methode für Template außerhalb definieren . on Sat, 02 Apr 2011 18:31:47 GMT

CStoll — Sat, 02 Apr 2011 18:31:47 GMT

Klar ist dein operator<<() ein Template - schließlich bezieht er sich auf die Template-Klasse Array<>. Ansonsten hat BimBam seinen letzten Beitrag noch berichtigt.

Reply to Friend Methode für Template außerhalb definieren . on Sat, 02 Apr 2011 18:34:38 GMT

Bacid90210 — Sat, 02 Apr 2011 18:34:38 GMT

Ok stimmt .
Aber wodurch wird der Linker-Fehler verursacht ?

Reply to Friend Methode für Template außerhalb definieren . on Sat, 02 Apr 2011 18:41:40 GMT

CStoll — Sat, 02 Apr 2011 18:41:40 GMT

Vermutlich durch die Regeln der Template-Instanziierung:

friend ostream& operator << (ostream& ostr, const A& a);

erklärt dem Compiler, daß für jeden Array ein passender operator<< existiert - die müsstest du alle einzeln schreiben.
template
friend ostream& operator << (ostream& ostr, const A& a);
[/cpp]erklärt den Template-Operator als Freund deiner Klasse.

Reply to Friend Methode für Template außerhalb definieren . on Sat, 02 Apr 2011 18:46:59 GMT

Bacid90210 — Sat, 02 Apr 2011 18:46:59 GMT

CStoll schrieb:

Vermutlich durch die Regeln der Template-Instanziierung:
friend ostream& operator << (ostream& ostr, const A& a);
erklärt dem Compiler, daß für jeden Array ein passender operator<< existiert - die müsstest du alle einzeln schreiben.
template
friend ostream& operator << (ostream& ostr, const A& a);
[/cpp]erklärt den Template-Operator als Freund deiner Klasse.

Definiere ich den Operator innerhalb der Klassendefiniton bekomme ich diesen Fehler allerdings nicht .

#include 
using std::ostream;
using std::endl;

template 
class Array
{
    private:

        static int defaultsize;
        T *internArray;
        int size;

    public:

        int getDefaultSize()const; // 
        int getActualSize()const; // 
        void setDefaultSize(int Value); //
        T getElement(int place)const;
        void setElement(T obstacle,int place);
        Array();
        Array(int _size);
        ~Array();
        Array(const Array&);
        Array& operator=(const Array& rhs);
        Array operator+(const Array& rhs);

        //STREAM OPERATIONS
        friend ostream& operator <<(ostream& stream,const Array& rhs)
       {
        for ( int i = 0 ; i < rhs.getActualSize() ; i ++) 
        { 
            stream << " Array an Stelle : " << i << " : " << rhs.getElement(i) << endl; 
        } 
        return stream; 
    }

};

Reply to Friend Methode für Template außerhalb definieren . on Sat, 02 Apr 2011 19:20:42 GMT

HighLigerBiMBam — Sat, 02 Apr 2011 19:20:42 GMT

Der Linker weiß nicht, dass die funktion ein template ist, also musst du es ihm sagen. Du musst also

template  friend ostream& operator <<(ostream& stream, const Array& rhs);

innerhalb der Klasse schreiben und

template  ostream& operator <<(ostream& stream, const Array& rhs){}

außerhalb der Klasse. Ich habe das doch schon weiter oben berichtigt.

Edit: Wenn du das template nicht vor die Funktion innerhalb der Klasse schreibst, dann sucht der Linker nach einer nicht template funktion, die es natürlich dann nicht gibt.

Reply to Friend Methode für Template außerhalb definieren . on Sat, 02 Apr 2011 19:32:21 GMT

Bacid90210 — Sat, 02 Apr 2011 19:32:21 GMT

So wie du es mir vorgeschlagen hast funktioniert es nicht. Das kann also nicht stimmen .
Ich belasse es jetzt bei dieser Version.

#include 
using std::ostream;
using std::endl;

template 
class Array
{
    private:

        static int defaultsize;
        T *internArray;
        int size;

    public:

        int getDefaultSize()const; // 
        int getActualSize()const; // 
        void setDefaultSize(int Value); //
        T getElement(int place)const;
        void setElement(T obstacle,int place);
        Array();
        Array(int _size);
        ~Array();
        Array(const Array&);
        Array& operator=(const Array& rhs);
        Array operator+(const Array& rhs);

        //STREAM OPERATIONS
        friend ostream& operator <<(ostream& stream,const Array& rhs)
        {
        for ( int i = 0 ; i < rhs.getActualSize() ; i ++) 
        { 
            stream << " Array an Stelle : " << i << " : " << rhs.getElement(i) << endl; 
        } 
        return stream; 
    }

};

Reply to Friend Methode für Template außerhalb definieren . on Sat, 02 Apr 2011 19:47:12 GMT

HighLigerBiMBam — Sat, 02 Apr 2011 19:47:12 GMT

Bei mir geht es.

#include 

template  
class Array 
{ 
private: 

    static int defaultsize; 
    T *internArray; 
    int size; 

public: 

    int getDefaultSize()const;
    int getActualSize()const;
    void setDefaultSize(int Value);
    T getElement(int place)const; 
    void setElement(T obstacle,int place); 
	Array(){}; 
    Array(int _size); 
	~Array(){}; 
    Array(const Array&);
    Array& operator=(const Array& rhs);
    Array operator+(const Array& rhs); 

    template  
    friend std::ostream& operator << (std::ostream& stream, const Array& rhs); 
}; 

template  
std::ostream& operator << (std::ostream& stream, const Array& rhs) 
{ 
    stream << "Array"; 
    return stream; 
}

int main() 
{
	Array a;
	std::cout << a;
}

Reply to Friend Methode für Template außerhalb definieren . on Sat, 02 Apr 2011 19:44:31 GMT

Bacid90210 — Sat, 02 Apr 2011 19:44:31 GMT

Keine Ahnung was das ist . Ich bekomme diese Fehlermeldung bei deiner Version:

Undefined symbols for architecture x86_64:
  "operator<<(std::ostream&, Array const&)", referenced from:
      _main in main.o
ld: symbol(s) not found for architecture x86_64
clang: error: linker command failed with exit code 1 (use -v to see invocation)

Reply to Friend Methode für Template außerhalb definieren . on Sat, 02 Apr 2011 19:51:53 GMT

HighLigerBiMBam — Sat, 02 Apr 2011 19:51:53 GMT

Da bin ich überfragt... Compiler reparieren? Projekt neu erstellen? Hast du es in einem neuen Projekt versucht?

Compiler und OS wären eventuell nützlich.

Reply to Friend Methode für Template außerhalb definieren . on Mon, 04 Apr 2011 21:46:48 GMT

Bacid90210 — Mon, 04 Apr 2011 21:46:48 GMT

Das Problem war einfach dass ich in meiner Operator Definiton nicht wieder T als Platzhalter nutzen darf ...

LÖSUNG :

// Sebastian Boldts AAT ( Awesome Array Template )
#include 
template 
class Array
{
    private:

        static int defaultsize;
        T *internArray;
        int size;

    public:

        int getDefaultSize()const; // 
        int getActualSize()const; // 
        void setDefaultSize(int Value); //
        T getElement(int place)const;
        void setElement(T obstacle,int place);
        Array();
        Array(int _size);
        ~Array();
        Array(const Array&);
        Array& operator=(const Array& rhs);
        Array operator+(const Array& rhs);

        //STREAM OPERATIONS
    template 
    friend std::ostream& operator <<(std::ostream& stream,const Array rhs);

};

/****IMPLEMENTIERUNG****/

template 
int Array::defaultsize = 10;

template 
int getDefaultSize()
{

    return Array::defaultsize;
}
template 
int Array::getActualSize()const
{
    return size;
}

template 
void Array::setDefaultSize(int Value)
{
    Array::defaultsize = Value;
}
template 
T Array::getElement(int place)const
{
    return internArray[place];    
}
template 
void Array::setElement(T obstacle,int place)
{   
    if(place < size)
    {
    internArray[place] = obstacle;
    }
}

//C'toren und D'toren

template 
Array::Array():size(getDefaultSize())
{
    internArray = new T[size];
    for (int i = 0 ; i < size ; i ++)
    {
        internArray[i] = 0;
    }
}

template 
Array::Array(int _size):size(_size)
{
    internArray = new T[_size];
    for (int i = 0 ; i < size ; i ++)
    {
        internArray[i] = 0;
    }
}

template 
Array::Array(const Array& _array):size(_array.size)
{

    internArray = new T[size];
    for (int i = 0 ; i < size ; i ++)
    {
        internArray[i] = _array.getElement(i);
    }
}
template 
Array::~Array()
{

    free(internArray);
}

//OPERATOREN

template 
Array& Array::operator=(const Array& rhs)
{
    size = rhs.getActualSize();
    delete[]internArray;
    internArray = new T[size];
    for(int i = 0 ; i < size ; i ++)
    {
        internArray[i] = rhs.getElement(i);
    }
    return *this;
}

template 
Array Array::operator+(const Array& rhs)
{
    Array temp(size +rhs.getActualSize());
    for(int i = size ; i < size ; i ++)
    {
        temp.setElement(i) = internArray[i];
    }
    for(int i = size+1 ; i < temp.getActualSize() ; i ++)
    {
        temp.setElement(i) = rhs.getElement(i);
    }
    return temp;

}

template 
std::ostream& operator <<(std::ostream& stream,const Array rhs)
{ 
    for ( int i = 0 ; i < rhs.internArray[i] ; i ++) 
    { 
        stream << " Array an Stelle : " << i << " : " << rhs.getElement(i) << std::endl; 
    } 
    return stream; 
}

//#include "ArrayTemplate.cpp"

//...... Coming Soon

Reply to Friend Methode für Template außerhalb definieren . on Mon, 04 Apr 2011 21:54:17 GMT

314159265358979 — Mon, 04 Apr 2011 21:54:17 GMT

Das ist natürlich logisch. Das sind die Fehler wegen denen man sich oft tot-sucht.
Immerhin funzt es jetzt

Reply to Friend Methode für Template außerhalb definieren . on Mon, 04 Apr 2011 22:06:37 GMT

CStoll — Mon, 04 Apr 2011 22:06:37 GMT

Und nachdem du deinen Quelltext durch den Compiler bekommen hast, kannst du dich als nächstes um die inhaltlichen Fehler kümmern:

- wenn du Speicher mit new[] anforderst, solltest du ihn auch mit delete[] freigeben und nicht mit free()
- der Zuweisungsoperator ist nicht gegen Selbstzuweisung geschützt
- die Anweisung internArray[i]=0; schränkt die Verwandbarkeit der Klasse etwas ein
- der Vergleich i im Ausgabe-Operator ist auch unsinnig


PS: Außerdem kommt der Ausgabe-Operator komplett mit den öffentlich erreichbaren Teilen des Arrays (getActualSize() und getElement()) aus, also kannst du dir das friend ersparen.
PPS: Zu den Vorteilen von statischen Methoden und const-Referenzen sage ich jetzt nichts.



Reply to Friend Methode für Template außerhalb definieren . on Mon, 04 Apr 2011 22:14:16 GMT
Bacid90210 — Mon, 04 Apr 2011 22:14:16 GMT
Ok , dankeschön .

Werde mich um die Fehler kümmern.