Ich habe eine Klasse "Quadtree", einen ADT "treeNode" von dem ich die Klassen "rootNode", "internalNode" und "leaveNode" ableite. In all diesen Klassen gibt es z.B. die Memberfunktion "findLeftNeighbour(/.../)" deren Implementation so aussieht.

void interNode::findLeftNeighbour(const treeNode *prev, 
								  PathList &path, 
								  LeaveList &neighbours)
{
	// find out wether the search comes from the top or the bottom
	if (myPrevious == prev)		// search comes from the top
	{
		// check if the strating-point-level is reached (empty list)
		if (path.size() == 0)	// starting-point-level reached
		{
			// the right subelements of this element are the
			// left neighbors of the element
			GetRightData(neighbours);
		}
		else					// starting-point-level not reached
		{
			switch (*(path.begin()))
			{
			case 0:
				path.pop_front();
				myNext[1]->findLeftNeighbour(this, path, neighbours);
				break;
			case 2:
				path.pop_front();
				myNext[3]->findLeftNeighbour(this, path, neighbours);
				break;
			}
		}
	}
	else						// search comes from the bottom
	{
		// find out which path the search comes from (0, 1, 2 or 3)
		int direction = 0;
		while (myNext[direction]->GetKey() != prev->GetKey())
			direction++;

		// find out wether the left neighbour lie whithin 
		// the brothers or not and proced correctly
		switch (direction)
		{
		case 1:
			myNext[0]->findLeftNeighbour(this, path, neighbours);
			break;
		case 3:
			myNext[2]->findLeftNeighbour(this, path, neighbours);
			break;
		default:	// comming from path 0 or 2, the right neighbour is not in the brothers
			path.push_front(direction);
			myPrevious->findLeftNeighbour(this, path, neighbours);
			break;
		}
	}
}

Ich prüfe jedes mal ob die Funktion von einer Funktion von unten oder von oben aufgerufen wurde. Ist es nach dem OO-Ansatz besser diese Funktionen in zwei verschiedene zu zerlegen oder ist dieser Entwurf in Ordnung?

Wenn man sie lieber in zwei Funktionen zerlegt, gibt es für solche fälle irgenwelche Namenskonventionen (z.B. findLeftNeighbourUp(/.../), findLeftNeighbourDown(/.../))?

Und dann hätte ich da noch eine Frage zur Platzierung eines "typedef"s. Z.B. ist pathList momentan jeweils in den Klassen "QuadTree" und "treeNode" als

typedef std::list<int> PathList;

definiert. Ist es in solchen Fällen besser ein separates Header File zu erstellen in dem derartige "typedef"s stehen oder sollen diese tatsächlich innerhalb der Klassen stehen?

Z.B

class QuadTree
{
public:
    typedef std::list<int> pathList;
    // ... andere deklarationen und definitionen ...

privat:
    // ...
};

Herzlichen Dank im voraus für jede Anregung.

(Ich persönlich fänds schicker, wenn die Funktion findLeftNeighbour nur einmal in der Funktion aufgerufen wird, zumal die Parameter überall gleich sind.)

Für die typedefs gilt das Gleiche wie für die Funktionszerlegung. Ich bevorzuge es allerdings sie innerhalb der Klasse zu definieren. Dadurch sind die Typen gleich der Klasse zugeordnet, für die sie relevant sind.
Zudem würde ich den Namen des Typs vielleicht mit 'T' beginnen lassen (also TPathList). Dann sieht man schon am Bezeichner dass es sich um ein Typedef handelt und nicht um eine (statische) Variable.

Ich hab da jetzt noch eine Frage

Mathias schrieb:

(Ich persönlich fänds schicker, wenn die Funktion findLeftNeighbour nur einmal in der Funktion aufgerufen wird, zumal die Parameter überall gleich sind.)

Wie bekomme ich das hin, dass ich findLeftNeighbour nur einmal aufrufen kann? Im Augenblick rufe ich es ja auf verschiedenen Objekten auf. Z.B

// ...
myNext[0]->findLeftNeighbour(/*...*/)
// ...
myNext[1]->findLeftNeighbour(/*...*/)
// ...

Wie unterscheide ich dann die "Richtung" in der der Quadtree weitersuchen muss?

Danke für alle Anregungen

Knecht schrieb:

switch (direction)
		{
		case 1:
			myNext[0]->findLeftNeighbour(this, path, neighbours);
			break;
		case 3:
			myNext[2]->findLeftNeighbour(this, path, neighbours);
			break;
		default:	// comming from path 0 or 2, the right neighbour is not in the brothers
			path.push_front(direction);
			myPrevious->findLeftNeighbour(this, path, neighbours);
			break;
		}

vielleicht so:

if(direction & 0x1)
{
   myNext[direction - 1]->findLeftNeighbour(this, path, neighbours);
}
else
{
   path.push_front(direction);
   myPrevious->findLeftNeighbour(this, path, neighbours);
}

Meep Meep

if(direction & 0x1)
{
   myNext[direction - 1]->findLeftNeighbour(this, path, neighbours);
}
else
{
   path.push_front(direction);
   myPrevious->findLeftNeighbour(this, path, neighbours);
}

Na das nenne ich Trickreich, aber nicht lesbar. Besser ist:

if (direction == 1 || direction == 3)
{ ...

Der Code ist viel klarer. Und macht euch an solchen Stellen keine Gedanken über Performance. Unterschätzt den Optimierer nicht.

Tntnet

Na das nenne ich Trickreich, aber nicht lesbar. Besser ist:

if (direction == 1 || direction == 3)
{ ...

Der Code ist viel klarer.

Bin im Augenblick auch bei der Variante gelandet, da ich gescheitert bin auszuknobeln wie es für

if (direction == 0 || direction == 2)
// ...

funktioniert. (2 und 3 hab ich noch hingekrigt, "direction & 0x2" stimmts?)

Jedenfalls, danke nochmals.