Methodenimplementation von abstrakten Klassen

Hallo,
ich habe gerade ein Problem bei der Vererbung.

Ich habe mir ein Art Interface geschrieben, das allen Klassen die von ihm erben zusätzlich Hilfsmethoden zur Verfügung stellt.

So sieht es ungefähr aus:

#include irgendEineKlasse

class IKlasse
{
protected:
	int hilfsMethode(irgendEineKlasse a, int b)
	{
		... mach was damit
	}

public:
	virtual double zuImplementieren(int a, int b) = 0;
}

In der Art sieht es aus.
Die Klasse die eine Objekt davon erstellt hat unter Umständen gar nichts mit irgendEineKlasse zu tun.
Weshalb ich es gerne so umbauen will, dass der, der ein Objekt davon macht, nicht unbedingt das include-Verzeichnis von irgendEineKlasse wissen muss.

Vorwärtsdeklaration geht ja so nicht direkt, da in der hilfsMethode1 darauf zugegriffen wird.
Also dachte ich mir, wird es auch bei Vererbungen sicher gehen, wenn ich einfach das Interface in .h und .cpp teile, so dass ich anstelle des #includes class irgendEineKlasse; schreiben kann und die Implementation von hilfsMethode in der cpp steht.

Lies sich auch wunderbar kompilieren.

Bei dem Programm die aber nun eine Instanz von einer Klasse erstellen will, die von IKlasse abgeleitet ist, kommt nun folgende Kompiler-Fehlermeldung:
Verweis auf nicht aufgelöstes externes Symbol "hilfsMethode"..

Also geh ich davon aus, dass ich das mit in .h und .cpp splitten bei Klassen, von denen ich ableiten will, nicht so einfach machen kann.

Wie würdet ihr dieses Problem, dass ich unabhängig von irgendEineKlasse sein will, angehen?

Xenya schrieb:

Also geh ich davon aus, dass ich das mit in .h und .cpp splitten bei Klassen, von denen ich ableiten will, nicht so einfach machen kann.

Ich gehe davon aus, dass du etwas falsch gemacht hast. Selbstverständlich kann man die Funktionen einer Klasse, von der abgeleitet wird, außerhalb des Headers implementieren.

brotbernd

// base.hpp

class Irgendwas;
class Base
{
public:
  virtual void Method() = 0;
private:
  void f(Irgendwas& was);
};

// base.cpp
#include "base.hpp"
#include "irgendwas.hpp"
void Base::f(Irgendwas& was)
{
  /* ... */
}

// conrete.hpp
#include "base.hpp"
class Concrete : public Base
{
public:
  void Method();
};

// concrete.cpp
#include "concrete.hpp"
void Concrete::Method()
{
   /*...*/
}

// foo.cpp
#include "base.hpp"
void Foo(Base& i)
{
  i.Method();
}

Edit: hatte es erst falsch verstanden.

ahhh, ich habs
die hilfsMethode war als inline deklariert. Da es ja nun in der cpp schon kompiliert wird und bei der Klasse, die es einbindet, auf die lib bei der Methode zugegriffen wird, darf es nicht inline sein.

Danke für die Antworten.