4

What's the current "best practice" regarding the inclusion of Qt header files when using a modern and recent C++ compiler (e.g. MSVC2015) with precompiled headers activated?

Example:

#include <QStringList> 
#include <QTreeWidget>
#include <QListWidget>

vs.

#include <QtCore>
#include <QtGui>

  • What convention should I choose for a new project?

  • What are the benefits/drawbacks of either?

  • What is more common for new projects?

FlKo
  • 805
  • 1
  • 10
  • 27

3 Answers3

2

As far as I know, there is no specific limitation/recommendation/advantages/drawback with Qt includes and precompiled headers. When including third party header files (Qt or boost or whatever), the same rules apply.

In general (true for Qt includes, but also for any other third party includes, like STL for instance, and even when including your own code), you should make your includes minimal. The fewer files you include, the faster compilation will be. Including files you don't actually need will make compilation slower. Additionally, if such a header file you included but do not use, is edited/modified (which should not be the case for third parties header files, in general), any file including it will require to be recompiled, even if it does not really use the code included....

So the general rule is to only include files that you really need. So if your file only needs QStringList, prefer including <QtCore/QStringList> rather than <QtCore>.

If you are concerned about compilation time, also make sure you only include files from header files (.h) if necessary, if forward declaration can be used, use it and only include the necessary header file from your implementation (.cpp). This will drastically reduce compilation time of your project when a header file gets modified (read this).

Now, if your project has many files that includes some Qt files, you may use precompiled header to optimize compilation. Those files will then be compiled once and only once. However, as all your files will end up using the same precompiled header (itself including many many header files), you should only do this if:

  • The precompiled header files should mainly be third party header files, so that they are not meant to change. Because if on changes, then all your files will require to be recompiled...
  • The compiler must support precompiled header (else, compilation may work but may also end up being slower because every file will end up including all the precompiled header of the project...so probably more files than it actually needs).
jpo38
  • 20,821
  • 10
  • 70
  • 151
1

I use next in all projects (for precompiled header):

#pragma once

#ifdef QT_CORE_LIB
# include <QtCore>
#endif

#ifdef QT_CONCURRENT_LIB
# include <QtConcurrent>
#endif

#ifdef QT_GUI_LIB
# include <QtGui>
#endif

#ifdef QT_WIDGETS_LIB
# include <QtWidgets>
#endif

#ifdef QT_MULTIMEDIA_LIB
# include <QtMultimedia>
#endif

#ifdef QT_NETWORK_LIB
# include <QtNetwork>
#endif

#ifdef QT_XML_LIB
# include <QtXml>
#endif

#ifdef QT_QML_LIB
# include <QtQml>
#endif

#ifdef QT_QUICK_LIB
# include <QtQuick>
#endif

#ifdef QT_SQL_LIB
# include <QtSql>
#endif

#ifdef QT_PRINTSUPPORT_LIB
# include <QtPrintSupport>
#endif

It will include necessary definitions only if you connect a module. Works well with msvs+qt addin or with cmake based projects (I use cotire).

Dmitry Sazonov
  • 8,801
  • 1
  • 35
  • 61
0

Including less headers reduces compilation time, and only that, so if you do 

#include <QtCore/QStringList>

compilation it's slightly faster than if you did

#include <QtCore>

If you are sure that you depend on everything in QtCore, include it, if not, include each header separately.

p-a-o-l-o
  • 9,807
  • 2
  • 22
  • 35
Bastien Thonnat
  • 563
  • 4
  • 9
  • "...and your binary will be larger with QtCore included." Are you really sure with that? Isn't it that the compiler is much more intelligent in seeing what's needed and what's not than an actual programmer regarding precompiled headers? – FlKo Oct 12 '17 at 16:18
  • It depend on your linker options – Bastien Thonnat Oct 12 '17 at 16:21
  • 3
    I don't think that's correct. For dynamic linking it makes no difference, as it is all external. For static linking, the compiler only includes the code that the user code is referencing, directly or indirectly. My static linked app is only 10 mb, even if I like to and include over 50 mb of static libs. It seems that only what I actually use is being added. – dtech Mar 10 '18 at 17:09
  • 2
    "and your binary will be larger with QtCore included" is definitely wrong. Unused declaration does not increase the binary size, however, it definitely increases compilation time. – jpo38 Mar 11 '18 at 12:45