Qt的信號和槽機(jī)制是Qt的一大特點,實際上這是和MFC中的消息映射機(jī)制相似的東西,要完成的事情也差不多,就是發(fā)送一個消息然后讓其它窗口響應(yīng),當(dāng)然,這里的消息是廣義的
說法,簡單點說就是如何在一個類的一個函數(shù)中觸發(fā)另一個類的另一個函數(shù)調(diào)用,而且還要把相關(guān)的參數(shù)傳遞過去.好像這和回調(diào)函數(shù)也有點關(guān)系,但是消息機(jī)制可比回調(diào)函數(shù)有用
多了,也復(fù)雜多了
MFC中的消息機(jī)制沒有采用C++中的虛函數(shù)機(jī)制,原因是消息太多,虛函數(shù)開銷太大.在Qt中也沒有采用C++中的虛函數(shù)機(jī)制,原因與此相同.其實這里還有更深層次上的原因,大體說來,
多態(tài)的底層實現(xiàn)機(jī)制只有兩種,一種是按照名稱查表,一種是按照位置查表,兩種方式各有利弊,而C++的虛函數(shù)機(jī)制無條件的采用了后者,導(dǎo)致的問題就是在子類很少重載基類實現(xiàn)
的時候開銷太大,再加上象界面編程這樣子類眾多的情況,基本上C++的虛函數(shù)機(jī)制就廢掉了,于是各家?guī)斓木帉懻呔椭缓米灾\生路了,說到底,這確實是C++語言本身的缺陷
示例代碼：
#include <QApplication>
#include <QPushButton>
#include <QPointer>
int main(int argc, char *argv[])
{
QApplication app(argc, argv);
QPushButton quit("Quit");
quit.resize(100, 30);
quit.show();
QObject::connect(&quit, SIGNAL(clicked()), &app, SLOT(quit()));
return app.exec();
}
這里主要是看QPushButton的clicked()信號和app的quit()槽如何連接?又是如何響應(yīng)?
前面已經(jīng)說過了,Qt的信號槽機(jī)制其實就是按照名稱查表,因此這里的首要問題是如何構(gòu)造這個表?
和C++虛函數(shù)表機(jī)制類似的,在Qt中,這個表就是元數(shù)據(jù)表,Qt中的元數(shù)據(jù)表最大的作用就是支持信號槽機(jī)制,當(dāng)然,也可以在此基礎(chǔ)上擴(kuò)展出更多的功能,因為
元數(shù)據(jù)是我們可以直接訪問到的,不再是象虛函數(shù)表那樣被編譯器遮遮掩掩的藏了起來,不過Qt似乎還沒有完全發(fā)揮元數(shù)據(jù)的能力,動態(tài)屬性,反射之類的機(jī)制好像還沒有
任何從QObject派生的類都包含了自己的元數(shù)據(jù)模型，一般是通過宏Q_OBJECT定義的
#define Q_OBJECT \
public: \
static const QMetaObject staticMetaObject; \
virtual const QMetaObject *metaObject() const; \
virtual void *qt_metacast(const char *); \
QT_TR_FUNCTIONS \
virtual int qt_metacall(QMetaObject::Call, int, void **); \
private:
首先聲明了一個QMetaObject類型的靜態(tài)成員變量,這就是元數(shù)據(jù)的數(shù)據(jù)結(jié)構(gòu)
struct Q_CORE_EXPORT QMetaObject
{
...
struct { // private data
const QMetaObject *superdata;
const char *stringdata;
const uint *data;
const QMetaObject **extradata;
} d;
}
QMetaObject中有一個嵌套類封裝了所有的數(shù)據(jù)
const QMetaObject *superdata;//這是元數(shù)據(jù)代表的類的基類的元數(shù)據(jù)
const char *stringdata;//這是元數(shù)據(jù)的簽名標(biāo)記
const uint *data;//這是元數(shù)據(jù)的索引數(shù)組的指針
const QMetaObject **extradata;//這是擴(kuò)展元數(shù)據(jù)表的指針,一般是不用的
這里的三個虛函數(shù)metaObject，qt_metacast，qt_metacall是在moc文件中定義的
metaObject的作用是得到元數(shù)據(jù)表指針
qt_metacast的作用是根據(jù)簽名得到相關(guān)結(jié)構(gòu)的指針,注意它返回的可是void*指針
qt_metacall的作用是查表然后調(diào)用調(diào)用相關(guān)的函數(shù)
宏QT_TR_FUNCTIONS是和翻譯相關(guān)的
# define QT_TR_FUNCTIONS \
static inline QString tr(const char *s, const char *c = 0) \
{ return staticMetaObject.tr(s, c); }
好了,看看實際的例子吧:
QPushButton的元數(shù)據(jù)表如下:
static const uint qt_meta_data_QPushButton[] = {
// content:
1, // revision
0, // classname
0, 0, // classinfo
2, 10, // methods
3, 20, // properties
0, 0, // enums/sets
// slots: signature, parameters, type, tag, flags
13, 12, 12, 12, 0x0a,
24, 12, 12, 12, 0x08,
// properties: name, type, flags
44, 39, 0x01095103,
56, 39, 0x01095103,
64, 39, 0x01095103,
0 // eod
};
static const char qt_meta_stringdata_QPushButton[] = {
"QPushButton\0\0showMenu()\0popupPressed()\0bool\0autoDefault\0default\0"
"flat\0"
};
const QMetaObject QPushButton::staticMetaObject = {
{ &QAbstractButton::staticMetaObject, qt_meta_stringdata_QPushButton,
qt_meta_data_QPushButton, 0 }
};
在這里我們看到了靜態(tài)成員staticMetaObject被填充了
const QMetaObject *superdata;//這是元數(shù)據(jù)代表的類的基類的元數(shù)據(jù),被填充為基類的元數(shù)據(jù)指針&QAbstractButton::staticMetaObject
const char *stringdata;//這是元數(shù)據(jù)的簽名標(biāo)記,被填充為qt_meta_stringdata_QPushButton
const uint *data;//這是元數(shù)據(jù)的索引數(shù)組的指針,被填充為qt_meta_data_QPushButton
const QMetaObject **extradata;//這是擴(kuò)展元數(shù)據(jù)表的指針,一般是不用的,被填充為0
首先應(yīng)該看qt_meta_data_QPushButton,因為這里是元數(shù)據(jù)的主要數(shù)據(jù),它被填充為一個整數(shù)數(shù)組,正因為這里只有整數(shù),不能有任何字符串存在,因此才有
qt_meta_stringdata_QPushButton發(fā)揮作用的機(jī)會,可以說真正的元數(shù)據(jù)應(yīng)該是qt_meta_data_QPushButton加上qt_meta_stringdata_QPushButton,那么為什么
不把這兩個東西合在一起呢?估計是兩者都不是定長的結(jié)構(gòu),合在一起反而麻煩吧
qt_meta_data_QPushButton實際上是以以下結(jié)構(gòu)開頭的
struct QMetaObjectPrivate
{
int revision;
int className;
int classInfoCount, classInfoData;
int methodCount, methodData;
int propertyCount, propertyData;
int enumeratorCount, enumeratorData;
};
一般使用中是直接使用以下函數(shù)做個轉(zhuǎn)換
static inline const QMetaObjectPrivate *priv(const uint* data)
{ return reinterpret_cast<const QMetaObjectPrivate*>(data); }
這種轉(zhuǎn)換怎么看都有些黑客的味道,這確實是十足的C風(fēng)格
再結(jié)合實際的數(shù)據(jù)看一看
static const uint qt_meta_data_QPushButton[] = {
// content:
1, // revision 版本號是1
0, // classname 類名存儲在qt_meta_stringdata_QPushButton中,索引是0,因此就是QPushButton了
0, 0, // classinfo 類信息數(shù)量為0,數(shù)據(jù)也是0
2, 10, // methods QPushButton有2個自定義方法,方法數(shù)據(jù)存儲在qt_meta_data_QPushButton中,索引是10,就是下面的slots:開始的地方
3, 20, // properties QPushButton有3個自定義屬性,屬性數(shù)據(jù)存儲在qt_meta_data_QPushButton中,索引是20,就是下面的properties:開始的地方
0, 0, // enums/sets QPushButton沒有自定義的枚舉
// slots: signature, parameters, type, tag, flags
13, 12, 12, 12, 0x0a,
第一個自定義方法的簽名存儲在qt_meta_data_QPushButton中,索引是13,就是showMenu()了
24, 12, 12, 12, 0x08,
第二個自定義方法的簽名存儲在qt_meta_data_QPushButton中,索引是24,popupPressed()了
// properties: name, type, flags
44, 39, 0x01095103,
第一個自定義屬性的簽名存儲在qt_meta_data_QPushButton中,索引是44,就是autoDefault了
第一個自定義屬性的類型存儲在qt_meta_data_QPushButton中,索引是39,就是bool
56, 39, 0x01095103,
第二個自定義屬性的簽名存儲在qt_meta_data_QPushButton中,索引是56,就是default了
第二個自定義屬性的類型存儲在qt_meta_data_QPushButton中,索引是39,就是bool
64, 39, 0x01095103,
第三個自定義屬性的簽名存儲在qt_meta_data_QPushButton中,索引是64,就是flat了
第三個自定義屬性的類型存儲在qt_meta_data_QPushButton中,索引是39,就是bool
0 // eod 元數(shù)據(jù)的結(jié)束標(biāo)記
};
static const char qt_meta_stringdata_QPushButton[] = {
"QPushButton\0\0showMenu()\0popupPressed()\0bool\0autoDefault\0default\0"
"flat\0"
};
QPushButton\\showMenu()\popupPressed()\bool\autoDefault\default\flat\
這里把\0直接替換為\是為了數(shù)數(shù)的方便
當(dāng)然我們還可以看看QPushButton的基類QAbstractButton的元數(shù)據(jù)
static const uint qt_meta_data_QAbstractButton[] = {
// content:
1, // revision
0, // classname
0, 0, // classinfo
12, 10, // methods
9, 70, // properties
0, 0, // enums/sets
// signals: signature, parameters, type, tag, flags
17, 16, 16, 16, 0x05,
27, 16, 16, 16, 0x05,
46, 38, 16, 16, 0x05,
60, 16, 16, 16, 0x25,
70, 38, 16, 16, 0x05,
// slots: signature, parameters, type, tag, flags
89, 84, 16, 16, 0x0a,
113, 108, 16, 16, 0x0a,
131, 16, 16, 16, 0x2a,
146, 16, 16, 16, 0x0a,
154, 16, 16, 16, 0x0a,
163, 16, 16, 16, 0x0a,
182, 180, 16, 16, 0x1a,
// properties: name, type, flags
202, 194, 0x0a095103,
213, 207, 0x45095103,
224, 218, 0x15095103,
246, 233, 0x4c095103,
260, 255, 0x01095103,
38, 255, 0x01195103,
270, 255, 0x01095103,
281, 255, 0x01095103,
295, 255, 0x01094103,
0 // eod
};
static const char qt_meta_stringdata_QAbstractButton[] = {
"QAbstractButton\0\0pressed()\0released()\0checked\0clicked(bool)\0"
"clicked()\0toggled(bool)\0size\0setIconSize(QSize)\0msec\0"
"animateClick(int)\0animateClick()\0click()\0toggle()\0setChecked(bool)\0"
"b\0setOn(bool)\0QString\0text\0QIcon\0icon\0QSize\0iconSize\0"
"QKeySequence\0shortcut\0bool\0checkable\0autoRepeat\0autoExclusive\0"
"down\0"
};
QAbstractButton00pressed()0released()0checked0clicked(bool)0clicked()0toggled(bool)0size0setIconSize(QSize)0msec0animateClick(int)0animateClick()0click()0toggle()0setChecked(bool)0b0setOn(bool)0QString0text0QIcon0icon0QSize0iconSize0QKeySequence0shortcut0bool0checkable0autoRepeat0autoExclusive0down0
基本上都是大同小異的
QObject::connect(&quit, SIGNAL(clicked()), &app, SLOT(quit()));
下面開始看信號和槽連接的源碼了
// connect的源碼
connect函數(shù)是連接信號和槽的橋梁，非常關(guān)鍵
bool QObject::connect(const QObject *sender, const char *signal,
const QObject *receiver, const char *method,
Qt::ConnectionType type)
{
#ifndef QT_NO_DEBUG
bool warnCompat = true;
#endif
if (type == Qt::AutoCompatConnection) {
type = Qt::AutoConnection;
#ifndef QT_NO_DEBUG
warnCompat = false;
#endif
}
// 不允許空輸入
if (sender == 0 || receiver == 0 || signal == 0 || method == 0) {
#ifndef QT_NO_DEBUG
qWarning("Object::connect: Cannot connect %s::%s to %s::%s",
sender ? sender->metaObject()->className() : "(null)",
signal ? signal+1 : "(null)",
receiver ? receiver->metaObject()->className() : "(null)",
method ? method+1 : "(null)");
#endif
return false;
}
QByteArray tmp_signal_name;
#ifndef QT_NO_DEBUG
// 檢查是否是信號標(biāo)記
if (!check_signal_macro(sender, signal, "connect", "bind"))
return false;
#endif
// 得到元數(shù)據(jù)類
const QMetaObject *smeta = sender->metaObject();
++signal; //skip code跳過信號標(biāo)記,直接得到信號標(biāo)識
// 得到信號的索引
int signal_index = smeta->indexOfSignal(signal);
if (signal_index < 0) {
// check for normalized signatures
tmp_signal_name = QMetaObject::normalizedSignature(signal).prepend(*(signal - 1));
signal = tmp_signal_name.constData() + 1;
signal_index = smeta->indexOfSignal(signal);
if (signal_index < 0) {
#ifndef QT_NO_DEBUG
err_method_notfound(QSIGNAL_CODE, sender, signal, "connect");
err_info_about_objects("connect", sender, receiver);
#endif
return false;
}
}
QByteArray tmp_method_name;
int membcode = method[0] - '0';
#ifndef QT_NO_DEBUG
// 檢查是否是槽,用QSLOT_CODE 1標(biāo)記
if (!check_method_code(membcode, receiver, method, "connect"))
return false;
#endif
++method; // skip code
// 得到元數(shù)據(jù)類
const QMetaObject *rmeta = receiver->metaObject();
int method_index = -1;
// 這里是一個case,信號即可以和信號連接也可以和槽連接
switch (membcode) {
case QSLOT_CODE:
// 得到槽的索引
method_index = rmeta->indexOfSlot(method);
break;
case QSIGNAL_CODE:
// 得到信號的索引
method_index = rmeta->indexOfSignal(method);
break;
}
if (method_index < 0) {
// check for normalized methods
tmp_method_name = QMetaObject::normalizedSignature(method);
method = tmp_method_name.constData();
switch (membcode) {
case QSLOT_CODE:
method_index = rmeta->indexOfSlot(method);
break;
case QSIGNAL_CODE:
method_index = rmeta->indexOfSignal(method);
break;
}
}
if (method_index < 0) {
#ifndef QT_NO_DEBUG
err_method_notfound(membcode, receiver, method, "connect");
err_info_about_objects("connect", sender, receiver);
#endif
return false;
}
#ifndef QT_NO_DEBUG
// 檢查參數(shù),信號和槽的參數(shù)必須一致,槽的參數(shù)也可以小于信號的參數(shù)
if (!QMetaObject::checkConnectArgs(signal, method)) {
qWarning("Object::connect: Incompatible sender/receiver arguments"
"\n\t%s::%s --> %s::%s",
sender->metaObject()->className(), signal,
receiver->metaObject()->className(), method);
return false;
}
#endif
int *types = 0;
if (type == Qt::QueuedConnection
&& !(types = ::queuedConnectionTypes(smeta->method(signal_index).parameterTypes())))
return false;
#ifndef QT_NO_DEBUG
{
// 得到方法的元數(shù)據(jù)
QMetaMethod smethod = smeta->method(signal_index);
QMetaMethod rmethod = rmeta->method(method_index);
if (warnCompat) {
if(smethod.attributes() & QMetaMethod::Compatibility) {
if (!(rmethod.attributes() & QMetaMethod::Compatibility))
qWarning("Object::connect: Connecting from COMPAT signal (%s::%s).", smeta->className(), signal);
} else if(rmethod.attributes() & QMetaMethod::Compatibility && membcode != QSIGNAL_CODE) {
qWarning("Object::connect: Connecting from %s::%s to COMPAT slot (%s::%s).",
smeta->className(), signal, rmeta->className(), method);
}
}
}
#endif
// 調(diào)用元數(shù)據(jù)類的連接
QMetaObject::connect(sender, signal_index, receiver, method_index, type, types);
// 發(fā)送連接的通知,現(xiàn)在的實現(xiàn)是空的
const_cast<QObject*>(sender)->connectNotify(signal - 1);
return true;
}
檢查信號標(biāo)記其實比較簡單,就是用signal的第一個字符和用QSIGNAL_CODE=2的標(biāo)記比較而已
static bool check_signal_macro(const QObject *sender, const char *signal,
const char *func, const char *op)
{
int sigcode = (int)(*signal) - '0';
if (sigcode != QSIGNAL_CODE) {
if (sigcode == QSLOT_CODE)
qWarning("Object::%s: Attempt to %s non-signal %s::%s",
func, op, sender->metaObject()->className(), signal+1);
else
qWarning("Object::%s: Use the SIGNAL macro to %s %s::%s",
func, op, sender->metaObject()->className(), signal);
return false;
}
return true;
}
得到信號的索引實際上要依次找每個基類的元數(shù)據(jù),得到的偏移也是所有元數(shù)據(jù)表加在一起后的一個索引
int QMetaObject::indexOfSignal(const char *signal) const
{
int i = -1;
const QMetaObject *m = this;
while (m && i < 0) {
// 根據(jù)方法的數(shù)目倒序的查找
for (i = priv(m->d.data)->methodCount-1; i >= 0; --i)
// 得到該方法的類型
if ((m->d.data[priv(m->d.data)->methodData + 5*i + 4] & MethodTypeMask) == MethodSignal
&& strcmp(signal, m->d.stringdata
// 得到方法名稱的偏移
+ m->d.data[priv(m->d.data)->methodData + 5*i]) == 0) {
//如果找到了正確的方法,再增加所有基類的方法偏移量
i += m->methodOffset();
break;
}
// 在父類中繼續(xù)找
m = m->d.superdata;
}
#ifndef QT_NO_DEBUG
// 判斷是否于基類中的沖突
if (i >= 0 && m && m->d.superdata) {
int conflict = m->d.superdata->indexOfMethod(signal);
if (conflict >= 0)
qWarning("QMetaObject::indexOfSignal:%s: Conflict with %s::%s",
m->d.stringdata, m->d.superdata->d.stringdata, signal);
}
#endif
return i;
}
// 這里是所有基類的方法偏移量算法,就是累加基類所有的方法數(shù)目
int QMetaObject::methodOffset() const
{
int offset = 0;
const QMetaObject *m = d.superdata;
while (m) {
offset += priv(m->d.data)->methodCount;
m = m->d.superdata;
}
return offset;
}
// 得到方法的元數(shù)據(jù)
QMetaMethod QMetaObject::method(int index) const
{
int i = index;
// 要減去基類的偏移
i -= methodOffset();
// 如果本類找不到,就到基類中去找
if (i < 0 && d.superdata)
return d.superdata->method(index);
// 如果找到了,就填充QMetaMethod結(jié)構(gòu)
QMetaMethod result;
if (i >= 0 && i < priv(d.data)->methodCount) {
// 這里是類的元數(shù)據(jù)
result.mobj = this;
// 這里是方法相關(guān)數(shù)據(jù)在data數(shù)組中的偏移量
result.handle = priv(d.data)->methodData + 5*i;
}
return result;
}
bool QMetaObject::connect(const QObject *sender, int signal_index,
const QObject *receiver, int method_index, int type, int *types)
{
// 得到全局的連接列表
QConnectionList *list = ::connectionList();
if (!list)
return false;
QWriteLocker locker(&list->lock);
// 增加一個連接
list->addConnection(const_cast<QObject *>(sender), signal_index,
const_cast<QObject *>(receiver), method_index, type, types);
return true;
}
void QConnectionList::addConnection(QObject *sender, int signal,
QObject *receiver, int method,
int type, int *types)
{
// 構(gòu)造一個連接
QConnection c = { sender, signal, receiver, method, 0, 0, types };
c.type = type; // don't warn on VC++6
int at = -1;
// 如果有中間被刪除的連接,可以重用這個空間
for (int i = 0; i < unusedConnections.size(); ++i) {
if (!connections.at(unusedConnections.at(i)).inUse) {
// reuse an unused connection
at = unusedConnections.takeAt(i);
connections[at] = c;
break;
}
}
if (at == -1) {
// append new connection
at = connections.size();
// 加入一個連接
connections << c;
}
// 構(gòu)造sender,receiver連接的哈希表,加速搜索速度
sendersHash.insert(sender, at);
receiversHash.insert(receiver, at);
}
通過connect函數(shù),我們建立了信號和槽的連接,并且把信號類+信號索引+槽類,槽索引作為記錄寫到了全局的connect列表中
一旦我們發(fā)送了信號,就應(yīng)該調(diào)用相關(guān)槽中的方法了,這個過程其實就是查找全局的connect列表的過程,當(dāng)然還要注意其中要對相關(guān)的參數(shù)打包和解包
// emit是發(fā)送信號的代碼
void Foo::setValue(int v)
{
if (v != val)
{
val = v;
emit valueChanged(v);
}
}
// 發(fā)送信號的真正實現(xiàn)在moc里面
// SIGNAL 0
void Foo::valueChanged(int _t1)
{
// 首先把參數(shù)打包
void *_a[] = { 0, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
// 調(diào)用元數(shù)據(jù)類的激活
QMetaObject::activate(this, &staticMetaObject, 0, _a);
}
void QMetaObject::activate(QObject *sender, const QMetaObject *m, int local_signal_index,
void **argv)
{
// 增加一個基類偏移量
int offset = m->methodOffset();
activate(sender, offset + local_signal_index, offset + local_signal_index, argv);
}
void QMetaObject::activate(QObject *sender, int from_signal_index, int to_signal_index, void **argv)
{
// 這里得到的是QObject的數(shù)據(jù),首先判斷是否為阻塞設(shè)置
if (sender->d_func()->blockSig)
return;
// 得到全局鏈表
QConnectionList * const list = ::connectionList();
if (!list)
return;
QReadLocker locker(&list->lock);
void *empty_argv[] = { 0 };
if (qt_signal_spy_callback_set.signal_begin_callback != 0) {
locker.unlock();
qt_signal_spy_callback_set.signal_begin_callback(sender, from_signal_index,
argv ? argv : empty_argv);
locker.relock();
}
// 在sender的哈希表中得到sender的連接
QConnectionList::Hash::const_iterator it = list->sendersHash.find(sender);
const QConnectionList::Hash::const_iterator end = list->sendersHash.constEnd();
if (it == end) {
if (qt_signal_spy_callback_set.signal_end_callback != 0) {
locker.unlock();
qt_signal_spy_callback_set.signal_end_callback(sender, from_signal_index);
locker.relock();
}
return;
}
QThread * const currentThread = QThread::currentThread();
const int currentQThreadId = currentThread ? QThreadData::get(currentThread)->id : -1;
// 記錄sender連接的索引
QVarLengthArray<int> connections;
for (; it != end && it.key() == sender; ++it) {
connections.append(it.value());
// 打上使用標(biāo)記,因為可能是放在隊列中
list->connections[it.value()].inUse = 1;
}
for (int i = 0; i < connections.size(); ++i) {
const int at = connections.constData()[connections.size() - (i + 1)];
QConnectionList * const list = ::connectionList();
// 得到連接
QConnection &c = list->connections[at];
c.inUse = 0;
if (!c.receiver || (c.signal < from_signal_index || c.signal > to_signal_index))
continue;
// 判斷是否放到隊列中
// determine if this connection should be sent immediately or
// put into the event queue
if ((c.type == Qt::AutoConnection
&& (currentQThreadId != sender->d_func()->thread
|| c.receiver->d_func()->thread != sender->d_func()->thread))
|| (c.type == Qt::QueuedConnection)) {
::queued_activate(sender, c, argv);
continue;
}
// 為receiver設(shè)置當(dāng)前發(fā)送者
const int method = c.method;
QObject * const previousSender = c.receiver->d_func()->currentSender;
c.receiver->d_func()->currentSender = sender;
list->lock.unlock();
if (qt_signal_spy_callback_set.slot_begin_callback != 0)
qt_signal_spy_callback_set.slot_begin_callback(c.receiver, method, argv ? argv : empty_argv);
#if defined(QT_NO_EXCEPTIONS)
c.receiver->qt_metacall(QMetaObject::InvokeMetaMethod, method, argv ? argv : empty_argv);
#else
try {
// 調(diào)用receiver的方法
c.receiver->qt_metacall(QMetaObject::InvokeMetaMethod, method, argv ? argv : empty_argv);
} catch (...) {
list->lock.lockForRead();
if (c.receiver)
c.receiver->d_func()->currentSender = previousSender;
throw;
}
#endif
if (qt_signal_spy_callback_set.slot_end_callback != 0)
qt_signal_spy_callback_set.slot_end_callback(c.receiver, method);
list->lock.lockForRead();
if (c.receiver)
c.receiver->d_func()->currentSender = previousSender;
}
if (qt_signal_spy_callback_set.signal_end_callback != 0) {
locker.unlock();
qt_signal_spy_callback_set.signal_end_callback(sender, from_signal_index);
locker.relock();
}
}
// 響應(yīng)信號也是在moc里實現(xiàn)的
int Foo::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
// 首先在基類中調(diào)用方法,返回的id已經(jīng)變成當(dāng)前類的方法id了
_id = QObject::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
switch (_id) {
// 這里就是真正的調(diào)用方法了,注意參數(shù)的解包用法
case 0: valueChanged(*reinterpret_cast< int(*)>(_a[1])); break;
case 1: setValue(*reinterpret_cast< int(*)>(_a[1])); break;
}
_id -= 2;
}
return _id;
}