void testMessagePattern() {

    QString QT_MESSAGE_PATTERN=

            "[%{if-debug}D%{endif}%{if-warning}W%{endif}%{if-critical}C%{endif}%{if-fatal}F%{endif}]"

            ": %{file}:%{line} - %{message}";

    qSetMessagePattern(QT_MESSAGE_PATTERN);

    qDebug() << "Hello Pattern";

    qDebug() << QString("黄彪").toUtf8().toHex();

}

[D]: /Users/Biao/Dropbox/workspace/Qt/Test/main.cpp:26 - Hello Pattern 
[D]: /Users/Biao/Dropbox/workspace/Qt/Test/main.cpp:28 - "e9bb84e5bdaa" 

void qSetMessagePattern(const QString & pattern)
Changes the output of the default message handler.
Allows to tweak the output of qDebug(), qWarning(), qCritical() and qFatal().
Following placeholders are supported:

    

        

            
Placeholder
Description
        
    
    

        

            
%{appname}
            
QCoreApplication::applicationName()
        
        

            
%{file}
            
Path to source file
        
        

            
%{function}
            
Function
        
        

            
%{line}
            
Line in source file
        
        

            
%{message}
            
The actual message
        
        

            
%{pid}
            
QCoreApplication::applicationPid()
        
        

            
%{threadid}
            
ID of current thread
        
        

            
%{type}
            
"debug", "warning", "critical" or "fatal"
        
    

You can also use conditionals on the type of the message using %{if-debug}, %{if-warning}, %{if-critical} or %{if-fatal} followed by an %{endif}. What is inside the%{if-*} and %{endif} will only be printed if the type matches.
Example:
QT_MESSAGE_PATTERN="[%{if-debug}D%{endif}%{if-warning}W%{endif}%{if-critical}C%{endif}%{if-fatal}F%{endif}] %{file}:%{line} - %{message}"
The default pattern is "%{message}".
The pattern can also be changed at runtime by setting the QT_MESSAGE_PATTERN environment variable; if both qSetMessagePattern() is called and QT_MESSAGE_PATTERN is set, the environment variable takes precedence.
qSetMessagePattern() has no effect if a custom message handler is installed.
This function was introduced in QtCore 5.0.
See also qInstallMessageHandler() and Debugging Techniques.

Adding a Q_DECLARE_METATYPE() makes the type known to all template based functions, including QVariant.

Note that if you intend to use the type in queued signal and slot connections or in QObject's property system,

you also have to call qRegisterMetaType() since the names are resolved at runtime.

class BH {

public:

    BH() {

        value = 10;

    }

    int value;

};

Q_DECLARE_METATYPE(BH)

QVariant var = QVariant::fromValue(bh);

qDebug() << var.canConvert<BH>();

BH bh2 = var.value<BH>();

qDebug() << bh2.value;

最近做项目遇到的问题，总结下。

有时候我们觉得系统的标题栏和按钮太丑太呆板，想做自己的标题栏以及最大化、最小化、关闭，菜单按钮，我们就需要 

有两种方案处理这种情况：

1.自己对mouseMoveEvent,mousePressEvent,mouseReleaseEvent 等事件进行处理。

2.Qt可以处理windows的消息。大家重新实现bool winEvent(MSG *message, long *result);(在此又一次感觉Qt的NB)

我刚开始使用第一种方法去实现的。移动窗口很容易做，大家可以去看看这个大大写的，比网上其他版本问题少些。

http://blog.csdn.net/aqtata/article/details/8902889

在窗口边缘按下鼠标拖动改变窗口大小就比较麻烦了。

我是这样做的：

在mousePressEvent 按下设置m_bPressed为真。

在mouseMoveEvent中m_bPressed为真且event->x() 在窗口边缘 及处理算出鼠标移动的增量 然后不断resize窗口。

至于如何为边缘的断定，就自己设定一个 差值 假如 在窗口边缘 ±4个px 就算在在该边缘就处理该resize。

这样做缺点很多，1.拖快了不行，很容易超过该差值 ， 2.窗口抖动的厉害，一直在resize，3.要处理太多情况

鉴于上诉缺点于是乎就到处问人百度google。有了第二种方法：

第二种方法很好用，效果和有标题边框程序一样~~~

Qt居然可以处理windows消息。。

这里我们要重新实现winEvent ( MSG * message, long * result ) 

该虚函数在QWidget和QWizard以及QSizeGrip以及他们的子类中都可以实现。

如果你想停止Qt处理消息就返回true，并且设置result到你想要保存的值返回给window处理。否者的话返回false。

这里我们主要想处理WM_NCHITTEST消息。

The WM_NCHITTEST message is sent to a window in order to determine what part of the window corresponds to a particular screen coordinate. This can happen, for example, when the cursor moves, when a mouse button is pressed or released, or in response to a call to a function such as WindowFromPoint. If the mouse is not captured, the message is sent to the window beneath the cursor. Otherwise, the message is sent to the window that has captured the mouse.

A window receives this message through its WindowProc function. 

知道这个就好了，我们还是要判断下鼠标的位置，然后通过该位置保存到result给window处理。

其实就是我们的程序没有边框不能发送这些消息，我们把它告诉windows，然后windows帮我们处理拖动，改变大小等效果。所以效果和有边框有标题程序效果一样的。

头文件申明：

把各种边界情况保存到result给windows处理，我们就省去很多事情，我想windows肯定比我们自己实现的效果要好多了。

因为

我做了边框阴影。阴影边框设定为20px所以在

Using a third-party library with Qt is a simple process. Suppose you know of a cross-platform library that accepts audio samples of a cat's meows and translates them into English words. This library is named CatWhisperer, and has several files that it provides as part of its library. Your project, MyQtApp, stores these files in a folder named 3rdparty:

• MyQtApp/
  • MyQtApp.pro
  • src/
    • main.cpp
  • 3rdparty/
    • CatWhisperer
      • include/
        • CatWhisperer.h
      • lib/
        • libCatWhisperer.so
        • CatWhisperer.lib
      • bin/
        • CatWhisperer.dll

To use the CatWhisperer library in MyQtApp, qmake requires the location and names of the CatWhisperer libraries. Optionally, you can also:

• Provide the location of the CatWhisperer source code so that you don't have to type out the full path to each file when you include them in your own code.
• Choose the destination in which the MyQtApp executable will be created.

The information above is provided in the .pro file, so that qmake can parse it and produce makefiles. Makefiles contain all the information needed by your compiler and linker to produce output, whether it is an executable, another library file, etc. The next sections explain the syntax with which qmakeexpects you to provide this information.

Source code

To be able to write

#include <CatWhisperer.h>

instead of

#include <3rdparty/CatWhisperer/include/CatWhisperer.h>

you can provide the path to the CatWhisperer include directory, using the INCLUDEPATH variable:

INCLUDEPATH += 3rdparty/CatWhisperer/include

Library files

To let qmake know where to find the CatWhisperer library files, use the LIBS variable:

LIBS += -L"3rdparty/CatWhisperer/lib" -lCatWhisperer

The first part of the expression lets the linker know in which directory it should look for the library files. The double quotes are only necessary when the path contains spaces, so we could have omitted them in this example.

The second part tells the linker which libraries to link against. We have two different library files for UNIX platforms and Windows, respectively:libCatWhisperer.so and CatWhisperer.lib. It is not necessary to specify the .lib extension, nor the lib prefix (on UNIX platforms).

Destination directory

By default, qmake creates the executable in the same directory as the .pro file. We can choose our own directory using the DESTDIR variable:

DESTDIR = bin

That's it! You can now use the CatWhisperer library in your project. The final .pro file looks like this:

TARGET = MyQtApp
TEMPLATE = app
INCLUDEPATH += 3rdparty/CatWhisperer/include
SOURCES += src/main.cpp
LIBS += -L"3rdparty/CatWhisperer/lib" -lCatWhisperer

See also qmake Manual and Adding Libraries to Projects.

QFontDatabase的构造函数中会调用createDatabase （里面调用了initializeDb), initializeDb里调用了privateDb(),一个这个时候是第一次调用， 会生成QFontDatabasePrivate对象

QFontDatabasePrivate中的QDataStream *stream成员才是真正处理qte的字体

创建一个QT的库项目,删除自动生成的.h和.cpp文件,添加一个接口定义.h文件和一个接口实现类(一个.h一个.cpp).代码如下:

1.接口文件源码

#ifndef PLUGININTERFACE_H
#define PLUGININTERFACE_H

#include <QString>

class EchoInterface
{
public:
 virtual ~EchoInterface() {}
 virtual QString echo(const QString &message) = 0;
};

QT_BEGIN_NAMESPACE
Q_DECLARE_INTERFACE(EchoInterface, "com.hollysys.plugin.EchoIntrface/1.0");
QT_END_NAMESPACE

#endif

2.接口实现类头文件

#ifndef PLUGIN_H
#define PLUGIN_H

//#include "plugin_global.h"
#include <QObject>
#include "plugininterface.h"

class Plugin : public QObject, EchoInterface
{
 Q_OBJECT
 Q_INTERFACES(EchoInterface)
public:
 Plugin();
 ~Plugin();
public:
 QString echo(const QString &message);

};

#endif // PLUGIN_H

3.接口实现类cpp文件

#include "plugin.h"
#include <QtGui>

Plugin::Plugin()
{

}

Plugin::~Plugin()
{

}

QString Plugin::echo(const QString &message)
{
 return message;
}

Q_EXPORT_PLUGIN2("echoPlugin", Plugin);

编译生成dll格式的插件.这里可能会遇到LNK2001错误,因为插件接口定义依赖于QT的元数据,而在代码中手动添加Q_OBJECT宏后,编译器不会自动为我们生成moc_XXXX.cpp文件,因此需要使用命令行生成moc元数据文件:cmd-->cd 源码所在命令 -->moc -o moc_XXXX.cpp XXXX.h.这样就可以手动创建出moc元数据文件,解决LNK2001编译错误.

建立一个GUI测试项目,代码如下:

#include "test.h"
#include <QtGui>
#include <QMessageBox>
#include <QDir>

Test::Test(QWidget *parent, Qt::WFlags flags)
 : QMainWindow(parent, flags)
{
 ui.setupUi(this);
 QObject::connect(ui.pushButton, SIGNAL(clicked()), this, SLOT(ButtonClicked()));
 loadPlugin();
}

Test::~Test()
{

}

bool Test::loadPlugin()
{
 QDir pluginsDir(qApp->applicationDirPath());
 foreach (QString filename, pluginsDir.entryList(QDir::Files))
 {
  QPluginLoader pluginLoader(pluginsDir.absoluteFilePath(filename));
  QObject *plugin = pluginLoader.instance();
  if(plugin)
  {
   echoInterface = qobject_cast<EchoInterface *>(plugin);//echoInterface是成员变量
   if(echoInterface)
    return true;
  }
 }
}

void Test::ButtonClicked()
{
 QString plugin = ui.lineEdit->text();
 QMessageBox::information(NULL, "", echoInterface->echo(plugin));
}

分析代码可见,这里对所有与exe文件同目录的文件尝试加载插件,如果加载成功则返回.代码实现非常简洁.在正式开发中可将已加载的插件接口存放在列表中,在需要的时候依次调用即可.

另外如果想获取插件中类定义的元数据,可以使插件接口类从QObject继承,并使用Q_CLASSINFO宏添加键值对,如Q_CLASSINFO("Author**", "Henreash**").并从主程序中使用插件对象元数据获取这些键值对:

 const QMetaObject *mo = echoInterface->metaObject();
 for(int i = 0; i < mo->classInfoCount(); i++)
 {
  qDebug() << mo->classInfo(i).name() << mo->classInfo(i).value();
 }

使用这个机制可以在定义插件类的时候向主程序传递一些特殊信息.

测试发现,如果在插件接口类中定义一个静态变量,那么这个静态变量在插件中的地址和在主程序中的地址是不相同的.

在C++编程语言中，单例模式应用的例子如下述代码所示（这里仅仅提供一个示例，这个例子对多线程的情况并不是安全的）：

// ...
class lock
{
public:
lock();
lock(lock const & l);
~lock();
lock & operator =(lock const & l);
void request();
void release();
// ...
};
lock::lock()
{
// ...
}
// ...
lock::~lock()
{
// ...
}
// ...
void lock::request()
{
// ...
}
void lock::release()
{
// ...
}
// ...
// assumes _DATA_TYPE_ has a default constructor
template<typename _DATA_TYPE_>
class singleton
{
public:
static _DATA_TYPE_ * request();
static void release();
private:
singleton();
singleton(singleton<_DATA_TYPE_> const & s);
~singleton();
singleton<_DATA_TYPE_> & operator =(singleton<_DATA_TYPE_> const & s);
static _DATA_TYPE_ * pointer;
static lock mutex;
// ...
};
template<typename _DATA_TYPE_>
_DATA_TYPE_ * singleton<_DATA_TYPE_>::pointer = 0;
template<typename _DATA_TYPE_>
lock singleton<_DATA_TYPE_>::mutex;
template<typename _DATA_TYPE_>
_DATA_TYPE_ * singleton<_DATA_TYPE_>::request()
{
if(singleton<_DATA_TYPE_>::pointer == 0)
{
singleton<_DATA_TYPE_>::mutex.request();
if(singleton<_DATA_TYPE_>::pointer == 0)
{
singleton<_DATA_TYPE_>::pointer = new _DATA_TYPE_;
}
singleton<_DATA_TYPE_>::mutex.release();
}
return singleton<_DATA_TYPE_>::pointer;
}
template<typename _DATA_TYPE_>
void singleton<_DATA_TYPE_>::release()
{
if(singleton<_DATA_TYPE_>::pointer != 0)
{
singleton<_DATA_TYPE_>::mutex.request();
if(singleton<_DATA_TYPE_>::pointer != 0)
{
delete singleton<_DATA_TYPE_>::pointer;
singleton<_DATA_TYPE_>::pointer = 0;
}
singleton<_DATA_TYPE_>::mutex.release();
}
}
template<typename _DATA_TYPE_>
singleton<_DATA_TYPE_>::singleton()
{
// ...
}
// ...
int main()
{
int * s;
s = singleton<int>::request();
// ...
singleton<int>::release();
return 0;
}

#include "stdafx.h"
#include "DLLSample.h"

#pragma comment(lib, "DLLSample.lib")    //你也可以在项目属性中设置库的链接

int main()
{
        TestDLL(123);   //dll中的函数，在DllSample.h中声明
        return(1);
}

（2）显式链接
需要函数指针和WIN32 API函数LoadLibrary、GetProcAddress装载，使用这种载入方法，不需要.lib文件和.h头文件，只需要.dll文件即可（将.dll文件置入工程目录中）。

#include <iostream>
#include <windows.h>         //使用函数和某些特殊变量
typedef void (*DLLFunc)(int);
int main()
{
        DLLFunc dllFunc;
        HINSTANCE hInstLibrary = LoadLibrary("DLLSample.dll");

        if (hInstLibrary == NULL)
        {
          FreeLibrary(hInstLibrary);
        }
        dllFunc = (DLLFunc)GetProcAddress(hInstLibrary, "TestDLL");
        if (dllFunc == NULL)
        {
          FreeLibrary(hInstLibrary);
        }
        dllFunc(123);
        std::cin.get();
        FreeLibrary(hInstLibrary);
        return(1);
}

LoadLibrary函数利用一个名称作为参数，获得DLL的实例（HINSTANCE类型是实例的句柄），通常调用该函数后需要查看一下函数返回是否成功，如果不成功则返回NULL（句柄无效），此时调用函数FreeLibrary释放DLL获得的内存。
GetProcAddress函数利用DLL的句柄和函数的名称作为参数，返回相应的函数指针，同时必须使用强转；判断函数指针是否为NULL，如果是则调用函数FreeLibrary释放DLL获得的内存。此后，可以使用函数指针来调用实际的函数。
最后要记得使用FreeLibrary函数释放内存。

注意：应用程序如何找到DLL文件？
使用LoadLibrary显式链接，那么在函数的参数中可以指定DLL文件的完整路径；如果不指定路径，或者进行隐式链接，Windows将遵循下面的搜索顺序来定位DLL：
（1）包含EXE文件的目录
（2）工程目录
（3）Windows系统目录
（4）Windows目录
（5）列在Path环境变量中的一系列目录

From: http://www.cppblog.com/ming81/archive/2013/03/04/198215.html

.h头文件是编译时必须的，lib是链接时需要的，dll是运行时需要的。

附加依赖项的是.lib不是.dll，若生成了DLL,则肯定也生成 LIB文件。如果要完成源代码的编译和链接，有头文件和lib就够了。如果也使动态连接的程序运行起来，有dll就够了。在开发和调试阶段，当然最好都有。

.h .lib .dll三者的关系是：

H文件作用是:声明函数接口 

DLL文件作用是: 函数可执行代码 

当我们在自己的程序中引用了一个H文件里的函数,编链器怎么知道该调用哪个DLL文件呢?这就是LIB文件的作用: 告诉链接器 调用的函数在哪个DLL中，函数执行代码在DLL中的什么位置 ，这也就是为什么需要附加依赖项 .LIB文件，它起到桥梁的作用。如果生成静态库文件，则没有DLL ，只有lib，这时函数可执行代码部分也在lib文件中

目前以lib后缀的库有两种，一种为静态链接库(Static Libary，以下简称“静态库”)，另一种为动态连接库(DLL，以下简称“动态库”)的导入库(Import Libary，以下简称“导入库”）。静态库是一个或者多个obj文件的打包 ，所以有人干脆把从obj文件生成lib的过程称为Archive，即合并到一起。比如你链接一个静态库，如果其中有错，它会准确的找到是哪个obj有错，即静态lib只是壳子。动态库一般会有对应的导入库，方便程序静态载入动态链接库 ，否则你可能就需要自己LoadLibary调入DLL文件，然后再手工GetProcAddress获得对应函数了。有了导入库，你只需要链接导入库后按照头文件函数接口的声明调用函数就可以了。导入库和静态库的区别很大，他们实质是不一样的东西。静态库本身就包含了实际执行代码、符号表等等，而对于导入库而言，其实际的执行代码位于动态库中，导入库只包含了地址符号表等，确保程序找到对应函数的一些基本地址信息。

一般的动态库程序有lib文件和dll文件。lib文件是必须在编译期就连接到应用程序中的，而dll文件是运行期才会被调用的。 如果有dll文件，那么对应的lib文件一般是一些索引信息，具体的实现在dll文件中。如果只有lib文件，那么这个lib文件是静态编译出来的，索引和实现都在其中。静态编译的lib文件有好处：给用户安装时就不需要再挂动态库了。但也有缺点，就是导致应用程序比较大，而且失去了动态库的灵活性，在版本升级时，同时要发布新的应用程序才行。在动态库的情况下，有两个文件，而一个是引入库（.LIB）文件，一个是DLL文件，引入库文件包含被DLL导出的函数的名称和位置，DLL包含实际的函数和数据，应用程序使用LIB文件链接到所需要使用的DLL文件，库中的函数和数据并不复制到可执行文件中，因此在应用程序的可执行文件中，存放的不是被调用的函数代码，而是DLL中所要调用的函数的内存地址，这样当一个或多个应用程序运行是再把程序代码和被调用的函数代码链接起来，从而节省了内存资源。从上面的说明可以看出，DLL和.LIB文件必须随应用程序一起发行，否则应用程序将会产生错误。

静态库和共享库都是一个obj文件的集合 ，但静态链接后，执行程序中存在自己所需obj的一份拷贝，而动态链接后，执行程序仅仅是包含对共享库的一个引用。共享库相当于一个由多个obj文件组合而成的obj文件，在链接后其所有代码被加载，不管需要的还是不需要的。
似乎可以得出一个结论：
  静态链接后的程序比动态链接的所用存储空间大，因为执行程序中包含了库中代码拷贝；
  而动态链接的程序比静态链接的所用的运行空间大，因为它将不需要的代码也加载到运行空间。

针对上面的知识2 个问题：

1） DLL和.LIB文件必须随应用程序一起发行，否则应用程序将会产生错误。 
我的答案：lib应该不需要吧。

2）如果是某个程序中调用了一个动态库（通过header文件，lib+dll来调用），则对动态库的某个函数的内容修改了，但接口不改，则调用此动态库的程序需重新编译连接吗？如果是通过loadlibary动态加载，需要重新编译连接吗？

目前有很多不同类型的版本控制系统（Version Control System， VCS）。一些VCS，比如Subversion和CVS，以中央仓库（repository）为中心进行架构。此外，还有分布式的VCS（Distributed VCS，DVCS）， Git 和 Mercurial 是两个新近出现的DVCS。然而，在上述两种类型的环境中，通常会有一个“指定的”中央仓库。对应地，比如一个Subversion服务器或者一个GitHub仓库。下面会基于这个场景进行图示说明。那么让我们开始吧。

在开发者拷贝到本机之前，服务器需要创建一个仓库。创建初始仓库会由于产品不同而有所差别。从现在起，你所要知道的就是，在服务器上有一个初始空间。我把这个版本称作版本“A”。

现在，每个开发者（开发者1和开发者2）都会拷贝版本“A”到他们本地电脑。再一次地，从服务器拷贝的过程会由于产品不同采用的技术会有所差别。

每个开发者会在他们的本地拷贝上进行开发。他们的本地拷贝基于版本“A”。然而，由于他们应该不会做同样的开发，因而他们的版本会有所差别。因此，会有2个以上的版本会同时被创建，比如版本“B”和版本“C”。


开发者1首先完成了她的工作并提交到服务器。服务器上的当前版本被更新成版本“B”。


开发者2现在完成了他的工作并试图提交到服务器。然而，这是服务器告知他基于开发的版本已经发生改变。这也是为什么采取版本控制的首要原因之一。这个特性是对网络共享代码然后由开发者手动更新的一个跨越式发展，这确保了之前的编辑没有被新的修改覆盖。


开发者2必须首先获得所有版本“B”的变化，并合并到他的修改中，然后才可以提交到服务器。这个过程听起来有些复杂。然而，大多数现代的版本控制系统十分高级，能够自动在开发者的本地拷贝上完成合并。有几种情况会产生冲突（例如：开发者1和开发者2同时修改了同一个文件的同一行）。这就是一些VCS产品比其他更高级的地方。不论如何完成合并，现在开发者2在他们的本地系统上同时混合了版本B和版本C。


现在开发者2可以提交他的版本到服务器。

这是一个版本控制的基础。通过注意观察图中服务器的连线可以发现版本控制的原理。服务器记录了所有先前的版本包括发生的变化，什么时候发生以及由谁进行修改。当需要进行代码回溯或者引入其他bug时，这个记录能够解除困境。
我希望本文能够为版本控制系统提供一个基础的介绍。如果你有任何疑问，请就你问题发表评论。
 
英文原文：greenmoonsoftware 编译：伯乐在线 – 唐尤华

    QString str("我....这是神马");

    QStringList list;

    int pos = 0;

    while ((pos = rx.indexIn(str, pos)) != -1) {

        list << rx.cap(0);

        pos += rx.matchedLength();

    }

    qDebug() << list;

QGraphicsEffect也是Qt-4.6引入的一个新功能。它让给图形元素QGraphicsItem增加更佳视觉效果的编程变得非常简单。

先来看几张效果图。

上图中最上面的那个图片是没有使用QGraphicsEffect处理的原图，下面的四个图片分别代表了模糊，变色，透明和阴影效果。对应使用了QGraphicsEffect的4个子类QGraphicsBlurEffect, QGraphicsColorizeEffect, QGraphicsDropShadowEffect, 和 QGraphicsOpacityEffect.下面分别介绍它们。

QGraphicsBlurEffect
该类用应产生模糊效果,主要函数setBlurRadius(qreal blurRadius),用于控制图形元素的模糊度，数值越大越模糊。使用该类例子如下

QGraphicsBlurEffect *e0 = new QGraphicsBlurEffect(this);
e0->setBlurRadius(0.2);
item[0]->setGraphicsEffect(e1);//item[0] 为QGraphicsItem指针

QGraphicsColorizeEffect
该类提供了使用另外一种颜色对当前图形的一种着色功能。主要函数是setColor(QColor)和setStrength (qreal strength)，指定了着色和着色强度。使用该类例子如下

QGraphicsColorizeEffect *e1 = new QGraphicsColorizeEffect(this);
e1->setColor(QColor(0,0,192));
item[1]->setGraphicsEffect(e1);

QGraphicsDropShadowEffect
该类提供了图形元素的阴影效果，用于增加立体感。主要设置函数有3个，setColor()用于设定阴影的颜色,setBlurRadius()用于设定阴影的模糊度，setOffset (qreal dx,qreal dy)用于设定在哪个方向产生阴影效果，如果dx为负数，则阴影在图形元素的左边。使用该类例子如下

QGraphicsDropShadowEffect *e2 = new QGraphicsDropShadowEffect(this);
e2->setOffset(8,8);
item[2]->setGraphicsEffect(e2);

QGraphicsOpacityEffect
该类用于图形元素的透明效果，主要函数是setOpacity(qreal opacity)，用于设置透明度，参数值在0和1.0之间。也可以设置部分透明效果，需要调用的函数是setOpacityMask (QBrush mask)。使用该类例子如下

QGraphicsOpacityEffect *e3 = new QGraphicsOpacityEffect(this);
e3->setOpacity(0.7);
item[3]->setGraphicsEffect(e3);

下面我是写的例子代码和截图。

最后值得一提的是，这些效果是可以互相组合的。如果能把这些效果和Qt的动画Animation API结合起来，写出的程序就更漂亮了。
$QTSRC/examples/effect目录下面有些例子可以参考。

From: http://cowboy.1988.blog.163.com/blog/static/75105798201151311244982/

#include <QDebug>

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

    qDebug() << QCryptographicHash::hash("Biao", QCryptographicHash::Md5).toHex().constData();

    return 0;

}