QT智能指针与std智能指针性能测试

---

测试思路

产生一个3000万次的迭代，在每次迭代中进行一次指针的创建和传递，用chrono库来记录时间，测试一下不同指针的维护成本

测试环境

qt6.5.3创建的控制台程序

测试结果

根据下表可知，独占式智能指针无论是std的还是qt中的，效率基本和裸指针一样，unique_ptr比QScopedPointer慢，推测是move操作导致的，共享式智能指针效率低，主要是维护内部引用计数导致的

指针类型	运行时间(ms)
unique_ptr	3954
shared_ptr	8346
QScopedPointer	3568
QSharedPointer	10692
bare pointer	3436

测试代码

#include <QCoreApplication>
#include <QDebug>
#include <QSharedPointer>
#include <chrono>

class MyClass
{
public:
    MyClass(int value)
        : value_(value)
    {}

    int getValue() const { return value_; }

private:
    int value_;
};

void func1(QSharedPointer<MyClass> ptr);
void func2(std::shared_ptr<MyClass> ptr);
void func3(MyClass *ptr);
void func4(std::unique_ptr<MyClass> ptr);
void func5(MyClass *ptr);

void testSharedPointer()
{
    auto startTime = std::chrono::high_resolution_clock::now();

    for (int i = 0; i < 30000000; ++i) {
        QSharedPointer<MyClass> ptr(new MyClass(i));

        // 多次参数传递
        func1(ptr);
    }

    auto endTime = std::chrono::high_resolution_clock::now();
    auto elapsedTime = std::chrono::duration_cast<std::chrono::milliseconds>(endTime - startTime)
                           .count();
    qDebug() << "QSharedPointer elapsed time:" << elapsedTime << "ms";
}

void testStdSharedPointer()
{
    auto startTime = std::chrono::high_resolution_clock::now();

    for (int i = 0; i < 30000000; ++i) {
        std::shared_ptr<MyClass> ptr(new MyClass(i));

        // 多次参数传递
        func2(ptr);
    }

    auto endTime = std::chrono::high_resolution_clock::now();
    auto elapsedTime = std::chrono::duration_cast<std::chrono::milliseconds>(endTime - startTime)
                           .count();
    qDebug() << "std::shared_ptr elapsed time:" << elapsedTime << "ms";
}

void testQScopedPointer()
{
    auto startTime = std::chrono::high_resolution_clock::now();

    for (int i = 0; i < 30000000; ++i) {
        QScopedPointer<MyClass> ptr(new MyClass(i));

        // 多次参数传递
        func3(ptr.data());
    }

    auto endTime = std::chrono::high_resolution_clock::now();
    auto elapsedTime = std::chrono::duration_cast<std::chrono::milliseconds>(endTime - startTime)
                           .count();
    qDebug() << "QScopedPointer elapsed time:" << elapsedTime << "ms";
}

void testStdUniquePointer()
{
    auto startTime = std::chrono::high_resolution_clock::now();

    for (int i = 0; i < 30000000; ++i) {
        std::unique_ptr<MyClass> ptr(new MyClass(i));

        // 多次参数传递
        func4(std::move(ptr));
    }

    auto endTime = std::chrono::high_resolution_clock::now();
    auto elapsedTime = std::chrono::duration_cast<std::chrono::milliseconds>(endTime - startTime)
                           .count();
    qDebug() << "std::unique_ptr elapsed time:" << elapsedTime << "ms";
}

void func1(QSharedPointer<MyClass> ptr)
{
    int value = ptr->getValue();
    Q_UNUSED(value); //消除编译器警告
}

void func2(std::shared_ptr<MyClass> ptr)
{
    int value = ptr->getValue();
    Q_UNUSED(value); //消除编译器警告
}

void func3(MyClass *ptr)
{
    int value = ptr->getValue();
    Q_UNUSED(value); //消除编译器警告
}

void func4(std::unique_ptr<MyClass> ptr)
{
    int value = ptr->getValue();
    Q_UNUSED(value); //消除编译器警告
}

void testBarePointer()
{
    auto startTime = std::chrono::high_resolution_clock::now();

    for (int i = 0; i < 30000000; ++i) {
        MyClass *ptr = new MyClass(i);

        // 多次参数传递
        func5(ptr);
        delete ptr;
    }

    auto endTime = std::chrono::high_resolution_clock::now();
    auto elapsedTime = std::chrono::duration_cast<std::chrono::milliseconds>(endTime - startTime)
                           .count();
    qDebug() << "Bare pointer elapsed time:" << elapsedTime << "ms";
}

void func5(MyClass *ptr)
{
    int value = ptr->getValue();
    Q_UNUSED(value);
}

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

    testSharedPointer();
    testStdSharedPointer();
    testQScopedPointer();
    testStdUniquePointer();
    testBarePointer();

    return a.exec();
}