Kann mir jemand sagen was mit dieser Fehlermeldung gemeint ist?

error C2758: 'Command::ui_': muss in der Basisklassen/Element-Initialisierungsliste des Konstruktors initialisiert werden.

mfg

Nein eigentlich ich wollte nur mal alles implementieren sonst nichts!

Versteh ich nicht.

Zeig doch mal den betreffenden Code.

#include <string>
#include "userinterface.h"

using namespace std;

int main()
{ 
  UserInterface *user = new UserInterface; 
return 0;
}

userinterface.h

#include "command.h"
#include "addcircle.h"

class UserInterface
{
private:
   Command* commands_;
public:
  UserInterface();
  ~UserInterface();  
};

userinterface.cpp

#include <string>
#include "userinterface.h"
#include "addcircle.h"

using namespace std;

UserInterface::UserInterface()
{
  //commands_ = new AddCircle[5];
}

UserInterface::~UserInterface()
{  
}

command.h

#include <string>
//#include "userinterface.h"

class UserInterface;

class Command 
{
private:
  //Command(const Command&);//Copy Constructor
protected:
  UserInterface& ui_;
public:  
   Command();
   Command(UserInterface& ui);
  ~Command();
  virtual bool execute() = 0;
  virtual const char* getName()= 0 ;
};

command.cpp

#include <string>
#include "command.h"

Command::Command()
{
}

Command::Command(UserInterface& ui)
{
}
Command::~Command()
{
}

addcircle

#include "userinterface.h"
#include "command.h"

class Command;

class AddCircle : Command
{
private:
  //CommandAddCircle(const CommandAddCircle &);//copy Konstruktor
  //SVGDocument& svg_doc_;
public:  
  AddCircle(){};
  AddCircle(UserInterface& ui);//SVGDocument& svg_doc
  bool execute();
  const char* getName() {return "circle";};
};

addcircle.cpp

#include "command.h"
#include "userinterface.h"
#include "addcircle.h"

#include <string>

AddCircle::AddCircle(UserInterface& ui)
{
  AddCircle::ui_;
}
bool AddCircle::execute()
{
  return 0;
}

Also hier mal der Code.

UserInterface& ui_;

Referenzen müssen initialisiert werden (genauer: in der Iniitalisierungsliste gesetzt), und können zur Laufzeit nicht mehr umgesetzt werden. Falls du von C#/Java kommst: Die dortigen Referenzen entsprechen intern den C++ Zeigern, nicht den C++ Referenzen.

cu André

Falls du von C#/Java kommst: Die dortigen Referenzen entsprechen intern den C++ Zeigern, nicht den C++ Referenzen.

Und falls Du von C kommst: C++ Referenzen entsprechen etwa den #defines des Präprozessors.

int var_a = 100;
#define ref_a var_a
cout << ref_a;

Ja aber ich muss alles per Referenz übergeben! Gibt es nicht eine andere Lösung?

1. Warum musst du alles als Referenz übergeben?
2. Auch bei einer Referenzübergabe kannst du intern dennoch einen Zeiger halten.

Neuling_ schrieb:

Ja aber ich muss alles per Referenz übergeben! Gibt es nicht eine andere Lösung?

1. Warum musst du alles als Referenz übergeben?

2. Auch bei einer Referenzübergabe kannst du intern dennoch einen Zeiger halten.

1.Weil das vorgegeben ist!
2.Intern schon aber damit geht meine Fehlermeldung nicht weg!

asc schrieb:

Neuling_ schrieb:

Ja aber ich muss alles per Referenz übergeben! Gibt es nicht eine andere Lösung?

1. Warum musst du alles als Referenz übergeben?

2. Auch bei einer Referenzübergabe kannst du intern dennoch einen Zeiger halten.

1.Weil das vorgegeben ist!
2.Intern schon aber damit geht meine Fehlermeldung nicht weg!

kauf dir nen c++ buch -.-
wieso ist es vorgegeben? was genau ist vorgegeben (genauer wortlt der aufgabenstellung/...)?

zu 2. dann machst du was falsch - was genaueres gibts, wenn du genauer wirst...

bb

2.Intern schon aber damit geht meine Fehlermeldung nicht weg!

Wie wäre es wenn du dir erst einmal überlegst, wie du Fragen stellen musst, damit du sinnvolle Antworten erwarten kannst. Denk bitte daran, das wir weder deinen Sourcecode noch irgendwelche sinnvollen Fehlermeldungen vorliegen haben. Die Fehler des Compilers ergeben in der Regel Sinn.

Stell deine Variable _ui auf einen Zeiger um und weise ihr die Adresse der Übergebenen Referenz zu. Ganz davon abgesehen das du (sofern du nicht durch - uns unbekannten - Vorgaben eingeschränkt bist) mit der C++ Standardbibliothek, Boost und dem TR1 schon einige Probleme von dir lösen könntest.

1. Zu jedem new gehört auch genau ein delete.
=> Sinnvolle Alternativen sind Smartpointer, wie z.B. boost::scoped_ptr, boost::shared_ptr/std::tr1::shared_ptr.

2. Ohne deine aktuelle Fehlermeldung und dem aktuellen Codeausschnitt wirst du von uns keine Hilfe erwarten können. Kurz gesagt: Du machst etwas falsch. Und sei es das dein Design (wie ich annehme) nicht sinnvoll gewählt ist.

Ich frage mich z.B. ob dein Command ohne UI-Objekt überhaupt Sinn macht. Wenn nein, kommst du ausschließlich mit Referenzen in deiner Commandklasse aus, sofern du die Initialisierungsliste verwendest UND ohne Standardkonstruktor/Zuweisungsoperator auskommst.

Eine Initialisierungsliste ist immer nötig, wenn...
a) du Referenzen initialisieren willst.
b) du Konstanten initialisieren willst.
c) du einen anderen als den Standardkonstruktor der Basisklasse verwenden willst.

class Base
{
    public:
        Base(int foo)
        : foo(foo) // Initialisierungsliste
        {}

        virtual ~Base()
        {}

    private:
        int foo;
};

class Inherited : public Base
{
    public:
        Inherited(int foo, int foo2)
        : Base(foo), // Den Konstruktor Base(int) verwenden,
          foo2(foo2) // und weiteren Member initialisieren...
        {}

        virtual ~Base()
        {}

    private:
        int foo2;
}

3. Basisklassen sollten entweder einen virtuellen Destruktor oder nur private Konstruktoren besitzen.
=> Des weiteren könnte auch hier Boost/TR1 einen Teil des Entwurfes ersetzen (boost::function/std::tr1::function, boost::bind/std::tr1::bind).

cu André