C++/Qt 4.8.1: Überflüssige Vorwärtsdeklarationen vermeiden

[Flo (Gast)]

Hallo C++ler,

ich schreibe gerade ein Programm, das aus einer GUI "MainWindow" und 
einer Datenverarbeitung "Core" besteht.
Ansich funktioniert alles, allerdings muss ich im Header von Core jede 
verwendete Klasse vorwärtsdeklarieren.
Das finde ich äußerst merkwürdig, umständlich und vor allem hässlich :D
Tue ich das nicht, wird die Fehlermeldung "ISO C++ forbids declaration 
of 'SerialTransmitter' with no type" ausgegeben.
Warum auch immer, wird also die Klasse nicht durch den Header 
deklariert.
Könnt ihr mir weiter helfen, was habe ich übersehen?
Das Problem trat erst auf, seit ich mein Programm in GUI und Core 
gesplittet hatte.
Irgendwie habe ich das Gefühl es hängt mit dem Namespace zusammen.

Gruß und Dank
Flo



main.cpp

#include <QApplication>

#include "core.h"
#include "mainwindow.h"

int main(int argc, char *argv[])
{
    QApplication gui(argc, argv);

    Core *theCore = new Core();
    MainWindow *theMainWindow = new MainWindow(theCore);
    theMainWindow->show();

    return gui.exec();
}

Hier muss ich alle verwendeten Klassen vorwärtsdeklarieren, hier zwei 
Beispielklassen:
core.h

#ifndef CORE_H
#define CORE_H

#include "serialtransmitter.h"
class SerialTransmitter;
#include "serialreceiver.h"
class SerialReceiver;

class Core : public QObject
{
    Q_OBJECT

public:
    explicit Core();

    SerialTransmitter *theSerialTransmitter;
    SerialReceiver *theSerialReceiver;

public slots:
    ...

public:
    ...

private:
    ...
};

#endif // CORE_H

core.cpp

#include "core.h"

Core::Core() : QObject()
{
    theSerialPort = NULL;

    theSerialTransmitter = new SerialTransmitter(this);
    theSerialReceiver = new SerialReceiver(this);
}

mainwindow.h

#ifndef MAINWINDOW_H
#define MAINWINDOW_H

#include <QtGui>

#include "DEF.h"
#include "core.h"
#include "mappanel.h"
#include "viewpanel.h"
#include "controlpanel.h"

namespace Ui
{
    class MainWindow;
}

class MainWindow : public QMainWindow
{
    Q_OBJECT

public:
    explicit MainWindow(Core *core);
    ~MainWindow();

private:
    Core *theCore;
    Ui::MainWindow *ui;

    ...

    MapPanel *theMapPanel;
    ViewPanel *theViewPanel;
    ControlPanel *theControlPanel;
};

#endif // MAINWINDOW_H

mainwindow.cpp

#include "mainwindow.h"
#include "ui_mainwindow.h"

MainWindow::MainWindow(Core *core) : QMainWindow(), ui(new Ui::MainWindow)
{
    ui->setupUi(this);
    theCore = core;

    theMapPanel = new MapPanel(theCore);
    theViewPanel = new ViewPanel(theCore);
    theControlPanel = new ControlPanel(theCore);

    ...
}

MainWindow::~MainWindow()
{
    delete ui;
}

[radiostar (Gast)]

Frage: passiert das auch, wenn main.cpp compiliert wird? Außerdem 
vermisse ich ein "#include <QObject>" in core.h, denn woher soll der 
Compiler wissen, was ein QObject ist?

[Rufus Τ. F. (rufus)]

Das erscheint merkwürdig:

#include "serialtransmitter.h"
class SerialTransmitter;
#include "serialreceiver.h"
class SerialReceiver;

Was ist denn in SerialTransmitter deklariert?

[Flo (Gast)]

Hallo radiostar,
Tatsache, QObject war nicht importiert, Danke für den Hinweis.
Dennoch funktioniert es nicht ohne Vorwärtsdefinitionen ...

Hallo Rufus,
hier SerialTransmitter:

serialtransmitter.h

#ifndef SERIALPORT_H
#define SERIALPORT_H

#include <QObject>

#include "core.h"
class Core;
#include "qextserialport.h"
#include "qextserialenumerator.h"
#include "serialportdialog.h"
class SerialPortDialog;

class SerialTransmitter : public QObject
{
    Q_OBJECT

public:
    explicit SerialTransmitter(Core *core);

private:
    Core *theCore;

    SerialPortDialog *theSerialPortDialog;

public slots:
    ...

public:
    ...
};

#endif // SERIALPORT_H

serialtransmitter.cpp

#include "serialtransmitter.h"

SerialTransmitter::SerialTransmitter(Core *core) : QObject()
{
    theCore = core;

    theSerialPortDialog = NULL;
}

Ich habe die Klassen nun alle sehr stark vereinfacht, falls ihr Methoden 
o.ä. zum Verständnis benötigt, sagt einfach Bescheid! ;)

Viele Grüße
Flo

[Rufus Τ. F. (rufus)]

Das ist merkwürdig. In serialtransmitter.h ist die Klasse deklariert, 
und nach dem Einbinden davon verwendest Du nochmal eine 
"Vorwärts"deklaration?

Was soll das?

[Flo (Gast)]

Hallo Rufus,
mir kommt es genauso spanisch vor wie Dir!
Ohne die "Vorwärts"deklaration nach dem Einbinden des Headers compiliert 
er nicht: "ISO C++ forbids declaration of 'myUglyClass' with no type"
Ich muss alle Klassen hinter Core nach"vorwärts"deklarieren, in 
MainWindow funktioniert alles, wie es soll ...

[Malte S. (maltest)]

Flo schrieb:
> serialtransmitter.h:
> #ifndef SERIALPORT_H
> #define SERIALPORT_H

Der Include-Guard entspricht nicht dem Dateinamen. Gibt es evtl. mehrere 
Dateien, die dank Copy/Paste SERIALPORT_H #definen?

Mit
#pragma once
wäre das nicht passiert.

[chris (Gast)]

in serialtransmitter.h

#ifndef SERIALPORT_H

Wieso nicht #ifndef SERIALTRANSMITTER_H ?

Nicht dass das SERIALPORT_H schonmal defined wurde.

[Flo (Gast)]

Hallo Malte und Chris,
ihr habt Relikte aus der alten Namensgebung gefunden ;)
Das war aber leider auch nicht der ausschlaggebende Fehler ... :(
Trotzdem Danke!

[Flo (Gast)]

Vielleicht gerade noch einmal eine etwas ausführlichere 
Fehlerbeschreibung:
Wenn ich in core.h die "Vorwärts"deklaration "class SerialTransmitter;" 
auskommentiere, erhalte ich genau folgende Ausgaben des Compilers:
    In file included from serialtransmitter.h - serialtransmitter.h
    from serialtransmitter.cpp - serialtransmitter.cpp
(!) ISO C++ forbids declaration of 'SerialTransmitter' with no type - 
core.h
(!) expected ';' before '*' token - core.h

[radiostar (Gast)]

in SerialTransmitter hast Du eine Variable vom Typ Core und in Core eine 
Variable vom Typ SerialTransmitter. Das kann nicht ohne 
Vorwärtsdeklaration funktionieren, denn eine der beiden Klassen muß ja 
zuerst definiert werden.

[Peter II (Gast)]

du kannst aber die Vorwärtsdeklarationen in die header datei schreiben 
und zwar vor dem include guard.

[Malte S. (maltest)]

radiostar schrieb:
> in SerialTransmitter hast Du eine Variable vom Typ Core und in Core eine
> Variable vom Typ SerialTransmitter. Das kann nicht ohne
> Vorwärtsdeklaration funktionieren, denn eine der beiden Klassen muß ja
> zuerst definiert werden.

Ja, aber es reicht, eine der Klassen vorwärts zu deklarieren. Und eine 
"Vorwärts"deklaration nach einbinden des Headers ist merkwürdig...

Aber klar:

Das #include "core.h" muss aus serialtransmitter.h raus oder das 
#include "serialtransmitter.h" aus core.h und die jeweils andere Klasse 
muss dann vorwärsdeklariert werden.
Den dazugehörigen Header dann nur in der .cpp-Datei einbinden.

[radiostar (Gast)]

Malte S. schrieb:
> Ja, aber es reicht, eine der Klassen vorwärts zu deklarieren. Und eine
> "Vorwärts"deklaration nach einbinden des Headers ist merkwürdig...

Das liegt an der Art, wie die header inkludiert werden:

core.h bindet serialtransmitter.h ein, das bindet core.h ein. Das aber 
funktioniert nicht, weil CORE_H schon definiert ist. Also bleibt die 
Klasse Core undefiniert in serialtransmitter.h. Eigentlich ganz logisch.

[Malte S. (maltest)]

radiostar schrieb:
> Malte S. schrieb:
>> Ja, aber es reicht, eine der Klassen vorwärts zu deklarieren. Und eine
>> "Vorwärts"deklaration nach einbinden des Headers ist merkwürdig...
>
> Das liegt an der Art, wie die header inkludiert werden:
>
> core.h bindet serialtransmitter.h ein, das bindet core.h ein. Das aber
> funktioniert nicht, weil CORE_H schon definiert ist. Also bleibt die
> Klasse Core undefiniert in serialtransmitter.h. Eigentlich ganz logisch.

Sag ich doch :)
Gegenseitiges #include ist schlecht fürs Karma.

a.h:

#pragma once

class B;

class A {
    A();
    B* myB;
};

b.h:

#pramga once

#include "a.h"

class B {
    B();
    A* myA;
};

a.cpp:

#include "a.h"
#include "b.h"

A::A()
    : myB(new B()) {
}

b.cpp:

#include "b.h"

B::B()
    : myA(new A()) {
}

Abgesehen vom entstehenden Speicherleck und minus Tipp- und sonstigen 
Fehlern sollte das zeigen, wie du die Abhängigkeiten auflösen kannst.

* In a.h ist kein #include "b.h"
* Also darf die Klasse B im Header a.h auch nur als Zeiger oder Referenz 
auftauchen.

[Peter II (Gast)]

Malte S. schrieb:

> a.h:#pragma once
>
> class B;
>
> class A {
>     A();
>     B* myB;
> };

ich verwenden immer:

class A;

#ifndef DATEINAME
#define DATEINAME

#include b
 
class A {
    A();
    B* myB;
};

#endif

damit ist man das Problem auch los. Ich finde es sehr unschön in fremden 
Dateien eine vorwärtsdeklaration für fremnde dinge zu haben.

[Malte S. (maltest)]

Auch eine Variante.
Da halte ich wiederum dagegen, dass die Vorwärtsdeklaration sonst ja das 
#include ersetzt und dadurch auch dokumentiert, dass eben nur 
vorwärtsdeklariert wurde mit allen Einschränkungen, die das bringt. Bei 
einem gegenseitigen #include mit magischen Vorwärtsdeklarationen wird 
das versteckt.
Geschmackssache.

[Flo (Gast)]

Boa Jungs, ihr seid Klasse!!!
Das klingt verdammt logisch ... und es funktioniert!
Vielen Dank für eure Mühe! :)

[radiostar (Gast)]

Bitte sehr. War uns eine Ehre.

[Rolf M. (rmagnus)]

Ich mache eigentlich immer nur dann ein #include, wenn es dort auch 
wirklich nötig ist. Wenn für ein File eine Vorwärtsdeklaration reicht, 
mache ich nur die. Macht Qt selbst übrigens intern auch so. Das hält den 
Rattenschwanz an inkludierten Headern kürzer, und die Probleme mit 
zyklischen Abhängigkeiten ergeben sich gar nicht erst.