ich möchte nen Array schreiben, allerdings funktioniert das nicht so wie erhofft.

Wie kriege ich es hin, dass ich mit dem operator[] Elemente ersetzen kann?

Was muss ich als return Type haben?
type* und type& klappt nicht?

Gruß,
Kevin

Also ich meine: Die const-Version brauchst du nicht um Werte zu überhschreiben, aber die gehört auch dazu.

Gruß

Das funktioniert...
Allerdings nicht mit Referenzen...
Warum nicht?

Gruß,
Kevin

Danke schonmal...

Das funktioniert...
Allerdings nicht mit Referenzen...
Warum nicht?

Gruß,
Kevin

Was konkret funktioniert denn nicht? Fehlermeldung? Zeig mal was Code.

mfg
v R

TObject& o = TObject();
	TTemplate<TObject&>* list = new TTemplate<TObject&>(thr);
	threadlist[0] = thr;

Ich hab das mal stark vereinfacht:

Fehlermeldung:
instantiation of non-const reference type 'class TObject&' from rvalue of type 'TObject'

so:

const type& operator[] (unsigned int i) const {
		return t;
	}

????

Immernoch der gleiche Fehler

Referenzen kann man nicht in Containern speichern.

nicht in arrays. und das macht er nicht.

TObject& o = TObject();

TObject() ist ein temporäres Objekt, solche kannst du aber nicht an non-const Referenzen binden, sondern nur an const Referenzen. Folgendes würde also funktionieren:

const TObject& o = TObject();

Das Problem bei der non-const Version ist, dass dort direkt ein Objekt, also unser temporäres Objekt, an die Referenz gebunden werden würde. Das temporäre Objekt wird aber sofort wieder zerstört, sobald seine Verwendung als rvalue erlischt. Dh, du hättest danach eine Referenz auf ein nicht mehr existierendes Objekt. Macht also keinen Sinn. Bei der const Version hingegen kann der Compiler bei Bedarf selbst ein temporäres Objekt erzeugen, also in unserem Fall ein zweites temporäres Objekt, welches mit dem temporären Objekt des Client initialisiert wird. Dass dieses temporäre Client Objekt danach zerstört wird, spielt also keine Rolle mehr, da der Compiler ja selbst noch ein solches besitzt. Und das kann er solange halten und referenzieren, bis die Referenz nicht mehr gebraucht wird.

Was ich aber absolut nicht verstehe:
Ich nehmen jetzt als Typ TObject*.
Ich hab den Konstruktor jetzt so geändert, dass er einen int übergeben kriegt.
Jetzt macht er bei der Zuweisung

templ[0] = new TObject();

den Fehler:
parse error before ')' token
Invalid conversion from 'TObject*' to 'int'

Was hat der Konstruktor damit zu tun?

Vielen Dank,
Kevin

Ich hab den Konstruktor jetzt so geändert, dass er einen int übergeben kriegt.

meinst bzw. bezwecken willst.

template<class type>
class TTemplate {

public:
    TTemplate(/*type t*/ int i){
    }
    virtual ~TTemplate(){}

    type& operator[](unsigned int i){
        return t;
    }

private:
    type t;

};

Inzwischen bin ich davon überzeugt, dass es ein Compiler-Problem ist,
denn unter Linux kompiliert er es...
Ich verwende MinGW unter XP.

Gruß,
Kevin

Der code müßte doch eigentlich kompilierfähig sein...

Schön möglich, bevor du aber meine Frage nicht beantwortest, kann ich dir das nicht beantworten.

new TObject()

gibt jedenfalls ein TObject* zurück, also muss

templ[0]

einen entsprechenden Zuweisungsoperator besitzen. Falls nicht, wird versucht, einen passenden Konstruktor zu finden.
Ich kann dir zwar relativ schlecht folgen, aber vermutlich brauchst do sowas:

TTemplate(type* t)

Mir ist aber immer noch unklar, wieso du plötzlich die Sache mit new lösen willst. Ich hoffe du vergisst nach Gebrauch das delete nicht.
:xmas1: :xmas2:

Das soll nen Array-Template werden.
Deshalb auch der int Parameter.

Dass ich mich um die Garbage-Collection
kümmern muss, ist mir klar...

Aber wieso brauch ich sowas?

TTemplate(type* t)

Gruß,
Kevin

temp1 ist vom Typ TObject*.
Ich habs ja mit new TObject() erzeugt.
Kann doch dann nix anderes sein, oder?

Es geht nicht darum, was du temp1 zuweist, interessant ist erstmal nur, wie temp1 deklariert ist.

KeviKo schrieb:

Das soll nen Array-Template werden.
Deshalb auch der int Parameter.

Und der int Parameter gibt die initiale Grösse an, oder? Dann mach den ctor aber explicit, damit keine implizite Umwandlung durchgeführt wird.

KeviKo schrieb:

Aber wieso brauch ich sowas?

TTemplate(type* t)

Gruß,
Kevin

Wenn du die Werte nicht direkt im Container speicherst, sondern lediglich Zeiger auf die Werte, dann brauchst du einen entsprechenden ctor bzw. Zuweisungsoperator. Dh jetzt nicht, dass du den ctor exakt so deklarieren sollst. Der Code ist ja mehr oder weniger nur Pseudo. Du kannst auch type so angeben, dass es ein Zeiger ist. So wie man es idR von anderen Containern kennt, zB std::vector. Da in deinem Originalcode aber kein Zeiger für type verwendet wurde (TTemplate<TObject&>), kam mir der ctor

TTemplate(/*type t*/ int i){
    }

etwas seltsam vor.

temp1 ist vom Typ TObject*.
Ich habs ja mit new TObject() erzeugt.
Kann doch dann nix anderes sein, oder?

Es geht nicht darum, was du temp1 zuweist, interessant ist erstmal nur, wie temp1 deklariert ist. Oder ist temp1 tatsächlich vom Typ TObject*? Dann kann das nicht funktionieren, da temp1[0] dann vom Typ TObject ist.

KeviKo schrieb:

Das soll nen Array-Template werden.
Deshalb auch der int Parameter.

Und der int Parameter gibt die initiale Grösse an, oder? Dann mach den ctor aber explicit, damit keine implizite Umwandlung durchgeführt wird.

KeviKo schrieb:

Aber wieso brauch ich sowas?

TTemplate(type* t)

Gruß,
Kevin

Brauchen musst du das natürlich nicht. Wenn du die Werte nicht direkt im Container speicherst, sondern lediglich Zeiger auf die Werte, dann muss type entsprechend spezifiziert sein. Dh jetzt nicht, dass du den ctor exakt so deklarieren sollst. Der Code ist ja mehr oder weniger nur Pseudo. Wenn ich es mir so überlege, macht ein solcher ctor sowieso nur in wenigen Fällen Sinn. ZB dann, wenn du bei der Instanzierung ein initiales Element angeben willst. Wenn Zeiger in den Container gespeichert werden sollen, dann ist es jedenfalls generell besser, wenn type entsprechend als Zeiger angegeben wurde. Da in deinem Originalcode aber kein Zeiger für type verwendet wurde (TTemplate<TObject&>), kam mir der ctor

TTemplate(/*type t*/ int i){
    }

halt etwas seltsam vor.