Zugriffsoperator überladen

Alechseij

Grünschnabel
Hallo :)
habe eine Templateklasse entworfen, die einen Koten in einer Baumstruktur modelliert. Diese Klasse soll als Basisklasse für Baumknoten mit erweiterten Funktionen dienen.
Nun möchte ich den Zugriffsoperator -> so überschreiben, dass er einen Zeiger des Typs zurück gibt, der als Templateargument angegeben wurde. Das klappt aber nicht, weil der Compiler den überladenen Operator zu ignorieren scheint. Seht selbst:

Der Header (LinkedTreeTemplate.h), das Template
C++:
#pragma once
#define _AFXDLL

#include <afx.h>
#include <list>
#include <algorithm>

template<class T>
class CTreeNode : public CObject
{
protected:
	/// <summary> The children </summary>
	std::list<CTreeNode*> m_children;

	/// <summary> The parent </summary>
	CTreeNode* m_parent;
public:
	CTreeNode(void) : m_parent(NULL){};

// Zugriffsoperator überschreiben
	T* operator->()
	{
		return dynamic_cast<T*>(this);
	}

	void AddChild(CTreeNode* pChild)
	{
...
	};

	std::list<CTreeNode*> GetChilds(const CRuntimeClass* pClass)
	{
...
	}

};

Nun die Verwendung im Beispielcode:

C++:
#include "stdafx.h"
#define _AFXDLL
#include <afx.h>

using namespace System;

#include "LinkedTreeTemplate.h"

class ItTestTreeBase : public CTreeNode<ItTestTreeBase>
{
	DECLARE_DYNCREATE(ItTestTreeBase)
public:
	ItTestTreeBase () : CTreeNode() {}
	ItTestTreeBase (const ItTestTreeBase& rhs) : CTreeNode(rhs){}

	virtual char* foo()
	{
		return "ItTestTreeBase";
	};
};
IMPLEMENT_DYNCREATE(ItTestTreeBase, CObject)

int main(array<System::String ^> ^args)
{
	ItTestTreeBase root, node1, node2;
	root.AddChild(&node1);
	root.AddChild(&node2);
	std::list<CTreeNode<ItTestTreeBase>*> li = root.GetChilds();
	std::list<CTreeNode<ItTestTreeBase>*>::iterator itD = li.begin();
	while (itD != li.end())
	{
		CTreeNode<ItTestTreeBase>* tmp = *itD;
		Console::WriteLine(tmp->foo()); // Compilerfehler
		itD++;
	}
    return 0;
}
Der Compiler dazu:
1>.\IteratorTest.cpp(33) : error C2039: 'foo': Ist kein Element von 'CTreeNode<T>'
1> with
1> [
1> T=ItTestTreeBase
1> ]
Hat also jemand ne Ahnung, was hier falsch läuft?
Danke Euch & Lg
Alechseij
 
Hi.

Die Variable tmp ist ein Zeiger!
C++:
Console::WriteLine((*tmp)->foo());
oder
C++:
CTreeNode<ItTestTreeBase>& tmp = **itD;
Console::WriteLine(tmp->foo());
Gruß
 
Zuletzt bearbeitet:
Hi deepthroat,

danke für die schnelle Antwort!

Dein Code funktioniert. Ich glaubte jedoch, dass der -> Operator ausschließlich für Zeiger verwendet wird. Nun wird er auf einer Referenz ausgeführt ...

Ich wollte eigentlich die gängige Syntax bzw. Ausdrucksform beibehalten. Gibt es eine Möglichkeit den Compiler von meiner ursprüglichen Variante zu überzeugen?

Grüße
Alechseij
 
Hi.
Dein Code funktioniert. Ich glaubte jedoch, dass der -> Operator ausschließlich für Zeiger verwendet wird. Nun wird er auf einer Referenz ausgeführt ...
Du hast doch den -> Operator explizit für deine Klasse CTreeNode definiert. Dann mußt du ihn auch auf ein solches Objekt anwenden.
Ich wollte eigentlich die gängige Syntax bzw. Ausdrucksform beibehalten. Gibt es eine Möglichkeit den Compiler von meiner ursprüglichen Variante zu überzeugen?
Nein. Man kann für Zeiger keine Überladung des -> Operators definieren, nur für benutzerdefinierte Typen.

Gruß
 
Zurück