Setting up the Xcode IDE for developing Qt applications for Mac OS X is relatively simple. There are three options, GNU Make, Carbon, and Xcode makespec. Using the Xcode makespec is the simplest way to get started, but it seems to have problems with certain setups.

Using the Xcode makespec

If you don't mind using the console to set up your project, creating a new Xcode project can be done automatically by qmake.

Create the project bundle

1. Create a folder for your project. (You can switch the order of this step with the next.)
2. Open a console such as Terminal.app or an xterm using X11.app.
3. Change directories to the project folder using the cd command.
4. Create a .pro file. Calling qmake -project in an empty folder will not produce a suitable pro file, but touch myproject.pro will.
5. Execute the command qmake -spec macx-xcode.

From here you can close the console and open the .xcode bundle created by qmake or you can use the open command to launch it from the command line.

Known Issues

These issues are as of Qt/Mac 4.1.3, all experienced using OS X 10.3.9 and Xcode 1.5.

• Adding files to the Xcode project does not automatically add them to the .pro file. The .pro file can be edited within the project.
• Sometimes, adding a header file to the project will cause the build process to fail in dependency checking. There should be a workaround but I have not found it yet.
• Xcode will sometimes emit spurious internal errors about the build settings. I'm not sure if this is due a bug in qmake, a bug in Xcode, or misconfiguration of my build environment. It is also possible that qmake generates valid Xcode 2.x project files that aren't completely backwards-compatible with Xcode 1.x.

As a GNU Make project

The solution most similar to the traditional build process is to use GNU Make. This uses the traditional build tools and is quicker to set up, but ultimately is less convenient than the other methods.

Create a new GNU Make project

1. From File | New Project, select "GNU Make".

Add a qmake target

1. From Project | New Target, select "External Target".
2. Name the new target "qmake".
3. Under the new target's settings, under Custom Build Command, specify the full path to the qmake binary in "Build Tool".
4. Erase the contents of the "Arguments" field.

Manage your .pro file

If you want to maintain your own .pro file:

1. From File | New File, select "Empty File in Project".
2. Name the file with a .pro extension.

If you want to use qmake -project to maintain your .pro file:

1. Duplicate the "qmake" target. Name the new target "qmake -project".
2. Under the new target's settings, under Custom Build Command, set the "Arguments" field to "-project".

Building your project

1. If using the qmake -project method, select "qmake -project" as your active project and click Build to update your .pro file.
2. Select "qmake" as your active project and click Build to run qmake to generate your Makefile.
3. Select your main target and click Build to run make to compile your application.

As a Carbon project

Setting up a Qt application as a Carbon project requires more work but gives you better control over the build process and integrates qmake more comfortably into the Xcode toolchain when compared to the GNU Make method. This method produces a project similar to the one created by using the Xcode makespec, but has been deprecated in favor of the more automatic approach.

Create a new Carbon project

1. From File | New Project, select "Carbon application".
2. Delete the main.c and .pch file automatically generated by the template. (Feel free to replace them with a main.cpp file.)

• Deleting the prefix header is optional; you can use it if you want but it's not portable. If you choose to use it, take out the Carbon include provided by default.

Add Qt frameworks

1. Control+click or right-click on "External Frameworks and Libraries" in your project's file tree. Select Add | Existing Frameworks.
2. Find and add QtCore.framework.
3. Repeat to add QtGui.framework and any other frameworks or libraries needed by your application.

Add a Shell Script build phase

1. From Project | New Build Phase, select "New Shell Script Build Phase".
2. Set the script to:

   /path/to/qt4/bin/qmake 

1. If you intend to use Qt Designer, add make compiler_uic_make_all after make mocables.
2. If you wish to allow qmake to automatically maintain your .pro file, add /path/to/qt4/bin/qmake -project as the first line.
3. Expand the active target in your project's file tree and drag the Shell Script Files step up to be the first step of the build sequence.

Configure the compiler and linker

1. From the Project menu, select "Edit Active Target".
2. In the Build tab, find "Other Linker Flags" and set it to "-filelist MocLinkList".
3. Find "Prefix Header" and clear it.
4. Find "Precompile Prefix Header" and uncheck it.

• Of course, if you chose to use the prefix header, don't clear it. You may or may not wish to precompile it; consult Xcode's documentation.

Building your project

At this point you can use all of the Xcode build tools directly with no special steps.

Using Qt Designer

Unfortunately, while Xcode allows you to choose external editors for various file types, it seems to lack a way to specify new file types. If you could specify a new file type (i.e. "sourcecode.ui"), it would be a simple matter to associate it with Designer.

This doesn't mean you're out of luck, though. You can add .ui files to your project just like any other file, and if you control+click or right-click the file, selecting "Open with Finder" will launch Designer with the selected file.

    Qt 包含完全集成的 ECMA 标准脚本引擎。Qt Script 集成了 QObject，为脚本提供了 Qt 的信号与槽 (Signals & Slots) 机制，可在 C++ 和脚本之间进行集成。 脚本支持可使开发事半功倍，QtScript提供脚本错误报告，用户可用自己的脚本跟踪程序缺陷.

   下面是一个简单的hello程序。

记住还需要在.pro文件中加入：QT       += script

    1、QScriptEngine类为程序提供一个嵌入式脚本环境。一个应用程序中可以添加多个脚本引擎；每一个引擎都是一个轻量级自包含的虚拟机。通过调用脚本引擎的evaluate()函数可以执行脚本.

    2、QScriptValue是一个Qt Script数据类型的容器,支持ECMA-262定义的类型，如：

     原始数据类型：Undefined,Null,Boolean,Number,String,对象类型。

     另外Qt Script还内建支持QVariant,QObject和QMetaObject.

      >>对于基对象(object-based)类型（包括Date和RegExp)，使用QScriptEngine对象的newT()函数（如QScriptEngine::newObject())创建一个你期望的QScriptValue类型。

      >>对于原始数据类型,直接使用QScriptValue构造函数加载。

      isT()方法能够被用来测试一个值是否是你确定的数据类型。toT()方法用来将QScriptValue转换成其他类型。当然你也可以用qscriptvalue_cast()方法.

Building PySide on Microsoft Windows

Prerequisites

• MS Visual Studio Express 2008 [microsoft.com]
  • NOTE: Visual Studio Express 2010 is not supported
• CMake [cmake.org]
• Git [code.google.com]
• Python 2.6 or 2.7 [python.org]

NOTE: Be sure that git.exe and cmake.exe are all in your PATH.

Build

• Open “Visual Studio Command Prompt”: [Start Menu]->Programs->Microsoft Visual C++ 2008 Express Edition->Visual Studio Tools

• Get build scripts from repository http://qt.gitorious.org/pyside/packaging and go to folder “c:\repositories\packaging\setuptools”. The script can automatically download the sources, compile them, and create the installer, all in one step.

• Run the build.py script (it must be run from “Visual Studio Command Prompt”):

• After the successful build, the final binary distribution can be found in sub-folder “dist”:
  1.   c:\repositories\packaging\setuptools\dist\PySide-1.0.4qt473.win32-py2.7.exe
  2.  

Categories:

• LanguageBindings
  • PySide

Necessitas是一个 用于Android平台的qt开发的实现。众所周知，Qt是诺基亚所有（最初由奇趣科技创建后由诺基亚收购）的一个跨平台的C++图形用户界面应用程序框架。它提供给应用程序开发者建立艺术级的图形用户界面所需的所用功能。Qt是完全面向对象的，很容易扩展，并且允许真正地组件编程。qt目前已经支持windows、linux、mac os x等平台，并且在智能手机操作系统领域，支持Windows Mobile,Symbian,Meego平台。然而，目前android平台已经成为智能手机领域举足轻重的平台，而android目前只支持java开发，可惜的是，对C++开发的支持十分有限并残缺的。

java开发的应用程序，由于运行在虚拟机上，采用同样的算法，与原生的C++代码相比，存在着一定的性能损失。后来谷歌公司意识到这一点，允许使用C++语言开发类库并被java程序调用，但并不能创建完整的GUI程序。因此，便有了将qt与android相结合的necessitas项目。

UGENE - Integrated Bioinformatics Tools

 

Home Documentation UGENE Manual Workflow Designer Query Designer YouTube Podcast Version History FAQ Community Forum Bug Tracker Source Code Downloads Latest Release Snapshots External Tools Support Contacts

News September 20, 2011 UGENE 1.9.7 is released August 23, 2011 UGENE 1.9.6 is released July 27, 2011 UGENE at the BOSC-2011 July 25, 2011 UGENE 1.9.5 and changes in the release cycle July 12, 2011 UGENE 1.9.4 is released July 6, 2011 UGENE on the Illumina iDEA 2011 Conference June 3, 2011 Workshop on UGENE was held in Novisibirsk State University May 23, 2011 UGENE 1.9.3 is released April 7, 2011 UGENE wins award in a contest devoted to GPU computations March 24, 2011 UGENE 1.9.2 is released March 15, 2011 UGENE bug-tracker is open for public February 7, 2011 UGENE 1.9.1 is released December 25, 2010 Development snapshots are available December 21, 2010 UGENE wins the Best Open Source Project contest December 17, 2010 What's new in UGENE 1.9 video December 15, 2010 UGENE 1.9.0 is released November 3, 2010 UGENE wins award at contest held by Intel and Rusnano

Unipro UGENE: Integrated Bioinformatics Tools UGENE is a free cross-platform genome analysis suite.  It works perfectly on Windows, Mac OS or Linux and requires only a few clicks to install. Features Screenshots    Swine flu in UGENE    Assembly Browser    Workflow Designer    Multiple alignment Integrated tools Multiple sequence alignment using MUSCLE 3, KAlign, Clustal; HMM profiles build and search, based on the source of HMMER 2 and HMMER 3; PCR Primers design using Primer 3; Cloning in silico capabilities; Queries to NCBI BLAST and CDD databases; Protein secondary structure prediction using GOR IV and PSIPRED; Phylogenetic analysis with Phylip; Search for restriction enzymes and integration with REBASE; Extremely fast repeat finder; DNA short reads to reference alignment using Bowtie; De novo assembly with CAP3; Search for transcription factor binding sites using SITECON; Protein back translation; ORF finder; Complete Smith-Waterman algorithm implementation; Support for external tools: BLAST+, MAFFT, T-Coffee; Assembly Browser — a shiny BAM viewer. User interface Visual and interactive genome browsing including circular plasmid view; Multiple alignment editor; Chromatograms visualization; 3D viewer for files in PDB and MMDB formats with anaglyph stereo mode support; Phylogenetic tree viewer; Dot plot visualization; Query designer enables search for complex annotation patterns; Easy to use workflow designer for custom computational workflows. High performance computing in UGENE Complete support of modern multicore processors and SSE instructions; Out of the box support of modern GPUs using NVIDIA CUDA and ATI Stream; Support for cloud computing: running computational tasks on Amazon EC2 cloud; Support for supercomputers and distributed computing. Cooperation Can be used for education purposes in schools and universities; Features to be included into the next release are initiated by users; UGENE team is ready for collaboration in related projects, both free or commercial. Availability Unipro UGENE is a free software distributed under the terms of GNU General Public License. Prebuilt version for set of operating systems can be foundhere. Contact us to learn more about alternative licensing terms.

 По-русски

UniPro, Russia, 2008–2011

• 想不出好的名字，还是继续用lighthouse这个名字吧，毕竟和Qt Lighthouse学习(二)内容相连。

注：本文内容基于现阶段的Qt5源码，等Qt5正式发布时，本文的内容可能不再适用了。 2011.09.11

QPA插件加载

Qt5所有的gui程序都将依赖一个 qpa 插件(QGuiApplication初始化时将会加载qpa插件)。

• 程序如何知道去哪儿找插件呢？
• 又如何知道加载哪一个插件呢？

路径

• 命令行参数：-platformpluginpath

• 环境变量： QT_QPA_PLATFORM_PLUGIN_PATH

• 常规插件路径(QCoreApplication::libraryPaths())下的platform子目录

  • 恩，常规路径很复杂，详见：Qt 插件路径(笔记)

  • QLibraryInfo::location(QLibraryInfo::PluginsPath)

    • 文件:/qt/etc/qt.conf中设置的路径
    • 环境变量：QT_PLUGIN_PATH
    • 编译Qt时生成的 src/corelib/global/config.cpp 中写死的路径
  • 可执行程序自身所在路径
  • 可执行程序路径下qt.conf设置的路径
  • 手动调用 QCoreApplication::addLibraryPath()设置的路径
  • 环境变量QT_QPA_PLATFORM_PLUGIN_PATH设置的路径以及-platformpluginpath指定的路径

插件名

• 命令行参数：-platform

• 环境变量：QT_QPA_PLATFORM

• 编译Qt源码时定义的宏：QT_QPA_DEFAULT_PLATFORM_NAME

• 默认插件名：
  • MAC 平台下的 “cocoa”
  • WIN 平台下的 “windows”
  • 其他 平台下 "xcb"

QWindow

QWidget和QApplication都从QtGui模块中移走了(移到了QtWidgets模块)。那么如何使用QtGui模块写一个最简单的界面呢？

需要使用 QWindow 和 QGuiApplication，一个简单的例子：

• widget.h

#ifndef WINDOW_H
#define WINDOW_H

#include <QtGui/QWindow>
class Window : public QWindow
{
    Q_OBJECT
public:
    Window(QWindow *parent = 0);
protected:
    void exposeEvent(QExposeEvent *);
    void resizeEvent(QResizeEvent *);
private:
    void render();
    QBackingStore *m_backingStore;
};
#endif // WINDOW_H

• window.cpp

#include "window.h"
#include <QtGui/QPainter>
#include <QtGui/QBackingStore>

Window::Window(QWindow *parent)
    : QWindow(parent)
{
    setGeometry(QRect(10, 10, 640, 480));
    m_backingStore = new QBackingStore(this);
}

void Window::exposeEvent(QExposeEvent *)
{
    render();
}

void Window::resizeEvent(QResizeEvent *)
{
    render();
}

void Window::render()
{
    QRect rect(QPoint(), geometry().size());
    m_backingStore->resize(rect.size());

    m_backingStore->beginPaint(rect);

    QPainter p(m_backingStore->paintDevice());
    p.drawRect(rect);

    m_backingStore->endPaint();
    m_backingStore->flush(rect);
}

• main.cpp

#include <QtGui/QGuiApplication>
#include "window.h"

int main(int argc, char *argv[])
{
    QGuiApplication a(argc, argv);
    Window w;
    w.show();

    return a.exec();
}

上一次关注Qt Lighthouse是在6月初，可是现在都8月底了。时间真快...

Lighthouse 是 QPA(Qt Platform Abstraction) 项目的名字，它使得将Qt移植到新的平台变得比较简单。尽管现在它已经完全融入到了Qt主干代码中，lighthouse作为独立项目已经不复存在了，但本文中，我们继续使用这个名字(虽然已不太恰当)。

QPA 抽象了什么？

不妨看看QPA前后，有何不同：

之前

考虑一下，传统的Qt是如何实现图形界面的夸平台：

• 针对不同的窗口系统(WS)定义相应的宏： Q_WS_*

Q_WS_X11
Q_WS_MAC
Q_WS_QWS
Q_WS_WIN
Q_WS_S60

• 代码中夹杂大量的编译预处理指令 (处理小段)

#if defined(Q_WS_X11)
...
#elif defined(Q_WS_MAC)
...
#elif defined(Q_WS_WIN)
...
#endif

• 各个窗口系统相关的代码文件 (处理大段)

qapplication_x11.cpp
qapplication_win.cpp
qapplication_s60.cpp
qapplication_mac.mm
qapplication_qws.cpp
...
qwidget_win.cpp
qwidget_qws.cpp
qwidget_mac.cpp
qwidget_x11.cpp
...

• src/gui/kernel.pri 等工程文件内，控制哪些文件参与编译

win32 {
...
}
symbian {
...
}
unix:x11 {
...
}

这一切这意味这什么？？

如果我们想在这个基础上支持一个新的窗口系统，比如wayland，需要

• 添加平台相关的宏，代码中针对该窗口再扩充 #if #elif #endif

• 添加平台相关的文件，扩充 **.pri 文件使其融入Qt
• ...

总之，需要对Qt的代码进行大量的修改。这一切使得将Qt移植到新的窗口系统中，变得不是那么容易。

之后

QPA 定义了一套接口，而后，将窗口系统相关的代码放到插件中：

• src/plugins/platforms/xlib/*
• src/plugins/platforms/wayland/*
• src/plugins/platforms/cocoa/*

这时，如果我们想支持一个新的窗口系统，怎么办？只需要编写一个新的插件，而Qt自身的代码则不需要任何改变。

(当然，编写插件本身还是很有难度的，哈...)

QPA源码结构

为了使插件能供工作，Qt中需要提供有相应的加载接口，在Qt源码中搜索*_qpa.h、*_qpa.cpp、 *_qpa_p.h 即可找到所有(fixme)和 qpa有关的代码：

• QTDIR/src/opengl
  • qgl_qpa.cpp
• QTDIR/src/gui
  • painting
    • qcolormap_qpa.cpp
    • qpaintdevice_qpa.cpp
  • image
    • qpixmap_qpa.cpp
  • egl
    • qegl_qpa.cpp
  • kernel
    • qplatformintegrationplugin_qpa.cpp
    • qplatformcursor_qpa.cpp
    • qwidget_qpa.cpp
    • ...
  • text
    • qfontengine_qpa.cpp
    • qfontengine_qpa_p.h
    • ...

可以看到代码集中在 gui/kernel 部分；除此外，和字体相关gui/text，和绘图相关gui/painting、gui/image、gui/egl，和opengl相关

QPA结构

QPlatformIntegration

这个应该算是 QPA 的核心了，

• 它是QApplication(准确地说是QApplicationPrivate)的成员

class Q_GUI_EXPORT QApplicationPrivate : public QCoreApplicationPrivate
{
...
    static QPlatformIntegration *platform_integration;
...

• 在初始化QAppliction时它会被创建

QApplication::QApplication()
  QApplicationPrivate::construct()
   qt_init()
     init_platform()
       QPlatfromIntegrationFactory::create()

• 它是所有窗口系统相关函数的入口点

class Q_GUI_EXPORT QPlatformIntegration
{
public:

这样一来：

QPlatformWindow 与 QWindowSurface

相对而言，QPlatformWindow 出现的比较晚一点(见Say hello to QPlatformWindow一文）之所以。之所以分离开来，原因见Remodelling the Lighthouse。

QPlatformScreen

• 代表屏幕(显示器)
• 它提供的api对应用程序来说是只读的
• 用来计算分辨率 dpi

class Q_GUI_EXPORT QPlatformScreen : public QObject
{
...
    virtual QRect geometry() const = 0;
    virtual QRect availableGeometry() const {return geometry();}
    virtual int depth() const = 0;
    virtual QImage::Format format() const = 0;
    virtual QSize physicalSize() const;

QPixmapData

为什么要有这个东西？

通常我们似乎都不怎么区分QImage和QPixmap，尽管在Manual中很大的篇幅在描述这二者的区别。

设计目的和用途(一个是IO和像素操作，一个是屏幕显示)：

• QImage is designed and optimized for I/O, and for direct pixel access and manipulation
• while QPixmap is designed and optimized for showing images on screen.

典型的用途：

• Typically, the QImage class is used to load an image file, optionally manipulating the image data, before the QImage object is converted into a QPixmap to be shown on screen.
• Alternatively, if no manipulation is desired, the image file can be loaded directly into a QPixmap.

与QImage不同，QPixmap 是平台相关的

• Note that the pixel data in a pixmap is internal and is managed by the underlying window system.

于是它的后端需要由各个窗口系统来提供也就不足为奇了。

QPlatformFontDatabase

提供字体信息

详见Fonts in Lighthouse一文。

其他

• QPlatformClipboard
• QPlatformCursor
• ...

同前面几个一样，从名字上容易看出是做什么的。

参考

• http://labs.qt.nokia.com/2010/04/06/remodelling-the-lighthouse/

• http://labs.qt.nokia.com/2010/04/21/say-hello-to-qplatformwindow/

• http://labs.qt.nokia.com/2010/09/02/fonts-in-lighthouse

• http://developer.qt.nokia.com/groups/qt_contributors_summit/wiki/Qt5ProductDefinition

• http://developer.qt.nokia.com/wiki/Qt_5.0

• http://developer.qt.nokia.com/wiki/Qt_Modules_Maturity_Level

• https://bugreports.qt.nokia.com/browse/QTBUG-20885

模态对话框就是指在子对话框弹出时，焦点被强行集中于该子对话框，子对话框不关闭，用户将无法操作其他的窗口。非模态相反，用户仍然可以操作其他的窗口，包括该子对话框的父对话框。

QPainter默认只能在paintEvent里面调用,但是:

在其他事件中绘制窗体，提示信息如下：
QPainter::begin: Paint device returned engine == 0, type: 1

绘制操作应该在paintEvent中完成.

有一个属性值，在构造函数中设置可以在paintEvent()之外进行绘制： 
this->setAttribute(Qt::WA_PaintOutsidePaintEvent); 

但是只支持X11，对于 Windows, Mac OS X or Embedded Linux。。。。不予支持

void xx::paintEvent(QPaintEvent *p)

{

  painter.begin(this);

  painter.drawImage(image);

  painter.end();

}

解决Qt系统托盘上下文菜单无法消失的问题

在Qt demo中可以找到Qt系统托盘的例子（Desktop -> System Tray）。

右击系统托盘，可以弹出上下文菜单。

然而在window下，弹出的菜单无法消失，必须点击菜单项或者应用程序窗体才会消失。

如图：

 

查阅Qt的BugReport，有相关记录。参见http://bugreports.qt.nokia.com/browse/QTBUG-7386?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel。

按照issue给出的方法，没有能够解决这个问题。

参照Qt帮助文档：

 

void QSystemTrayIcon::setContextMenu ( QMenu * menu )

发现有如下说明：

 

 Note: The system tray icon does not take ownership of the menu. You must ensure that it is deleted at the appropriate time by, for example, creating the menu with a suitable parent object.

 

注意到Qt demo中给出的示例是这样初始化上下文菜单的：

Cpp代码  

1. trayIconMenu = new QMenu(this);  

 也就是说，该上下文菜单的context是默认的应用程序窗体，然而文档中已经表述的非常清楚：

The system tray icon does not take ownership of the menu.

所以，当窗体获得焦点时，系统托盘的上下文菜单才会消失。换言之，如果该菜单的context是整个桌面的话，点击菜单之外的其他任何地方，菜单就会消失，这样我们的问题就解决了。

修改上文的初始化语句如下：

Cpp代码  

1. trayIconMenu = new QMenu(QApplication::desktop());  

至此，我们成功解决了这个问题。

其实Qt的文档中已经做出了说明，所以严格来说，这个bug并不是Qt本身的bug。

希望本文对同样被这个问题困扰的Qt程序员有所帮助。

 

 

• 查看图片附件

原创:

浅议Qt的事件处理机制 一

转帖：

cmake vs qmake

• qmake 是为 Qt 量身打造的，使用起来非常方便
• cmake 使用上不如qmake简单直接，但复杂换来的是强大的功能

  • 内置的 out-of source 构建。（目前QtCreator为qmake也默认启用了该功能，称：shadow build）

  • 为各种平台和场景提供条件编译

  • 可处理多个可执行文件情况，和很好配合 QtTest 工作

如何选择?

Using CMake to Build Qt Projects 一文中说：

• 对简单的Qt工程，采用 qmake
• 对复杂度超过 qmake 处理能力的，采用 cmake

尽管如此，如果简单Qt的工程都不知道怎么用 cmake 构建，复杂的工程，就更不知道如何使用 cmake 了。还是从简单的学起吧

简单的 Qt 程序

#include <QtCore/QCoreApplication>
#include <QtCore/QDebug>
int main(int argc, char** argv)
{
QCoreApplication app(argc, argv);
qDebug()<<"hello qt!";
app.exec();
}

如果不使用构建工具，直接调用编译器来编译的话，只需要类似这样的一条命令：

g++ main.cpp -Ie:/Qt/4.7.0/include -o main -Le:/Qt/4.7.0/lib -lQtCore4

指定头文件目录，以及需要链接的库

qmake

qmake 需要一个 .pro 文件:

CONFIG += qt
QT -= gui
SOURCES += main.cpp

• 因为我们需要 Qt的库和头文件，所以需要 CONFIG += qt 。

  • 这是默认项，可直接去掉该行
• 启用qt后，可以通过 QT -= gui 来进一步细调我们需要的模块
  • 默认是 core gui。我们不需要gui模块，故去掉。

cmake

cmake 需要一个 CMakeLists.txt 文件：

PROJECT(example)
FIND_PACKAGE(Qt4 REQUIRED)
SET(QT_DONT_USE_QTGUI TRUE)
INCLUDE(${QT_USE_FILE})
ADD_EXECUTABLE(example main.cpp)
TARGET_LINK_LIBRARIES(example ${QT_LIBRARIES})

• FIND_PACKAGE 来启用 Qt4
• 默认使用了core 和 gui，故手动禁用 QTGUI

  • 这两行可以直接使用 FIND_PACKAGE(Qt4 COMPONENTS QtCore REQUIRED)，未指定的模块将被禁用

• 包含一个CMake为Qt提供的配置文件，${QT_USE_FILE}变量是一个文件名
• 添加可执行程序目标
• 链接到 Qt 的库

复杂一点

考虑一个常规Qt程序：

• main.cpp
• mainwindows.ui
• mainwindows.h
• mainwindows.cpp

如果手动编译的话：

• mainwindow.ui 需要使用 uic 预处理

uic mainwindow.ui -o ui_mainwindow.h

• mainwindow.h 需要 moc 预处理

moc mainwindow.h -o moc_mainwindow.cpp

• 调用编译器进行编译

g++ main.cpp mainwindow.cpp moc_mainwindow.cpp -Ie:/Qt/4.7.0/include -o main -Le:/Qt/4.7.0/lib -lQtCore4 -lQtGui4

qmake

使用 qmake 的的话，一个简单的 pro 文件

TARGET = example
TEMPLATE = app
SOURCES += main.cpp mainwindow.cpp
HEADERS += mainwindow.h
FORMS += mainwindow.ui

HEADERS 中的文件是否需要 moc 进行预处理，qmake 运行时会根据其是否含有Q_OBJECT自动判断。

这也是为什么 很多人添加Q_OBJECT宏后不重新运行qmake会出错误的原因。

cmake

看看相应的 cmake 的 CMakeLists.txt 文件

PROJECT(example)
CMAKE_MINIMUM_REQUIRED(VERSION 2.6)
FIND_PACKAGE(Qt4 REQUIRED)
INCLUDE(${QT_USE_FILE})
INCLUDE_DIRECTORIES(${CMAKE_CURRENT_BINARY_DIR})
QT4_WRAP_CPP(example_MOCS mainwindow.h)
QT4_WRAP_UI(example_UIS mainwindow.ui)
ADD_EXECUTABLE(example main.cpp mainwindow.cpp ${example_MOCS})
TARGET_LINK_LIBRARIES(example ${QT_LIBRARIES})

• 需要 moc 的文件，用 QT4_WRAP_CPP 处理
  • 生成的文件放入变量 example_MOCS 中，最后一块链接到可执行程序
• 需要 uic 的文件，用 QT4_WRAP_UI 处理

Windows

因为windows下链接时分为 console 和 windows 两个子系统，所以windows下有些问题需要特殊处理。

用 qmake 时：

• 默认是 windows 子系统
• 可以通过 CONFIG += console 使用 console 子系统

用 cmake 是：

• 默认是 console 子系统
• 使用 windows 子系统需要

SET(QT_USE_QTMAIN TRUE)
ADD_EXECUTABLE(example WIN32 main.cpp mainwindow.cpp ${example_MOCS})

前者启用 qtmain.lib 库来提供windows下的 WinMain 入口函数。后者链接 windows 子系统

再复杂一点

• main.cpp
• mainwindows.ui
• mainwindows.h
• mainwindows.cpp
• main.qrc
• main.rc

前面已经用到了Qt的 moc 和 uic，这次增加了资源系统 需要用 rcc

rcc main.qrc -o qrc_main.cpp

同时，使用了windows下的资源文件 .rc (比如给程序添加图标)

• MVSC 中使用 rc.exe 对 .rc 文件进行处理
• MinGW 中使用 windres.exe 处理 .rc 文件

qmake

TARGET = example
TEMPLATE = lib
HEADERS = mainwindow.h widget.h
SOURCES = main.cpp widget.cpp mainwindow.cpp
RESOURCES = main.qrc
RC_FILE = main.rc

cmake

PROJECT(example)
CMAKE_MINIMUM_REQUIRED(VERSION 2.6)
FIND_PACKAGE(Qt4 REQUIRED)
SET(QT_USE_QTMAIN TRUE)
INCLUDE(${QT_USE_FILE})
INCLUDE_DIRECTORIES(${CMAKE_CURRENT_BINARY_DIR})

if(MINGW)
set(CMAKE_RC_COMPILER_INIT windres)
ENABLE_LANGUAGE(RC)
SET(CMAKE_RC_COMPILE_OBJECT
"<CMAKE_RC_COMPILER> <FLAGS> -O coff <DEFINES> -i <SOURCE> -o <OBJECT>")
endif(MINGW)

SET(example_SRCS main.cpp mainwindow.cpp widget.cpp res/main.rc)
SET(example_MOC_SRCS mainwindow.h widget.h)
QT4_WRAP_CPP(example_MOCS ${example_MOC_SRCS})
QT4_ADD_RESOURCES(example_RCC_SRCS main.qrc)
SET(example_SRCS ${example_SRCS} ${example_MOCS} ${example_RCC_SRCS})

ADD_EXECUTABLE(example WIN32 main.cpp mainwindow.cpp ${example_SRCS})
TARGET_LINK_LIBRARIES(example ${QT_LIBRARIES})

• 对Qt的资源文件，使用 QT4_ADD_RESOURCES 来调用rcc进行预处理
• 对 Windows 资源文件，直接和源文件一样，添加到列表中即可。只是：
  • MinGW 下仅仅这么做还不行，上面的 MinGW 块用来修复这个问题

Debug 与 Release

qmake

使用 qmake 时，可以在 pro 文件内分别为两种模式设置不同的选项。

使用时，可以直接 make release 或 make debug 来编译不同的版本

cmake

不同于 qmake，由于 cmake 采用 out-of-source 方式。故：

• 建立debug release两目录，分别在其中执行cmake -DCMAKE_BUILD_TYPE=Debug（或Release）
• 需要编译不同版本时进入不同目录执行make

对生成 msvc 工程的情况, CMAKE_BUILD_TYPE 不起作用。生成工程后使用IDE自带的模式选择。

Qt在线文档

http://doc.qt.nokia.com/4.7/

Qt e-Learning

http://qt.nokia.com/developer/learning/elearning

http://wikis.in.nokia.com/QtSoftware/LearnQt

http://www.ics.com/learning/icsnetwork/

官方Qt移动开发社区、资源、Wiki

Getting started with Git and GitHub

Nokia Forum projects

http://forum.nokia.com

http://forum.nokia.com.cn/ 

http://wiki.forum.nokia.com/index.php/Qt_%E5%BC%80%E5%8F%91

官方Qt论坛

http://developer.qt.nokia.com/forums

Qt for Symbian 开发资源

http://discussion.forum.nokia.com/forum/showthread.php?162323-Qt-for-Symbian-development-resources

中文Qt网站

http://qt.csdn.net

诺基亚论坛上的Qt for Symbian中文论坛

http://www.qtcn.org

www.qteverywhere.com

中文文档

http://forum.nokia.com.cn/document_1.html

http://qtdocs.sourceforge.net/index.php/%E5%88%86%E7%B1%BB:Qt_%E5%8F%82%E8%80%83%E6%89%8B%E5%86%8C

其他

如果在开发中遇到了技术细节上的问题，相信再下面两个论坛搜索相关关键字会比直接在baidu/google上搜强很多

http://lists.trolltech.com/qt-interest/

Qt在SlideShare的幻灯片

http://www.slideshare.net/tag/qt

非官方的优秀Qt论坛

http://www.qtcentre.org/forum/

请尊重原创作品和译文。转载请保持文章完整性，并以超链接形式注明原始作者地址http://blog.csdn.net/changsheng230，方便其他朋友提问和指正。

在Qt/Qt Quick宏浅议一文中，我们将介绍Qt中经常使用的几个宏： Q_OBJECT, SIGNAL与SLOT, Q_SIGNALS 与 Q_SLOTS, Q_EMIT ,Q_INVOKABLE, Q_PROPERTY。相比其他宏，Q_INVOKABLE 显得更加神秘，但Q_INVOKABLE的理解与使用变得越来越重要。本文将围绕Q_INVOKABLE以及相对应的invokeMethod展开讨论。

Q_INVOKABLE

#define Q_INVOKABLE

重新回顾一下Q_INVOKABLE的定义，它在$QTDIR/src/corelib/kernel/qobjectdefs.h 中，简单被define，目的在于让moc识别。

使用Q_INVOKABLE来修饰成员函数，目的在于被修饰的成员函数能够被元对象系统所唤起。

QMetaObject::invokeMethod

静态方法QMetaObject::invokeMethod() 的定义如下：

 

view plain
1. bool QMetaObject::invokeMethod ( QObject * obj, const char * member,Qt::ConnectionType type,  
2. QGenericReturnArgument ret, QGenericArgument val0 = QGenericArgument( 0 ), …)  
 

 

 

invokeMethod的用法为，尝试调用对象obj的方法member（注意member可以为信号或者是槽)，如何member可以被调用，则返回真，否则返回假。QMetaObject::invokeMethod可以是异步调用，也可以是同步调用。这取决与它的连接方式Qt::ConnectionType type。如果type为Qt::DirectConnection，则为同步调用，若为Qt::QueuedConnection，则为异步调用。例如：

 

view plain
1. QMetaObject::invokeMethod(object, "methodName",   
2. Qt::QueuedConnection,   
3. Q_ARG(type1, arg1),   
4. Q_ARG(type2, arg2));  
 

 

上述调用为异步调用。请注意，因为上面所示的参数需要被在构建事件时进行硬拷贝，参数的自定义型别所对应的类需要提供一个共有的构造函数、析构函数以及拷贝构造函数。而且必须使用注册Qt型别系统所提供的qRegisterMetaType() 方法来注册这一自定义型别。

Q_INVOKABLE与QMetaObject::invokeMethod均由元对象系统唤起。这一机制在Qt C++/QML混合编程，跨线程编程，Qt Service Framework 以及 Qt/ HTML5混合编程以及里广泛使用。

Qt C++/QML混合编程

QML中调用C++方法借助了Qt元对象系统。考虑在QML中使用Qt C++定义的方法，如下代码所示：

为了让上述QML代码成功的调用下面这段代码定义的randomColor()函数，最为关键的一点见randomColor方法用Q_INVOKABLE 修饰。

更多细节，请参看我的另一篇博文：QML与C++混合编程使用

在跨线程编程中的使用

我们如何调用驻足在其他线程里的QObject方法呢？Qt提供了一种非常友好而且干净的解决方案：向事件队列post一个事件，事件的处理将以调用我们所感兴趣的方法为主（当然这需要线程有一个正在运行的事件循环）。而触发机制的实现是由moc提供的内省方法实现的。因此，只有信号、槽以及被标记成Q_INVOKABLE的方法才能够被其它线程所触发调用。如果你不想通过跨线程的信号、槽这一方法来实现调用驻足在其他线程里的QObject方法。另一选择就是将方法声明为Q_INVOKABLE，并且在另一线程中用invokeMethod唤起。

更多细节，译文事件循环与线程

Qt Service Framework

Qt服务框架是Qt Mobility 1.0.2版本推出的，一个服务（service）是一个独立的组件提供给客户端（client）定义好的操作。客户端可以通过服务的名称，版本号和服务的对象提供的接口来查找服务。 查找到服务后，框架启动服务并返回一个指针。

服务通过插件（plug-ins）来实现。为了避免客户端依赖某个具体的库，服务必须继承自QObject。这样QMetaObject 系统可以用来提供动态发现和唤醒服务的能力。要使QmetaObject机制充分的工作，服务必须满足，其所有的方法都是通过 signal，slot，property 或invokable method和Q_INVOKEBLE来实现

其中，最常见的与servicer交互的方法如下：

view plain
QServiceManager manager;QObject *storage ;  
storage = manager.loadInterface("com.nokia.qt.examples.FileStorage"); if (storage)     QMetaObject::invokeMethod(storage, "deleteFile", Q_ARG(QString, "/tmp/readme.txt"));  

上面的代码通过service的元对象提供的invokeMethod方法，调用文件存储对象的deleteFile() 方法。客户端不需要知道对象的类型，因此也没有链接到具体的service库。  当然在服务端的deleteFile方法，一定要被标记为Q_INVOKEBLE，才能够被元对象系统识别

Qt服务框架的一个亮点是它支持跨进程通信，服务可以接受远程进程。在服务管理器上注册后 进程通过signal，slot，invokable method和property来通信，就像本地对象一样。服务可以设定为在客户端间共享，或针对一个客户端。  请注意，在Qt服务框架推出之前，信号、槽以及invokable method仅支持跨线程。 下图是跨进成的服务/客户段通信示意图（图片来自诺基亚论坛）。这里我们可以清楚的看到，invokable method和Q_INVOKEBLE 是跨进城、跨线程对象之间通信的重要利器。

有关Qt Service Framework的更多讨论和用例，请参见Qt Service Framework文档

请尊重原创作品和译文。转载请保持文章完整性，并以超链接形式注明原始作者地址http://blog.csdn.net/changsheng230，方便其他朋友提问和指正。

刚开始接触Qt的朋友可能对Qt在使用当中需要声明的各色各样的宏感到神秘而又陌生，本文将介绍Qt中经常使用的几个宏： Q_OBJECT, SIGNAL与SLOT, Q_SIGNALS 与 Q_SLOTS, Q_EMIT ,Q_INVOKABLE, Q_PROPERTY：

宏的头文件出处： $QTDIR/src/corelib/kernel/qobjectdefs.h

Q_OBJECT

#define Q_OBJECT / 
public: / 
    Q_OBJECT_CHECK / 
    static const QMetaObject staticMetaObject; / 
    Q_OBJECT_GETSTATICMETAOBJECT / 
    virtual const QMetaObject *metaObject() const; / 
    virtual void *qt_metacast(const char *); / 
    QT_TR_FUNCTIONS / 
    virtual int qt_metacall(QMetaObject::Call, int, void **); /

宏Q_OBJECT是Qt所有宏中最为重要的一个，Q_OBJECT是使用信号槽机制以及其他所有元对象系统提供的服务（内省、invokeMethod，元对象property系统等等）的前提条件。有关Q_OBJECT的讨论请参考Qt源码分析之QObject。 

SIGNAL与SLOT

这两个宏是调用connect方法时用到:

那么宏SIGNAL和SLOT为我们做了那些事情呢，看一下源代码：

原来它会基于把我们定义的信号、槽的名称返回一个字符串，比如SIGNAL(clicked()) 返回字符串 “2clicked()”, SLOT(showText())返回字符串“1showText()”

Q_SIGNALS 与 Q_SLOTS是Qt 4.1引入的，它们用来替换关键字signals和slots，原因是更好的与第三方信号槽机制兼容，比如boost库。尽管Q_SIGNALS 与 Q_SLOTS看起来没有做什么。其实不然，QT的元对象编译器moc会识别声明在头文件中的宏Q_SIGNALS，Q_SLOTS。并做为依据，生成元对象模型数据，详见文中最后所示代码实例

Q_EMIT

#define Q_EMIT #define emit

Q_EMIT用来替换关键字emit,原因也是更好的与第三方信号槽机制兼容，比如boost库。

这里要注意，我们看到Q_EMIT看起来同样的简单， 但它们是有区别的！表面的区别在于Q_SIGNALS 与 Q_SLOTS用在头文件中，而Q_EMIT用在代码视线中。 本质的区别的在于，Q_SIGNALS 与 Q_SLOTS将被moc识别，是必须使用的。而Q_EMIT或者emit是可有可无的。它不会被moc识别，它存在的唯一理由是：增加代码的可读性。  也就是说如下代码都能正常工作，但2）的写法也许会惹怒你的同事。

Q_INVOKABLE

#define Q_INVOKABLE

使用Q_INVOKABLE来修饰成员函数，目的在于被修饰的成员函数能够被元对象系统所唤起。这一机制在Qt C++/QML混合编程，Qt service framework, 以及Qt/ HTML5混合编程里广泛使用。我会随后另撰写一文做深入探讨。

Q_PROPERTY

#define Q_PROPERTY(text)   

使用Q_PROPERTY用以声明属性，属性类似于成员变量，但它能够被元对象系统所访问。QML的属性便是利用该机制得以实现的。 Q_PROPERTY的用法如下：

Q_PROPERTY(QString title READ title WRITE setTitle USER true)

接下来，让我们结合代码来看一下上述宏的使用以及元对象编译器是如何利用这些宏的。

以下代码由元对象编译器moc根据上述头文件自动生成：

从上面代码实例我们可以看到， QT的元对象编译器moc会识别声明在头文件中的宏Q_SIGNALS，Q_SLOTS, Q_PROPERTY, Q_PROPERTY。并以此做为依据，生成了元对象数据表。在这张元对象数据表中，我们已可以看到，moc根据头文件所声明的宏定义，识别出:

• 两个信号：colorChanged(), ready();      (Q_SIGNALS）
• 两个槽:    try1(), try2()                          (Q_SLOTS)
• 五个方法，其中被标记为Q_INVOKABLE的方法randomColor()被记录在元对象字符串数组qt_meta_stringdata_EllipseItem中。  
• 一个属性：color   (Q_PROPERTY)

本文介绍的是Qt 内省机制，关于内省，新手的原因，我们一块学习，所谓内省是指面向对象语言的一种在运行期间查询对象信息的能力， 比如如果该语具有运行期间检查对象型别的能力，那么我们称它是型别内省（type intropection）的，型别内省可以用来实施多态。

c++的内省比较有限，它仅支持上面所说的型别内省， C++的型别内省是通过运行时类型识别（RTTI）(Run-Time Type Information)中的typeid 以及 dynamic_case关键字来实现的，举例说明：

    // rabbit 派生于 Animal, jump为虚函数  
 
if ( rabbit *p = dynamic_case<Animal*>(obj))     
{     
   p->jump();     
}     
//我们还可以通过typeid萃取到对象的型别信息，比如对象的名称   
std::cout << typeid(obj).name() << std::endl   

Qt拓展了C++的内省机制，（实际上，它并没有采用c++的RTTI),而是提供了更为强大的元对象(meta object)机制，来实现内省。接下来，就让我们看看，Qt是如何扩展c++内省机制的。

要深刻理解Qt的内省机制，首先理解QObject，QObject类是整个Qt对象模型的心脏，Qt对象模型最为核心的功能是提供一种无缝的对象通讯机制，即就是我们所熟知的信号和槽。QObject主要有三大职责： 内存管理、内省(intropection)与事件处理。本文将集中在在内省的讨论。以下代码介绍了QObject类提供的内省方法:

//每个对象可以通过QObject::setObjectName()和QObject::objectName()设置、取得类的实例的名字   
FirstQtApp obj;    
obj.setObjectName("instanceName");    
QString name1 = obj.objectName();   // return instanceName   
//每个对象还可以通过它的元对象className方法得到类的名字   
QString name2 = obj.metaObject()->className();  // return FirtstQtApp   
//每个对象可以通过QObject::inherits方法来查询是否对前对象类派生于量一个类   
bool isherited =  obj.inherits("QObject");         // returns true   
isherited =  obj.inherits("QWideget");         // returns true  

让我们再来一下QObject::inherits方法的底层实现：

inline bool inherits(const char *classname) const   
    { return const_cast<QObject *>(this)->qt_metacast(classname) != 0; }  

原来，QObject::inherits是通过qt_metacast()这个虚函数实现的， 事实上每个QObject的派生类都必须实现metaObject()以及其他qt_metacall()方法，从而满足自省方法className, inherits等方法的调用（当然还有其他用途）。

而所有有关派生从QObject的子类中的内省方法无须有用户实现，用户只要在类中声明宏Q_OBJECT即可，Qt的元对象编译器（moc)负责实现派生从QObject的子类中的内省方法。

// defined at ..\Qt\src\corelib\kernel\qobjectdefs.h   
/* tmake ignore Q_OBJECT */   
#define Q_OBJECT \   
public: \     
    Q_OBJECT_CHECK \     
static const QMetaObject staticMetaObject; \     
    Q_OBJECT_GETSTATICMETAOBJECT \     
virtual const QMetaObject *metaObject() const; \     
virtual void *qt_metacast(const char *); \     
    QT_TR_FUNCTIONS \     
virtual int qt_metacall(QMetaObject::Call, int, void **); \  

此外，所有的Qt widgets类均继承自QObject, QObject所提供的isWidgetType自省方法可以很方便让QObject子对象查询自己是否是wideget, 而且它会比 qobject_cast<QWidget *>(obj) 或者 obj->inherits快很多。原因qobject_cast()t和inherits()都是借助元对象系统来实现其功能的，isWidgetType()是QObject本身的标志位得以实现。

更多自省方法定义在QMetaObject，以下是QMetaObject声明的源代码：

struct Q_CORE_EXPORT QMetaObject     
{     
const char *className() const;     
const QMetaObject *superClass() const;     
    QObject *cast(QObject *obj) const;     
 
    ....     
int methodOffset() const;     
int enumeratorOffset() const;     
int propertyOffset() const;     
int classInfoOffset() const;     
int constructorCount() const;     
int methodCount() const;     
int enumeratorCount() const;     
int propertyCount() const;     
int classInfoCount() const;     
int indexOfConstructor(const char *constructor) const;     
int indexOfMethod(const char *method) const;     
int indexOfSignal(const char *signal) const;     
int indexOfSlot(const char *slot) const;     
int indexOfEnumerator(const char *name) const;     
int indexOfProperty(const char *name) const;     
int indexOfClassInfo(const char *name) const;     
    ...     
}   

上述方法主要是实现对元对象表的访问及其操作，对元对象表(由moc实现）实例如下所示：

// defined at ..\Qt\src\corelib\kernel\qobjectdefs.h   
/* tmake ignore Q_OBJECT */   
#define Q_OBJECT \   
public: \    
    Q_OBJECT_CHECK \    
static const QMetaObject staticMetaObject; \    
    Q_OBJECT_GETSTATICMETAOBJECT \    
virtual const QMetaObject *metaObject() const; \    
virtual void *qt_metacast(const char *); \    
    QT_TR_FUNCTIONS \    
virtual int qt_metacall(QMetaObject::Call, int, void **); \   

总结：

1、Qt是通过QObject、QMetaObject类实现其内省机制,

2、QObject暴露给用户的共有自省方法有objectName(), inherits()， isWidgetType()等

3、大多数自省方法是QObject派发给QMetaObject实现 (e.g. QMetaObject::className,)，元对象模型编译器moc负责自省方法的实现

4、更多自省方法定义在QMetaObject，而是为了等信号槽通讯、事件派发等机制，

小结：关于解析 Qt 内省机制剖析的内容介绍完了，希望本文对你有所帮助！

 int main(int argc, char *argv[])

 {

 QApplication app(argc, argv);

 QDeclarativeView view;

 view.rootContext()->setContextProperty("ls",new LS);

 view.setSource(QUrl::fromLocalFile("../QMLAPP/QMLtest.qml"));

 view.show();

 return app.exec();

 }

#define LS_H

#include <QObject>

#include <QColor>

class LS : public QObject

{

 Q_OBJECT

 Q_PROPERTY(QColor color READ getColor WRITE setColor NOTIFY colorChange)

public:

 LS(QObject *parent = 0);

 ~LS();

 // Q_INVOKABLE 用于导出函数，让qml能使用

 Q_INVOKABLE QString getText(void) const;

 // 用于属性

 QColor getColor(void) const;

 void setColor(const QColor &c);

signals:

 void sendMsg(const QString &s);

 // 用于属性

 void colorChange(void);

public slots:

 void echoMsg(const QString &s);

private:

 QString m_str;

 QColor m_Color;

};

#endif // LS_H

//LS.cpp

 LS::LS(QObject *parent)

 :QObject(parent),m_str("I am LS class"),m_Color(Qt::blue)

 {

 QObject::connect(this, SIGNAL(sendMsg(QString)), this, SLOT(echoMsg(QString)));

 }

 LS::~LS(){}

 QString LS::getText(void) const

 {

 return m_str;

 }

 // 用于属性

 QColor LS::getColor(void) const

 {

 return m_Color;

 }

 void LS::setColor(const QColor &c)

 {

 m_Color = c;

 }

 void LS::echoMsg(const QString &s)

 {

 qDebug(" %s ", s.toLocal8Bit().data());

 }

//----------------------------------------------------------------------
// QMLtest.qml
Rectangle{
 id: mainrect
 width: 400; height: 300;
 color: ls.color;
 Text {
 id: tls;
 text: "click this"
 }

 MouseArea{
 anchors.fill: parent;
 onClicked: {
 tls.text = ls.getText();
 ls.sendMsg(" ok ");
 }
 }

}

1.  Qt 全局宏定义

Qt版本号:

 QT_VERSION :　 (major << 16) + (minor << 8) + patch

检测版本号：

QT_VERSION_CHECK(major, minor, patch)((major<<16)|(minor<<8)|(patch))

当使用命名空间时的一些宏定义：

namespace QT_NAMESPACE {}　//命名空间定义

# define QT_PREPEND_NAMESPACE(name) ::QT_NAMESPACE::name

# define QT_USE_NAMESPACE using namespace ::QT_NAMESPACE;

# define QT_BEGIN_NAMESPACE namespace QT_NAMESPACE {

# define QT_END_NAMESPACE }

# define QT_BEGIN_INCLUDE_NAMESPACE }

# define QT_END_INCLUDE_NAMESPACE namespace QT_NAMESPACE {

# define QT_BEGIN_MOC_NAMESPACE QT_USE_NAMESPACE

# define QT_END_MOC_NAMESPACE

# define QT_FORWARD_DECLARE_CLASS(name) /

    QT_BEGIN_NAMESPACE class name; QT_END_NAMESPACE /

    using QT_PREPEND_NAMESPACE(name);

# define QT_FORWARD_DECLARE_STRUCT(name) /

    QT_BEGIN_NAMESPACE struct name; QT_END_NAMESPACE /

    using QT_PREPEND_NAMESPACE(name);

Q_GLOBAL_STATIC(type, name)用于定义一个全局的静态变量（线程安全的）．用它来初始化一个对象指针（函数指针）．

Q_GLOBAL_STATIC_WITH_ARGS(type, name, arguments)：同上，可带参数．

Q_UNUSED（）:通常用于某个函数的参数，表明该参数未在方法体中使用．

常用数据类型：

qint8, quint8, qint16, quint16, qint32, quint32, qint64, quint64, qlonglong(=int64), qulonglong(=uint64)

quintptr, qptrdiff, 作为指针是一样大的．如：

      sizeof(void *) == sizeof(quintptr)

      && sizeof(void *) == sizeof(qptrdiff)

Qt有用的类型定义：uchar, ushort, uint, ulong

实用内联函数：qAbs(), qRound(), qRound64(), qMin(), qMax(), qBound();

try-catch宏：

#ifdef QT_NO_EXCEPTIONS

#  define QT_TRY if (true)

#  define QT_CATCH(A) else

#  define QT_THROW(A) qt_noop()

#  define QT_RETHROW qt_noop()

#else

#  define QT_TRY try

#  define QT_CATCH(A) catch (A)

#  define QT_THROW(A) throw A

#  define QT_RETHROW throw

#endif

每个QT_TRY对应一个ＱT_CATCH，不要在catch语句块中使用异常实例．

调试相关函数：

qDebug(), qWarnig(), qCritical(), Q_ASSERT()

其他一些函数：

该宏用于定义某个类，禁止拷贝

#define Q_DISABLE_COPY(Class) /

    Class(const Class &); /

    Class &operator=(const Class &);

qgetenv(), qputenv(), qIntCast(double 或float). qsrand(uint seed), qrand()

2. Qt的内存管理函数

void *qMalloc(size_t size);

void qFree(void *ptr);

void *qRealloc(void *ptr, size_t size);

void *qMallocAligned(size_t size, size_t alignment)

void *qReallocAligned(void *oldptr, size_t newsize, size_t oldsize, size_t alignment)

void qFreeAligned(void *ptr)

void *qMemCopy(void *dest, const void *src, size_t n);

void *qMemSet(void *dest, int c, size_t n);

注: 数组下标为-1的地址对于数组来说是越界访问了，但是这个地址是有意义的.这个地址就是所申请的数组存储空间的首地址的向前偏移一个单位(也就是偏移一个当前数组类型所对应的字节数)所对应的地址。这个地址由于没有跟着数组空间一起初始化，所以其中的数据是不确定的.如果是正在被系统或者其他应用程序使用中的地址空间，那么可以被访问，其中的数据的意义取决于被系统或者其他应用程序所写入的数据，但是访问后，有可能会引起系统或者其他应用程序异常。如果是没有被使用的地址，那么就是一个野地址，那么其中的数据是随机的，无意义的

３.　环境变量设置函数

qputenv()：与putenv()基本类似，由于VC2005后废除了putenv()函数，所有定义了此函数，在VC环境中调用替代的函数，其他平台调用标准Ｃ库函数putenv()．

qgetenv():获取某个环境变量的值．

４.自定义输出函数

QtMsgHandler qInstallMsgHandler(QtMsgHandler h)

其中：typedef void (*QtMsgHandler)(QtMsgType, const char *);

利用该函数可定制自己的调试信息输出．

5. 断言

Q_ASSERT(bool test)：当断言失败时，打印出警告信息，包含了源码文件名和行号．

void Q_ASSERT_X(bool test, const char *where, const char *what)

void Q_CHECK_PTR(void *pointer)：检测非法指针，如果指针为０，打印警告信息．

６.系统信息类QsysInfo