[C++] operator *()
- Ersteller TiKu
- Erstellt am
Hi,
ich stehe hier grad irgendwie auf dem Schlauch. Ich habe eine Klasse SimpleIterator. Diese enthält einen operator:
Desweiteren habe ich eine Klasse GlMatrixStackIterator, welche von SimpleIterator erbt. In einer Methode von GlMatrixStackIterator möchte ich nun obigen Operator nutzen. Wenn ich mich nicht irre, müsste das ja so gehen:
Nur leider mault da der Compiler rum, er könne GlMatrixStackIterator nicht zu TransformNode* konvertieren (eigentlich verständlich). Gibt es außer der folgenden Triviallösung noch einen anderen Weg?
TiKu
ich stehe hier grad irgendwie auf dem Schlauch. Ich habe eine Klasse SimpleIterator. Diese enthält einen operator:
Code:
TransformNode* SimpleIterator::operator*()
{
return nodeStack.top().node; //return the top elements node
}
Code:
TransformNode* n = *this;
Code:
TransformNode* n = this->operator *();TiKu
this ist immer ein Zeiger, mit *this nimmst du den Zeiger auf den Zeiger auf die Instanz.
E: Blödsinn
Du inizialisierst den Zeiger auf eine Klasse ja mit einer Instanz einer Klasse, kann auch net gehen. Versuch mal TransformNode* n=this;
E: Blödsinn
Du inizialisierst den Zeiger auf eine Klasse ja mit einer Instanz einer Klasse, kann auch net gehen. Versuch mal TransformNode* n=this;
TransformIterator.h:
Hintergrundinfo:
Ich mache ein vorlesungsbegleitendes Praktikum, bei dem man alle 2 Wochen ein Programm bekommt, welches um diverse Funktionen erweitert werden muss. Für die Lösung eines Teils der aktuellen Aufgabe bietet es sich meinen Informationen zufolge an, an besagter Stelle besagten (bereits vorgegebenen) Operator zu nutzen. Der Code tut ja auch was er soll, nur kapier ich nicht wie man den Operator aufrufen muss. Ruft man ihn als Funktion auf, geht's - aber das ist ja nicht Sinn und Zweck eines Operators.
Die Aufgabe hätte ich so zwar auch gelöst, nur interessant fände ich es trotzdem mal wie die Praktikumsleitung sich das eigentlich gedacht hat.
Code:
#ifndef TRANSFORMITERATOR_H
#define TRANSFORMITERATOR_H
#include "TransformNode.h"
namespace SceneGraph
{
/** Iterator class for traversing a scengraph */
class SimpleIterator
{
public:
/// initializes the Iterator by loading the TransformNode* n as the actual element
SimpleIterator(TransformNode* n);
/// returns the actual element (the node on top of the stack)
TransformNode* operator*();
/// true if elements left in the scenegraph
bool hasMoreElements() const;
/// selects the next element in the scenegraph as active
void next();
protected:
/// is called after each push operation to the local stack
virtual void afterPush() {}
/// is called before each pop operation from the local stack
virtual void beforePop() {}
/** stores information to point to a special node in the scenegraph*/
struct StackEntry
{
/// actual element that is returned by the * operator
TransformNode *node;
/// number [0..x] of the childelement that will be active after a call of next()
unsigned int nextChild;
};
/// stores the local stack of StackEntry elements
std::stack<StackEntry> nodeStack;
};
/** Iterator class for traversing a scengraph setting OpenGL Matrices during traversal*/
class GlMatrixStackIterator : public SimpleIterator
{
public:
/// initializes the Iterator by loading the TransformNode* n as the actual element
GlMatrixStackIterator(TransformNode* n);
protected:
virtual void afterPush();
virtual void beforePop();
};
}
#endifIch mache ein vorlesungsbegleitendes Praktikum, bei dem man alle 2 Wochen ein Programm bekommt, welches um diverse Funktionen erweitert werden muss. Für die Lösung eines Teils der aktuellen Aufgabe bietet es sich meinen Informationen zufolge an, an besagter Stelle besagten (bereits vorgegebenen) Operator zu nutzen. Der Code tut ja auch was er soll, nur kapier ich nicht wie man den Operator aufrufen muss. Ruft man ihn als Funktion auf, geht's - aber das ist ja nicht Sinn und Zweck eines Operators.
Die Aufgabe hätte ich so zwar auch gelöst, nur interessant fände ich es trotzdem mal wie die Praktikumsleitung sich das eigentlich gedacht hat.
Ach jetzt hab ich glaub ich verstanden worum es eigentlich geht.
Es müsste so funktionieren:
TransformNode* n = this*;
oder (bin mir gerade net sicher) so:
TransformNode* n = this*();
In jedem Fall ist es ungewöhnlich einen Operator zu definieren, der nur auf einen Wert angewendet wird. Normal wäre ja operator*(xyz abc);
Es müsste so funktionieren:
TransformNode* n = this*;
oder (bin mir gerade net sicher) so:
TransformNode* n = this*();
In jedem Fall ist es ungewöhnlich einen Operator zu definieren, der nur auf einen Wert angewendet wird. Normal wäre ja operator*(xyz abc);
Nee, geht auch nicht. Ich frag den Kollegen bei der Abgabe mal wie das funktionieren soll.
Würd ich so nicht sagen. Angenommen Du baust Dir Deinen eigenen Integer-Zahlentyp (oder irgendwas anderes wo eine Iteration sinnvoll ist), dann macht ein unäres ++ oder -- sehr wohl Sinn.
Narf, nen Kommilitone hat soeben rausgefunden, dass *(*this) geht.
Irgendwie auch logisch (wenn ich mir das so anschaue): this ist ja nen Zeiger, also muss man erstmal dereferenzieren, bevor man den Operator anwendet.
Danke für Deine Hilfe, i_hasser.
Irgendwie auch logisch (wenn ich mir das so anschaue): this ist ja nen Zeiger, also muss man erstmal dereferenzieren, bevor man den Operator anwendet.
Danke für Deine Hilfe, i_hasser.
