QT C++ 中常见知识点

文章目录

1. Qt信号与槽
2. TCP/UDP
- 1）描述Qt下Tcp通信的整个流程
- 2）描述QT下udp通信的整个流程
3. 多线程
4 Qt QJson
5 智能指针
6 Qt的d指针和p指针
7 QVariant使用
8 继承与派生
- 1）继承与派生的区别
- 2）三种继承方式公有继承，私有继承和保护继承
9 Qwidget、Qobejct实现的功能
- 1）QObject
- 2）QWidget
10 参数传值、指针、引用有什么区别，在什么场景常用哪种传递方式？

1. Qt信号与槽

1）信号与槽有哪些优势和不足？

♦ 优势：

类型安全。信号的参数类型和参数个数同接收该信号的槽的参数类型和参数个数相同。不过，一个槽的参数个数是可以少于信号的参数个数的，但缺少的参数必须是信号参数的最后一个或几个参数。
松散耦合。信号和槽机制减弱了Qt对象的耦合度。激发信号的Qt对象无需知道是哪个对象的哪个槽需要接收它发出的信号，它只需在适当的时间发送适当的信号就可以了，而不需要知道也不关心它的信号有没有被接收到，更不需要知道是哪个对象的哪个槽收到了信号。同样的，对象的槽也不知道是哪些信号关联了自己，而一旦关联信号和槽，Qt就保证了适合的槽得到了调用。即使关联的对象在运行时被删除，程序也不会崩溃。
灵活性。信号和槽机制增强了对象间通信的灵活性。一个信号可以关联多个槽，也可以多个信号关联一个槽。

♦不足：

同回调函数相比，信号和槽机制运行速度有些慢。通过传递一个信号来调用槽函数将会比直接调用非虚函数运行速度慢10倍。原因如下：

① 需要定位接收信号的对象。② 安全地遍历所有关联槽。③ 编组、解组传递参数。④ 多线程的时候，信号需要排队等待。（然而，与创建对象的new操作及删除对象的delete操作相比，信号和槽的运行代价只是他们很少的一部分。信号和槽机制导致的这点性能损耗，对实时应用程序是可以忽略的。）

2）信号与槽的本质是什么？

回调函数。 信号或是传递值，或是传递动作变化；槽函数响应信号或是接收值，或者根据动作变化来做出对应操作。

就是 “你想让别人的代码执行你的代码，而别人的代码你又不能动” 这种需求下产生的。

3）使用信号槽要注意什么？

发送者和接收者都需要是QObject的子类（当然，槽函数是全局函数、Lambda 表达式等无需接收者的时候除外）；
使用 signals 标记信号函数，信号是一个函数声明，返回 void，不需要实现函数代码；
槽函数是普通的成员函数，作为成员函数，会受到 public、private、protected 的影响；
使用 emit 在恰当的位置发送信号；
使用QObject::connect()函数连接信号和槽；
任何成员函数、static 函数、全局函数和 Lambda 表达式都可以作为槽函数。

4）信号槽有哪些用法？

一个信号可以和多个槽相连。
如果是这种情况，这些槽会一个接一个的被调用，但是它们的调用顺序是不确定的。
多个信号可以连接到一个槽。
只要任意一个信号发出，这个槽就会被调用。
一个信号可以连接到另外的一个信号。
当第一个信号发出时，第二个信号被发出。除此之外，这种信号-信号的形式和信号-槽的形式没有什么区别。
槽可以被取消链接。
这种情况并不经常出现，因为当一个对象delete之后，Qt自动取消所有连接到这个对象上面的槽。
使用Lambda 表达式。
在使用 Qt 5 的时候，能够支持 Qt 5 的编译器都是支持 Lambda 表达式的。

2. TCP/UDP

1）描述Qt下Tcp通信的整个流程

♦ 服务器端：

创建用于监听的套接字（Socket）【socket可以看成在两个程序进行通讯连接中的一个端点，一个程序将一段信息写入Socket中，该Socket将这段信息发送给另外一个Socket中，使这段信息能传送到其他程序中】
给套接字设置监听
如果有连接到来, 监听的套接字会发出信号newConnected
接收连接, 通过nextPendingConnection()函数, 返回一个QTcpSocket类型的套接字对象(用于通信)
使用用于通信的套接字对象通信
1>. 发送数据: write
2>. 接收数据: readAll/read

♦ 客户端：

创建用于通信的套接字
连接服务器: connectToHost
连接成功与服务器通信
1>. 发送数据: write
2>. 接收数据: readAll/read

2）描述QT下udp通信的整个流程

QT下udp通信服务器端和客户端的关系是对等的, 做的处理也是一样的.

创建套接字对象
如果需要接收数据, 必须绑定端口
发送数据: writeDatagram
接收数据: readDatagram

3. 多线程

1）多线程的使用

方法一：继承 QThread

链接： QT 中的多线程之继承 Thread

创建一个类从QThread类派生
在子线程类中重写 run 函数, 将处理操作写入该函数中
在主线程中创建子线程对象, 启动子线程, 调用start()函数

方法二：moveToThread

链接： QT 中的多线程之 moveToThread

将业务处理抽象成一个业务类, 在该类中创建一个业务处理函数
在主线程中创建一QThread类对象
在主线程中创建一个业务类对象
将业务类对象通过 moveToThread 移动到子线程中
在主线程中启动子线程 _workerThread->start();
通过信号槽的方式, 执行业务类中的业务处理函数

Worker* worker = new Worker ;                 //创建一个QObject对象
QThread* _workerThread = new QThread(this);   //创建一个新线程
worker->moveToThread(&_workerThread);        // 调用 moveToThread 将该任务交给 workThread

方法三

QFuture< void> fut1 = QtConcurrent::run(processFun, command);

processFun为线程回调函数

多线程使用注意事项:

业务对象, 构造的时候不能指定父对象
子线程中不能处理ui窗口(ui相关的类)
子线程中只能处理一些数据相关的操作, 不能涉及窗口

2）多线程下，信号槽分别在什么线程中执行，如何控制

可以通过 connect 的第五个参数 connectType 进行控制信号槽执行时所在的线程

connect有几种连接方式，直接连接和队列连接、自动连接

♦ 直接连接：

Qt::AutoConnection：默认值，使用这个值则连接类型会在信号发送时决定。如果接收者和发送者在同一个线程，则自动使用

Qt::DirectConnection：槽函数会在信号发送的时候直接被调用，槽函数运行于信号发送者所在线程。效果看上去就像是直接在信号发送位置调用了槽函数。这个在多线程环境下比较危险，可能会造成奔溃。

♦ 队列连接：

Qt::QueuedConnection：信号在信号发出者所在的线程中执行，槽函数在信号接收者所在的线程中执行

Qt::BlockingQueuedConnection：槽函数的调用时机与Qt::QueuedConnection一致，不过发送完信号后发送者所在线程会阻塞，直到槽函数运行完。接收者和发送者绝对不能在一个线程，否则程序会死锁。在多线程间需要同步的场合可能需要这个。

♦ 自动连接：

多线程时为队列连接函数，单线程时为直接连接函数。

3）多线程队列

Qt QQueue 安全的多线程队列、阻塞队列

4）Qt多线程同步的几种实现方式

链接： Qt 多线程同步：互斥锁QMutextLocker 、读写锁 QReadWriteLock、信号量 QSemaphore、条件变量QWaitConditio、QThread::wait()

互斥量 QMutex

QMutex类提供的是线程之间的访问顺序化。QMutex的目的是保护一个对象/数据结构或者代码段在同一时间只有一个线程可以访问。基本使用方法如下：

QMutex mutex;
int var;
  
void function()
{
   
    mutex.lock();
    // 访问var
    var * var;
    mutex.unlock();
}

如果使用mutex加锁，却没有使用unlock解锁，那么就会造成死锁，其他线程永远也得不到访问变量的机会，所以为了解决这个问题，Qt引入了QMutexLocker类，二者直接可以配合使用更加方便简洁，示例如下：

QMutex mutex;
int var;
 
void function()
{
   
    QMutextLocker locker(&mutex); 
    // 访问var
    var * var;
}

QReadWriteLock

QMutex只允许某个时刻有一个线程对共享资源进行访问，如果需要多个线程对共享资源进行读访问，同时只有一个线程进行写访问，这种情况下就可以使用QReadWriteLock。QReadWriteLock主要实现多个线程读资源，一个线程写。写线程执行的时候会阻塞所有的读线程，而读线程之间的运行不需要进行同步。使用示例如下：

int var;
QReadWriteLock lock;
 
void function()
{
   
    lock.lockForRead();
    int x = var;
    lock.unlock();
}
 
void function2()
{
   
    lock.lockForWrite();
    var = 100;
    lock.unlock();
}

和 QMutexLocker 一样，Qt同样提供了 QReadLocker和QWriteLocker。

int var;
QReadWriteLock lock;
 
void fun()
{
    QReadLocker(&lock);
    int x = var;
}
 
void fun2()
{
    QWriteLocker(&lock);
    var = 1000;
}

QSemaphore

QSemaphore是QMutex的一般化，它可以保护一定数量的相同资源，而QMutex只能保护一个资源。信号量比互斥量具有更好的并发性，我们可以利用信号量实现生产者-消费者模式，如下所示：

const int dataSize = 100000;
const int bufferSize = 1024;
char buffer[bufferSize];
QSemaphore freeBytes(bufferSize);
QSemaphore usedButes;
 
void Producer::run()
{
   
    for (int i = 0; i < dataSize; ++i)
    {
   
        freeBytes.acquire();
        buffer[i % bufferSize] = i;
        usedBytes.release();
    }
}
 
void Consumer::run()
{
   
    for (int i = 0; i < dataSize; ++i)
    {
   
        usedBytes.acquire();
        qDebug() << buffer[i % bufferSize];
        freeBytes.release();
    }
}

多线程队列、阻塞队列

Qt QQueue 安全的多线程队列、阻塞队列

4 Qt QJson

Qt QJson 使用

5 智能指针

1）QPointer

特点： 当其指向的对象(T必须是QObject及其派生类)被销毁时，它会被自动置NULL.

注意： 它本身析构时不会自动销毁所guarded的对象

用途： 当你需要保存其他人所拥有的QObject对象的指针时，这点非常有用

2）QScopedPointer QScopedArraytPointer与 std::unique_ptr/scoped_ptr

这是一个很类似auto_ptr的智能指针，它包装了new操作符在堆上分配的动态对象，能够保证动态创建的对象在任何时候都可以被正确地删除。但它的所有权更加严格，不能转让，一旦获取了对象的管理权，你就无法再从它那里取回来。

无论是QScopedPointer 还是 std::unique_ptr 都拥有一个很好的名字，它向代码的阅读者传递了明确的信息：这个智能指针只能在本作用域里使用，不希望被转让。因为它的拷贝构造和赋值操作都是私有的，这点我们可以对比QObject及其派生类的对象哈。

unique_ptr 是 C++11 才开始提供的类型，是一种在异常时可以帮助避免资源泄漏的智能指针。采用独占式拥有，意味着可以确保一个对象和其相应的资源同一时间只被一个 pointer 拥有。一旦拥有者被销毁或编程 empty，或开始拥有另一个对象，先前拥有的那个对象就会被销毁，其任何相应资源亦会被释放。（interview）

3）QSharedPointer QSharedArrayPointer 与 std::shared_ptr

QSharedPointer 与 std::shared_ptr 行为最接近原始指针，是最像指针的"智能指针"，应用范围比前面的提到的更广。

QSharedPointer 与 QScopedPointer 一样包装了new操作符在堆上分配的动态对象，但它实现的是引用计数型的智能指针，可以被自由地拷贝和赋值，在任意的地方共享它，当没有代码使用（引用计数为0）它时才删除被包装的动态分配的对象。shared_ptr也可以安全地放到标准容器中，并弥补了std::auto_ptr 和 QScopedPointer 因为转移语义而不能把指针作为容器元素的缺陷。

多个智能指针可以共享同一个对象，对象的最末一个拥有着有责任销毁对象，并清理与该对象相关的所有资源。支持定制型删除器（custom deleter），可防范 Cross-DLL 问题（对象在动态链接库（DLL）中被 new 创建，却在另一个 DLL 内被 delete 销毁）、自动解除互斥锁 (interview)

4）QWeakPointer 与 std::weak_ptr

强引用类型的QSharedPointer已经非常好用，为什么还要有弱引用的 QWeakPointer？ QWeakPointer 是为配合 QSharedPointer 而引入的一种智能指针，它更像是 QSharedPointer 的一个助手(因为它不具有普通指针的行为，没有重载operator*和->)。

它的最大作用在于协助 QSharedPointer 工作，像一个旁观者一样来观测资源的使用情况。

weak_ptr 主要是为了避免强引用形成环状。摘自msdn中一段话：

A cycle occurs when two or more resources controlled by shared_ptr objects hold mutually referencing shared_ptr objects. For example, a circular linked list with three elements has a head node N0; that node holds a shared_ptr object that owns the next node, N1; that node holds a shared_ptr object that owns the next node, N2; that node, in turn, holds a shared_ptr object that owns the head node, N0, closing the cycle. In this situation, none of the reference counts will ever become zero, and the nodes in the cycle will not be freed. To eliminate the cycle, the last node N2 should hold a weak_ptr object pointing to N0 instead of a shared_ptr object. Since the weak_ptr object does not own N0 it doesn’t affect N0’s reference count, and when the program’s last reference to the head node is destroyed the nodes in the list will also be destroyed.

在Qt中，对于QObject及其派生类对象，QWeakPointer有特殊处理。它可以作为QPointer的替代品这种情况下，不需要QSharedPointer的存在

weak_ptr 允许你共享但不拥有某对象，一旦最末一个拥有该对象的智能指针失去了所有权，任何 weak_ptr 都会自动成空（empty）。因此，在 default 和 copy 构造函数之外，weak_ptr 只提供 “接受一个 shared_ptr” 的构造函数。可打破环状引用（cycles of references，两个其实已经没有被使用的对象彼此互指，使之看似还在 “被使用” 的状态）的问题 (interview)

5）QSharedDataPointer

这是为配合 QSharedData 实现隐式共享(写时复制 copy-on-write))而提供的便利工具。

Qt中众多的类都使用了隐式共享技术，比如QPixmap、QByteArray、QString、…。而我们为自己的类实现隐式共享也很简单，比如要实现一个 Employee类：定义一个只含有一个数据成员(QSharedDataPointer) 的 Employee 类.我们需要的所有数据成员放置于派生自QSharedData的 EmployeeData类中。

6）QExplicitlySharedDataPointe

这是为配合 QSharedData 实现显式共享而提供的便利工具。

QExplicitlySharedDataPointer 和 QSharedDataPointer 非常类似，但是它禁用了写时复制功能。这使得我们创建的对象更像一个指针。

6 Qt的d指针和p指针

保持一个库中的所有公有类的大小恒定的问题可以通过单独的私有指针给予解决。这个指针指向一个包含所有数据的私有数据结构体。这个结构体的大小可以随意改变而不会产生副作用，应用程序只使用相关的公有类，所使用的对象大小永远不会改变，它就是该指针的大小。这个指针就被称作D指针。

D指针的其他好处 :

隐藏实现细节——我们可以不提供widget.cpp文件而只提供WidgetLib和相应的头文件和二进制文件。
头文件中没有任何实现细节，可以作为API使用。
由于原本在头文件的实现部分转移到了源文件，所以编译速度有所提高。
二进制兼容

其实以上的点都很细微，自己跟过源代码的人都会了解，qt是隐藏了d指针的管理和核心源的实现。像是在_p.h中部分函数的声明，qt也宣布在以后版本中将会删除。

d_ptr指针指向父类，使用如下宏定义辅助函数和声明友元类

#ifndef D_PTR_H
#define D_PTR_H
 
#include <QObject>
 
template <typename T> static inline T *GetPtrHelper(T *ptr) {
    return ptr; }
 
#define DECLARE_PRIVATE(Class) \
    inline Class##Private* d_func() {
      return reinterpret_cast<Class##Private*>(GetPtrHelper(d_ptr)); } \
    inline const Class##Private* d_func() const {
      return reinterpret_cast<const Class##Private*>(GetPtrHelper(d_ptr)); }\
    friend class Class##Private;
 
#define DPTR(Class) Class##Private * const d  = d_func()
 
class MyClassPrivate;
 
class MyClass : public QObject {
   
    Q_OBJECT
public:
    explicit MyClass(QObject *parent = 0);
    virtual ~MyClass();
    void testFunc();
    protected:
         MyClass(MyClassPrivate &d);
 
private:
        MyClassPrivate * const d_ptr;
    DECLARE_PRIVATE(MyClass);
    MyClass(const MyClass&);
    MyClass& operator= (const MyClass&);
};
 
#endif 

#ifndef Q_PTR_H
#define Q_PTR_H
 
 
#include <QObject>
#include "d_ptr.h"
 
#define DECLARE_PUBLIC(Class) \
    inline Class* q_func() {
      return static_cast<Class *>(q_ptr); } \
    inline const Class* q_func() const {
      return static_cast<const Class *>(q_ptr); } \
    friend class Class;
 
#define QPTR(Class) Class * const q = q_func()
 
class MyClassPrivate : public QObject
{
   
Q_OBJECT
 
public:
    MyClassPrivate(MyClass *q, QObject *parent = 0);
    virtual ~MyClassPrivate() {
   }
 
signals:
    void testSgnl();
 
private slots:
    void testSlt();
 
public:
    void fool();
 
private:
    MyClass * const q_ptr;
    DECLARE_PUBLIC(MyClass);
};
 
#endif

7 QVariant使用

用户自定义需要先注册一个类型，即使用qRegisterMetaType，注册到QT的一个Vector中
QVariant里面会new一个用户自定义类型的内存，并调用拷贝构造函数，QVariant自身的赋值会使用共享内存管理所以用户可以传入一个临时变量地址，如果用户传入的是一个指针，这个指针需要用户自己析构，改变这个指针的值，并不会改变QVariant，因为是两个不同的空间了

而如果QVariant a1=b1(b1是QVariant)，改变b1的值会改变a1的。因为这样用的是shared指针

初看以为是对的，验证发现不准确，改变b1并没有改变a1的值，细看发现这里面有QT使用了个小技巧，要取b1的值然后改变时，会调用data函数

CVariantHelp* pBTemp =  reinterpret_cast<CVariantHelp*>(b1.data());
pBTemp->j_ = 99;

而data的实现会调用detach将shared分离

void* QVariant::data()
{
   
    detach();
    return const_cast<void *>(constData());
}

void QVariant::detach()
{
   
    if (!d.is_shared || d.data.shared->ref == 1)
        return;
    Private dd;
    dd.type = d.type;
    handler->construct(&dd, constData());
    if (!d.data.shared->ref.deref())
        handler->clear(&d);
    d.data.shared = dd.data.shared;
}

8 继承与派生

1）继承与派生的区别

角度不同
继承是从子类的角度讲的，派生是从基类的角度讲的。
定义不同
继承是面向对象软件技术当中的一个概念，与多态、抽象共为面向对象的三个基本特征。继承可以使得子类具有父类的属性和方法或者重新定义、追加属性和方法等。派生指江河的源头产生出支流。引申为从一个主要事物的发展中分化出来。

单继承与多继承

单继承（派生类只从一个直接基类继承）时派生类的定义：

class 派生类名：继承方式 基类名
{
   
	新增成员声明；
}

多继承时派生类的定义：

class 派生类名：继承方式1 基类名1，继承方式2 基类名2，…
{
   
	成员声明；
}

注意：每一个“继承方式”，只用于限制对紧随其后之基类的继承。

2）三种继承方式公有继承，私有继承和保护继承

继承的访问控制

基类的public和protected成员：访问属性在派生类中保持不变；
基类的private成员：不可直接访问。
访问权限

派生类中的成员函数：可以直接访问基类中的public和protected成员，但不能直接访问基类的private成员；
通过派生类的对象：只能访问public成员。
公有派生类对象可以被当作基类的对象使用，反之则不可。

派生类的对象可以隐含转换为基类对象；
派生类的对象可以初始化基类的引用；
派生类的指针可以隐含转换为基类的指针。
通过基类对象名、指针只能使用从基类继承的成员，派生类新增的成员就不能使用了

9 Qwidget、Qobejct实现的功能

1）QObject

信号和槽的非常强大的机制,使用connect()把信号和槽连接起来并且可以用disconnect()来破坏这种连接。为了避免从不结束的通知循环，你可以调用blockSignals()临时地阻塞信号。保护函数connectNotify()和disconnectNotify()使跟踪连接成为可能。
QObject可以通过event()接收事件并且过滤其它对象的事件。详细情况请参考installEventFilter()和eventFilter()。一个方便的处理者，childEvent()，能够被重新实现来捕获子对象事件。
最后但不是最不重要的一点，QObject提供了Qt中最基本的定时器，关于定时器的高级支持请参考QTimer。
注意Q_OBJECT宏对于任何实现信号、槽和属性的对象都是强制的。
所有的Qt窗口部件继承了QObject。方便的函数 isWidgetType() 返回这个对象实际上是不是一个窗口部件。它比inherits(“QWidget” )快得多。