Class declaration with no definition in C++

Question

I do not have much experience with C++ and I have a question regarding the following lines from Qt documentation here : http://qt-project.org/doc/qt-4.8/mainwindows-application-mainwindow-h.html ( Lines 4-6 after the comment at the top )

 class QAction;
 class QMenu;
 class QPlainTextEdit;

Since QAction, QMenu and QPlainTextEdit are library classes of Qt ( clicking on them leads to their documentation pages), shouldn't they be included using '#include ' ? What purpose does just declaring them with the keyword 'class' serve ? As far as I think , the compiler will think of it as a completely new class, having nothing to do with the library class QAction.

However, the 'mainwindow.cpp' file ( http://qt-project.org/doc/qt-4.8/mainwindows-application-mainwindow-cpp.html ) does not contain any definition of class QAction, though its objects are being used in the code.

What is going on here ?

Edit : Further explanation of the problem

Look into the createActions method of class MainWindow ( http://qt-project.org/doc/qt-4.8/mainwindows-application-mainwindow-cpp.html ). Here objects of class QAction are being created but nowhere can I find a definition of QAction class.

Answer 1

Declaring a class, as opposed to defining it, is sufficient to make the compiler aware of the fact that a certain name refers to a type, and that allows you to use the type in certain settings. Specifically, a declared but not-yet-defined type is an incomplete type, and you can use incomplete types in several ways:

• In a function declaration, the function's return type and argument types may be incomplete (but of course not in the function's definition).*

• If T is an incomplete type, then T* and T&, as well as their CV-qualified versions, are complete types.

So you can write the following:

class Foo;  // we only need to know that `Foo` names a type.

struct Bar { Foo * p; };   // complete definition of `Bar`.

Foo mangle(Foo x, Foo y);  // function declaration

You can declare a class, or any type for that matter, as often as you like. The only thing that has to be unique is the definition (whence the "One Definition Rule").

_{*) With one exception: void is always incomplete, and you are allowed to return a void type by not returning anything at all.}

Answer 2

Those are known as "forward declarations" of the classes. It is used to make the compiler know that those symbols refer to classes, which are going to be defined afterwards. Those can be used in a header file to declare a symbol to be a class avoiding an inclusion of its header, which might be needed in some cases (circular inclusions for instance).

You can't always use forward declarations anyway, because the compiler might need to know how a class is defined. In other cases instead, the compiler needs only to know the fact that it actually is a class.

EDIT: To answer the following question you added, have a look at the QtGui file you can find in *qt_install_dir*/include/QtGui. In my Qt 4.8 installation I see inside:

#include "qaction.h"

Then look inside qaction.h: you'll see the complete definition of the QAction class. The inclusion of the header file QtGui is right at the beginning of your mainwindow.cpp, which makes QAction a complete type.

Answer 3

The type of the class is entirely determined by its fully-qualified name (not sure that's the official term, but anyway), which includes its namespace and its name. It doesn't matter whether it was sourced from a header file or simply declared in-situ.

In fact, the inclusion of a header file basically just inserts the text of that header into the point of the source code at which the inclusion appears. The effect is identical to replacing the #include with the contents of the header file using your favourite text editor. Either way, the compiler proper just sees a single stream of tokens.

The main purpose for using forward-declarations is to speed up the compiler by reducing the amount of text it has to parse and the size of the symbol tables that it builds up in RAM. I find this practice to be largely unnecessary these days in my own work, but very big projects probably still benefit.

Answer 4

I was just working on that example a few days ago. So here is the conclusion why I think you need those:

I'm guessing that if you'd look in the .pro file you'd see a line that's like:

QT += core
QT += gui

So the thing is you're telling the Qt translator and the compiler that you're using the QtGui and QtCore modules, and in those modules you have the QAction etc defined. So as a "hack" (since their IDE isn't able to detect that automatically until a later stage in the compilation process) you pre-declare the classes in order to avoid any errors during the compilation stage. In the end the Qt inserts the modules and everything works fine.

This gave me a headache the first time i did that as well but this was the only logical explanation I could get.

If you don't pre-declare the class you'll get an error saying that it can't find any reference to the class etc.

EDIT: In light of your recent update, i suggest that you go to YouTube and search for a user under the nick: voidrealms. He has decent C++ Qt video tutorials with explanations, and there he also shows the QMenu, QAction etc. He has 150+ videos on Qt C++ programming and covers everything from the basic Hello World all the way to network programming and even further... Check him out, he has other tutorials as well