Fun-Soft - Programmierforum

Autor

Thread - Seiten: > 1 <

000
23.05.2004, 20:53 Uhr
~Marco
Gast

Hi,

ich habe folgendes Problem. Ich habe zwei Klassen A und B. Klasse A benötigt Zugriff auf die Klasse B und Klasse B benötigt Zugriff auf die Klasse A.

C++:

class A
{
//Zugriff auf Klasse B wird in einer Methode benötigt->Headerdatei der Klasse B
};

class B : public class A
{
//aufgrund der Vererbung benötigt Klasse B natürlich die Headerdatei der Klasse A
};

Ich habe da mal etwas von einer Lösung mit einem Interface und einer dritten Headerdatei gehört. Leider habe ich keine Ahnung wie ich dieses Problem lösen soll. Beim Googlen habe ich leider auch nichts gefunden.

Hoffentlich könnt ihr mir weiterhelfen. Am Besten mit einem kleinen Beispiel.

Vielen Dank schon im Voraus

Marco

Profil || Private Message || Suche

Download || Zitatantwort || Editieren || Löschen || IP

001
23.05.2004, 21:07 Uhr
0xdeadbeef
Gott
(Operator)

Das kommt ziemlich darauf an, was du genau willst. In vielen Fällen reicht schon

C++:

// A.hh
class B;
class A
{
//...
};

//B.hh
#include "A.hh"
class B : public class A
{
//...
};

Aber unter Umständen kann das auch komplizierter sein - kommt halt drauf an.
--
Einfachheit ist Voraussetzung für Zuverlässigkeit.
-- Edsger Wybe Dijkstra

Profil || Private Message || Suche

Download || Zitatantwort || Editieren || Löschen || IP

002
23.05.2004, 21:22 Uhr
~Marco
Gast

Hi,

das hatte ich schon probiert. Das reicht in meinem Fall leider nicht. Bei mir dreht es sich um folgendes:

C++:

class IInterface
{
public:
static IInterface& GetInstance()
   {
       static CInterface theInstance; //hier ist Zugriff auf CInterface nötig
       return theInstance;
   }
virtual void DoSomething() = 0;
};

class CInterface : public IInterface  //hier ist Zugriff auf IInterface nötig
{
public:
void DoSomething();
};

Wie geht es in diesem Fall?

Vielen Dank schonmal

Marco

Profil || Private Message || Suche

Download || Zitatantwort || Editieren || Löschen || IP

003
23.05.2004, 21:39 Uhr
~mike
Gast

Hi!
Hab keine Ahnung von dem aber mir ist folgendes eingefallen

Das scheint mir ja so ähnlich wie COM von M$ zu sein (vielleicht es es ja COM *g*). Übergibt man da nicht die Instanz der 2ten Klasse per void *object?

mfg

Profil || Private Message || Suche

Download || Zitatantwort || Editieren || Löschen || IP

004
23.05.2004, 21:59 Uhr
AlfameisterT

Geht das nicht?

C++:

class IInterface
{
public:
static IInterface& GetInstance()
   {
       static IInterface * theInstance; //hier ist Zugriff auf CInterface nötig
       return (IInterface&)theInstance;
   }
virtual void DoSomething() = 0;
};

class CInterface : public IInterface  //hier ist Zugriff auf IInterface nötig
{
public:
void DoSomething();
};

Dieser Post wurde am 23.05.2004 um 21:59 Uhr von AlfameisterT editiert.

Profil || Private Message || Suche

Download || Zitatantwort || Editieren || Löschen || IP

005
23.05.2004, 22:24 Uhr
(un)wissender
Niveauwart

Äh, ich will dir ja nicht zu nahe treten, aber das ist Unsinn und falsch.
theInstance ist ein uninitialisierter Pointer und den versuchst du als Referenz zu liefern?
Wenn schon, dann so, ist auch auch nicht ok, und am eigentlichen Problem vorbei.

C++:

class IInterface
{
public:
static IInterface& GetInstance()
   {
       static IInterface * theInstance; //hier ist Zugriff auf CInterface nötig
   [b]return *theInstance;[/b]
   }
virtual void DoSomething() = 0;
};

class CInterface : public IInterface  //hier ist Zugriff auf IInterface nötig
{
public:
void DoSomething();
};

Ich behauptet auch mal ganz frch, dass das auch gar nicht geht, aber viel Ahnung habe ich von diesen Henne-Ei-Problemen nicht!
--
Wer früher stirbt ist länger tot.

Profil || Private Message || Suche

Download || Zitatantwort || Editieren || Löschen || IP

006
23.05.2004, 22:28 Uhr
0xdeadbeef
Gott
(Operator)

Was gehen müsste, wäre folgendes (ungetestet):

C++:

//IInterface.hh
class IInterface
{
public:
  static IInterface& GetInstance();
  virtual void DoSomething() = 0;
};

//Cinterface.hh
#include "IInterface.hh"
class CInterface : public IInterface  //hier ist Zugriff auf IInterface nötig
{
public:
  void DoSomething();
};

//IInterface.cc
#include "IInterface.hh"
#include "CInterface.hh"
CInterface IInterface::GetInstance() {
  static CInterface theInstance; //hier ist Zugriff auf CInterface nötig
  return theInstance;
}

--
Einfachheit ist Voraussetzung für Zuverlässigkeit.
-- Edsger Wybe Dijkstra

Profil || Private Message || Suche

Download || Zitatantwort || Editieren || Löschen || IP

007
24.05.2004, 00:11 Uhr
(un)wissender
Niveauwart

Das würde heißen, das man GetInstance nicht inline deklarieren könnte?
--
Wer früher stirbt ist länger tot.

Profil || Private Message || Suche

Download || Zitatantwort || Editieren || Löschen || IP

008
24.05.2004, 15:24 Uhr
~Marco
Gast

@Oxdeadbeef:
Vielen vielen Dank für deine Lösung. Es hat geklappt.

@Mike:
Irgendwie hat es schon etwas mit COM zu tun, auch wenn ich keine Ahnung von COM habe. Mein Ziel mit diesen beiden Klassen war es eine objektorientierte Schnittstelle in einer DLL anzubieten, obwohl diese dynamisch von einer Anwendung eingebunden werden kann.
Ich habe also eine Funktion mit C-Bindekonvention (extern "C") in der DLL, die ich von der Anwendung aus mit einem Funktionszeiger aufrufen kann. Diese Funktion liefert dann den Zeiger auf die Instanz der CInterface Klasse zurück. Und obwohl die IInterface Klasse exportiert wird, ist die Anwendung von der DLL unabhängig, da sie ja eigentlich nur mit der CInterface Klasse kommuniziert. Naja, ist jetzt nicht gut erklärt.

@alle:
Wen diese kleine Beispielanwendung interessiert, kann jederzeit den Code oder ausführlichere Information dazu bekommen.

mfg

Marco

Profil || Private Message || Suche

Download || Zitatantwort || Editieren || Löschen || IP

009
24.05.2004, 16:07 Uhr
0xdeadbeef
Gott
(Operator)

@unwissender: Ich würde mich generell damit zurückhalten, irgendetwas außer templates im Header zu implementieren. In diesem Fall könnte man es vielleicht inline implementieren, indem man theInstance als Klassenvariable auffasst, also etwa so:

C++:

//IInterface.hh
class CInterface; //Deklaration: Es gibt eine Klasse CInterface
class IInterface
{
private:
  static CInterface theInstance; //Deklaration: IInterface::theInstance existiert
public:
  static inline IInterface& GetInstance() { return theInstance; }
  virtual void DoSomething() = 0;
};

//Cinterface.hh
#include "IInterface.hh"
class CInterface : public IInterface  //hier ist Zugriff auf IInterface nötig
{
public:
  void DoSomething();
};

//IInterface.cc
#include "IInterface.hh"
#include "CInterface.hh"
CInterface IInterface::theInstance; //Definition: Hier wird IInterface::theInstance instanziiert

Übrigens hat sich oben ein Tipfeeler eingeschlichen, es muss natürlich

C++:

//IInterface.cc
#include "IInterface.hh"
#include "CInterface.hh"
[b]IInterface &[/b]IInterface::GetInstance() {
static CInterface theInstance; //hier ist Zugriff auf CInterface nötig
return theInstance;
}

heißen.
--
Einfachheit ist Voraussetzung für Zuverlässigkeit.
-- Edsger Wybe Dijkstra

Profil || Private Message || Suche

Download || Zitatantwort || Editieren || Löschen || IP

Seiten: > 1 < [ C / C++ (ANSI-Standard) ]

ThWBoard 2.73 FloSoft-Edition
© by Paul Baecher & Felix Gonschorek (www.thwboard.de)

Anpassungen des Forums
© by Flo-Soft (www.flo-soft.de)

Sie sind Besucher: