程序崩溃后自动重启 qt c++ 利用QProcess类实现重启

1.概要

记忆要点

捕获异常的方法

try {
        //正常运行
    } catch (const std::exception &e) {
        //捕获异常重启自己
    } catch (...) {
       //捕获异常重启自己     
    }

重启自己的方法

QMessageBox::critical(nullptr, "Error", "Program encountered an error and will restart.");

        // 获取当前程序的路径
        QString program = QApplication::applicationFilePath();

        // 使用QProcess启动新的实例
        QProcess::startDetached(program);

        // 退出当前实例
        return -1;  // 非正常退出代码

2.内容

在使用Qt进行C++开发时，如果希望在程序崩溃后自动重启，可以通过捕获异常或利用信号槽机制来检测程序异常状态，然后使用QProcess类来启动新的实例并关闭当前实例。然而，直接捕获所有崩溃（如段错误等）并非总是可行的，因为这通常需要操作系统级别的支持。但我们可以模拟一些异常处理，并在某些可捕获的异常情况下实现自动重启。

以下是一个简单的示例，展示如何在捕获到异常时使用QProcess类重启应用程序：

1. 主程序：设置一个简单的Qt应用程序，在其中模拟异常，并在捕获异常时尝试重启。

2. 使用QProcess重启：在捕获到异常后，使用QProcess::startDetached来启动新的程序实例，并退出当前实例。

#include <QApplication>
#include <QPushButton>
#include <QProcess>
#include <QMessageBox>
#include <exception>

void simulateCrash() {
    // 模拟一个异常，例如抛出一个std::runtime_error
    throw std::runtime_error("Simulated crash");
}

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

    try {
        QPushButton button("Click to Simulate Crash");
        QObject::connect(&button, &QPushButton::clicked, &simulateCrash);
        button.show();

        int ret = app.exec();  // 进入事件循环

        // 正常情况下不会到达这里，因为exec()不会返回直到应用程序退出
        return ret;
    } catch (const std::exception &e) {
        QMessageBox::critical(nullptr, "Error", "Program encountered an error and will restart.");

        // 获取当前程序的路径
        QString program = QApplication::applicationFilePath();

        // 使用QProcess启动新的实例
        QProcess::startDetached(program);

        // 退出当前实例
        return -1;  // 非正常退出代码
    } catch (...) {
        QMessageBox::critical(nullptr, "Unknown Error", "Program encountered an unknown error and will restart.");

        // 获取当前程序的路径
        QString program = QApplication::applicationFilePath();

        // 使用QProcess启动新的实例
        QProcess::startDetached(program);

        // 退出当前实例
        return -1;  // 非正常退出代码
    }
}

说明：

1. 异常捕获：
   • 使用try-catch块来捕获std::exception和其他未知异常。
   • 在捕获到异常后，显示一个错误消息框通知用户。
2. 获取程序路径：
   • 使用QApplication::applicationFilePath()获取当前程序的路径。
3. 重启程序：
   • 使用QProcess::startDetached启动新的程序实例。startDetached会在新进程中启动程序，并且不会阻塞当前进程。
   • 退出当前实例，返回非零值表示非正常退出。

注意事项：

• 崩溃类型：这种方法只能捕获C++层面的异常，对于如段错误等低级崩溃，可能无法直接捕获。需要操作系统或特定平台的支持来捕获这些崩溃。
• 用户体验：频繁重启可能会影响用户体验，建议在实际应用中谨慎使用自动重启功能，并提供用户配置选项以禁用此功能。
• 数据保存：在重启前，确保所有必要的数据已经保存，以避免数据丢失。

3.关联链接

qt 程序崩溃后自动重启_qt 重启程序-优快云博客

使用Qt崩溃重启工具，具体方法-优快云博客

qt，c++, 程序崩溃后自动重启，利用QProcess类实现重启-优快云博客

程序崩溃后自动重启：结合Windows API捕获程序崩溃时的异常-优快云博客

程序崩溃后自动重启：结合事件循环实现-优快云博客

4.关联知识 

1.上面这个程序，我如果是多线程的情况下，也可以吗

在多线程环境中实现程序崩溃后的自动重启会变得更加复杂。主要原因在于，异常可能发生在任何线程中，而主线程可能无法直接捕获其他线程中的异常。此外，多线程程序中的资源管理和状态同步也增加了复杂性。

多线程环境中的挑战

1. 异常捕获：
   • C++标准库并不支持跨线程的异常传播。即，一个线程中抛出的异常无法直接被另一个线程捕获。
   • 每个线程需要有自己的异常处理机制。
2. 资源管理：
   • 多线程程序中，资源（如内存、文件句柄等）可能在多个线程中共享，需要确保在重启前正确释放。
3. 线程同步：
   • 在重启过程中，需要确保所有线程都已正确终止，以避免资源泄漏或不一致状态。

实现思路

要在多线程环境中实现自动重启，可以考虑以下思路：

1. 线程内异常捕获：
   • 在每个线程中使用try-catch块捕获异常，并在捕获到异常时通知主线程。
2. 主线程协调重启：
   • 主线程接收到异常通知后，负责安全地终止所有其他线程。
   • 确保所有线程都已终止后，使用QProcess重启程序。
3. 线程管理：
   • 使用线程池或类似机制来管理线程，以便更容易地跟踪和终止线程。

以下是一个简化的示例，展示如何在多线程环境中实现基本的异常捕获和重启逻辑：

#include <QApplication>
#include <QProcess>
#include <QThread>
#include <QMessageBox>
#include <QTimer>
#include <iostream>
#include <exception>
#include <atomic>
#include <vector>
#include <memory>

class WorkerThread : public QThread {
    Q_OBJECT

public:
    explicit WorkerThread(std::atomic<bool>& restartFlag, QObject* parent = nullptr)
        : QThread(parent), restartFlag_(restartFlag) {}

protected:
    void run() override {
        try {
            // 模拟工作，可能会抛出异常
            throw std::runtime_error("Thread crash simulated");
        } catch (const std::exception& e) {
            std::cerr << "Exception in thread: " << e.what() << std::endl;
            restartFlag_.store(true);  // 设置重启标志
        }
    }

private:
    std::atomic<bool>& restartFlag_;
};

class MainApp : public QObject {
    Q_OBJECT

public:
    MainApp(int argc, char* argv[])
        : QApplication(argc, argv), restartFlag(false) {
        // 创建并启动多个线程
        for (int i = 0; i < 3; ++i) {
            threads.push_back(std::make_unique<WorkerThread>(restartFlag));
            threads.back()->start();
        }

        // 设置定时器定期检查重启标志
        timer = new QTimer(this);
        connect(timer, &QTimer::timeout, this, &MainApp::checkRestartFlag);
        timer->start(1000);  // 每秒检查一次
    }

private slots:
    void checkRestartFlag() {
        if (restartFlag.load()) {
            timer->stop();  // 停止定时器
            QMessageBox::critical(nullptr, "Error", "A thread crashed. Program will restart.");

            // 获取当前程序的路径
            QString program = QApplication::applicationFilePath();

            // 使用QProcess启动新的实例
            QProcess::startDetached(program);

            // 退出当前实例
            QCoreApplication::exit(-1);
        }
    }

private:
    std::atomic<bool> restartFlag;
    std::vector<std::unique_ptr<WorkerThread>> threads;
    QTimer* timer;
};

int main(int argc, char* argv[]) {
    MainApp app(argc, argv);
    return app.exec();  // 进入事件循环
}

#include "main.moc"  // 如果使用Q_OBJECT，需要这一行来生成MOC文件

说明

1. WorkerThread类：
   • 每个WorkerThread在自己的run方法中执行工作，并捕获可能的异常。
   • 如果捕获到异常，设置restartFlag以通知主线程需要重启。
2. 主线程检查：
   • 主线程在所有工作线程启动后检查restartFlag。
   • 如果restartFlag被设置为true，则显示错误消息框并使用QProcess重启程序。
3. 简化处理：
   • 示例中简化了线程管理和同步，实际应用中需要更复杂的机制来确保所有线程安全终止。

注意事项

• 线程安全：确保对共享资源（如restartFlag）的访问是线程安全的。
• 线程终止：在实际应用中，可能需要更复杂的逻辑来安全地终止线程，例如使用信号槽机制或条件变量。
• 用户体验：频繁重启可能会影响用户体验，尤其是在多线程应用中，建议提供用户配置选项以禁用自动重启功能。

2.std::atomic<bool> restartFlag(false);

std::atomic<bool> restartFlag(false); 是 C++ 中使用 std::atomic 模板定义的一个原子布尔变量，并将其初始化为 false。

解释：

1. std::atomic:
   • std::atomic 是 C++11 引入的标准库模板，用于支持原子操作。
   • 原子操作是指不可分割的操作，即不会被线程调度或其他因素中断。在多线程环境下，使用 std::atomic 可以避免数据竞争，并且无需手动加锁。
2. bool 类型:
   • 这里定义了一个原子布尔变量，可以存储 true 或 false。
3. 初始化:
   • 使用 false 对 restartFlag 进行初始化，表示该变量的初始值是 false。

应用场景：

这个变量在多线程程序中非常有用。例如：

• 作为一个标志位，用于控制线程的启动、停止或重启。
• 由于是原子类型，多个线程可以安全地读取和修改 restartFlag，而不需要担心竞争条件。

示例代码：

以下是一个简单的使用场景：

#include <atomic>
#include <iostream>
#include <thread>

std::atomic<bool> restartFlag(false);

void worker() {
    while (!restartFlag.load()) {  // 原子地检查 restartFlag 的值
        std::cout << "Working..." << std::endl;
        std::this_thread::sleep_for(std::chrono::milliseconds(500));
    }
    std::cout << "Worker thread stopping..." << std::endl;
}

int main() {
    std::thread t(worker);

    std::this_thread::sleep_for(std::chrono::seconds(2));
    std::cout << "Setting restartFlag to true..." << std::endl;
    restartFlag.store(true);  // 原子地设置 restartFlag 的值

    t.join();  // 等待线程结束
    return 0;
}

输出示例：

Working...
Working...
Working...
Setting restartFlag to true...
Worker thread stopping...

总结：

• std::atomic<bool> restartFlag(false); 定义了一个初始值为 false 的原子布尔变量。
• 它的主要优势是在多线程环境下可以避免数据竞争，保证操作的线程安全性。

3.std::atomic 

std::atomic 是 C++11 引入的一个模板类，用于支持多线程环境下的原子操作。它提供了一种无锁机制，允许多个线程安全地对同一个变量进行读写，避免了竞争条件和数据竞争问题。

主要特性

1. 线程安全：std::atomic 类型的变量可以在多个线程中安全地访问和修改，而无需显式使用锁。
2. 原子操作：支持多种原子操作，如加载（load）、存储（store）、交换（exchange）、比较并交换（compare_exchange_weak/compare_exchange_strong）等。
3. 类型支持：std::atomic 是一个模板类，支持多种基础类型，如整型、指针类型等（需要注意某些复杂类型可能不被支持）。

常见用法

1. 声明原子变量

#include <atomic>


std::atomic<int> counter(0);

2. 基本操作

#include <iostream>
#include <atomic>
#include <thread>

std::atomic<int> counter(0);

void increment() {
    for (int i = 0; i < 1000; ++i) {
        counter++;  // 等价于 counter.fetch_add(1)
    }
}

int main() {
    std::thread t1(increment);
    std::thread t2(increment);

    t1.join();
    t2.join();

    std::cout << "Counter: " << counter << std::endl;  // 输出 2000
    return 0;
}

3. 比较并交换

std::atomic<int> value(10);

int expected = 10;
bool result = value.compare_exchange_strong(expected, 20);

if (result) {
    std::cout << "交换成功，新值为: " << value.load() << std::endl;
} else {
    std::cout << "交换失败，当前值为: " << value.load() << std::endl;
}

注意事项

1. 性能开销：虽然 std::atomic 提供了方便的原子操作，但相比普通的非原子变量，它可能会有一定的性能开销。
2. 适用场景：std::atomic 适合用于简单的计数器、标志变量等场景。如果需要处理复杂的数据结构，请考虑其他同步机制（如互斥锁）。
3. 类型限制：std::atomic 对某些类型（如 std::string）不直接支持。

总结

std::atomic 是多线程编程中非常重要的工具，可以简化线程间的同步操作，避免常见的竞争条件问题。但在使用时也需要注意其适用场景和性能开销。

4.多线程模式下重启自己，包含段指针异常等崩溃的情况

qt，c++, 程序崩溃后自动重启，多线程模式下，任何线程崩溃都重启自己，使用QProcess重启自己，重启的时候要考虑到线程的互斥，别重启重复了

你说得对，我们可以在之前的多线程示例基础上添加自动重启的逻辑和互斥机制。让我们来完善这个示例，使其包含多线程操作，并确保在任何一个线程崩溃时，程序能够自动重启。

多线程示例代码

#include <QCoreApplication>
#include <QThread>
#include <QMutex>
#include <QMutexLocker>
#include <QProcess>
#include <QDebug>
#include <csignal>
#include <exception>

// 全局变量，用于控制重启逻辑
QMutex restartMutex;
bool restarting = false;

// 信号处理程序
void signalHandler(int signal) {
    qDebug() << "Signal (" << signal << ") received.";
    QMutexLocker locker(&restartMutex);
    if (!restarting) {
        restarting = true;
        // 可以在这里执行一些清理操作
        QCoreApplication::quit();
        QProcess::startDetached(QCoreApplication::applicationFilePath());
    }
}

// 一个简单的工作线程类
class WorkerThread : public QThread {
    Q_OBJECT
protected:
    void run() override {
        try {
            while (true) {
                qDebug() << "Thread" << QThread::currentThreadId() << "running...";
                QThread::sleep(1);

                // 模拟崩溃（取消下面的注释以测试崩溃重启）
                // int *p = nullptr;
                // *p = 42;  // 这行代码会引发段错误
            }
        } catch (const std::exception &e) {
            qDebug() << "Exception caught in thread" << QThread::currentThreadId() << ":" << e.what();
            handleRestart();
        } catch (...) {
            qDebug() << "Unknown exception caught in thread" << QThread::currentThreadId();
            handleRestart();
        }
    }

    void handleRestart() {
        QMutexLocker locker(&restartMutex);
        if (!restarting) {
            restarting = true;
            // 可以在这里执行一些清理操作
            QCoreApplication::quit();
            QProcess::startDetached(QCoreApplication::applicationFilePath());
        }
    }
};

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

    // 安装信号处理程序
    std::signal(SIGSEGV, signalHandler);
    std::signal(SIGABRT, signalHandler);

    // 创建并启动多个工作线程
    WorkerThread workerThread1;
    WorkerThread workerThread2;
    workerThread1.start();
    workerThread2.start();

    return a.exec();
}

#include "main.moc"

关键点说明

1. 多线程：
   • 创建了两个 WorkerThread 实例（workerThread1 和 workerThread2），并在 main 函数中启动它们。这展示了应用程序中使用多线程的方式。
2. 异常处理：
   • 每个线程在其 run 方法中包含一个 try-catch 块，用于捕获 C++ 异常。如果捕获到异常，会调用 handleRestart 方法。
3. 信号处理：
   • 使用 std::signal 安装信号处理程序，以捕获如段错误（SIGSEGV）和异常终止（SIGABRT）等信号。
   • signalHandler 函数中使用 QMutexLocker 确保 restarting 标志的检查和设置是线程安全的。
4. 重启逻辑：
   • handleRestart 方法同样使用 QMutexLocker 来检查和设置 restarting 标志，确保只有一个线程能够触发重启。
   • 调用 QCoreApplication::quit() 退出当前应用程序实例，然后使用 QProcess::startDetached 启动一个新的程序实例。
5. 线程安全：
   • 使用 QMutex 和 QMutexLocker 确保 restarting 标志的访问是线程安全的，避免多个线程同时决定重启程序。

注意事项

• 清理操作：在实际应用中，在重启前执行必要的清理操作，以确保资源被正确释放。
• 日志记录：记录崩溃和重启的日志信息，以便后续分析和调试。
• 测试：确保在目标平台上测试程序，以验证自动重启机制的正确性。

5.std::signal可以在子线程中吗

std::signal 函数通常用于在主线程中设置信号处理程序，而不是在子线程中。信号是针对进程而非单个线程发送的，因此信号处理程序在整个进程范围内有效。如果在子线程中调用 std::signal，可能会导致未定义行为，因为信号处理是进程级别的，而不是线程级别的。

关键点

1. 信号处理的范围：
   • 信号是发送给整个进程的，而不是特定的线程。因此，信号处理程序通常是在主线程中设置的。
   • 即使你在子线程中调用 std::signal，它也会影响整个进程，而不是仅仅影响该子线程。
2. 未定义行为：
   • 在多个线程中同时调用 std::signal 或在子线程中调用它可能会导致竞争条件，从而导致未定义行为。
   • 一些平台可能允许在子线程中设置信号处理程序，但这通常不被推荐，并且行为可能因平台而异。
3. 线程安全的信号处理：
   • 如果需要在多线程环境中处理信号，通常的做法是在主线程中设置信号处理程序，并确保在信号处理程序中只执行异步安全的操作。
   • 可以使用同步机制（如 QMutex）在信号处理程序中与其他线程进行通信。

推荐的做法

• 在主线程中设置信号处理程序：
  • 确保所有的信号处理程序都在主线程中设置。
  • 在信号处理程序中执行的操作应尽可能简单和快速，避免阻塞。
• 使用同步机制：
  • 如果需要在信号处理程序中与其他线程交互，使用线程安全的机制（如 QMutex、QWaitCondition 等）来实现。

以下是一个示例，展示如何在主线程中设置信号处理程序：

#include <QCoreApplication>
#include <QThread>
#include <QMutex>
#include <QMutexLocker>
#include <QDebug>
#include <csignal>
#include <exception>

// 全局变量，用于控制重启逻辑
QMutex restartMutex;
bool restarting = false;

// 信号处理程序
void signalHandler(int signal) {
    qDebug() << "Signal (" << signal << ") received.";
    QMutexLocker locker(&restartMutex);
    if (!restarting) {
        restarting = true;
        // 可以在这里执行一些清理操作
        QCoreApplication::quit();
        // 重新启动应用程序
        // QProcess::startDetached(QCoreApplication::applicationFilePath());
    }
}

// 一个简单的工作线程类
class WorkerThread : public QThread {
    Q_OBJECT
protected:
    void run() override {
        try {
            while (true) {
                qDebug() << "Thread" << QThread::currentThreadId() << "running...";
                QThread::sleep(1);
            }
        } catch (const std::exception &e) {
            qDebug() << "Exception caught in thread" << QThread::currentThreadId() << ":" << e.what();
        } catch (...) {
            qDebug() << "Unknown exception caught in thread" << QThread::currentThreadId();
        }
    }
};

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

    // 在主线程中安装信号处理程序
    std::signal(SIGSEGV, signalHandler);
    std::signal(SIGABRT, signalHandler);

    // 创建并启动多个工作线程
    WorkerThread workerThread1;
    WorkerThread workerThread2;
    workerThread1.start();
    workerThread2.start();

    return a.exec();
}

#include "main.moc"

在这个示例中，信号处理程序 signalHandler 是在主线程中设置的，并且负责处理整个进程的信号。这样可以避免在子线程中设置信号处理程序可能带来的未定义行为。

5.基础知识

1.QProcess::startDetached 

QProcess::startDetached 是 Qt 框架中的一个静态函数，用于在后台启动一个新的独立进程。与通常使用 QProcess 启动进程的方式不同，startDetached 不会将新进程与启动它的进程绑定在一起，这意味着启动的进程会继续运行，即使启动它的进程退出。

主要特性

1. 独立性：新进程独立于启动它的进程运行。启动进程退出后，新进程仍然会继续运行。
2. 后台运行：新进程在后台运行，不会阻塞启动它的进程。
3. 跨平台：提供了一个跨平台的方式来启动独立进程。

函数签名

bool QProcess::startDetached(const QString &program, const QStringList &arguments = QStringList());
bool QProcess::startDetached(const QString &program, const QStringList &arguments = QStringList(), const QString &workingDirectory = QString(), qintptr *pid = nullptr);

参数说明

• program：要启动的可执行文件的路径。
• arguments：传递给可执行文件的命令行参数。
• workingDirectory：新进程的工作目录。
• pid：如果非空，存储新进程的进程 ID。

返回值

• 返回 true 如果进程成功启动；否则返回 false。

示例

启动一个简单的进程

#include <QProcess>
#include <QString>
#include <QDebug>

int main() {
    QString program = "notepad.exe";  // 在 Windows 上启动记事本
    QStringList arguments;
    arguments << "example.txt";  // 打开名为 example.txt 的文件

    if (QProcess::startDetached(program, arguments)) {
        qDebug() << "进程启动成功！";
    } else {
        qDebug() << "进程启动失败！";
    }

    return 0;
}

启动进程并获取进程 ID

#include <QProcess>
#include <QString>
#include <QDebug>

int main() {
    QString program = "my_application";
    QStringList arguments;
    qintptr pid;

    if (QProcess::startDetached(program, arguments, QString(), &pid)) {
        qDebug() << "进程启动成功，进程 ID：" << pid;
    } else {
        qDebug() << "进程启动失败！";
    }

    return 0;
}

注意事项

1. 路径正确性：确保 program 的路径是正确的，尤其是在跨平台开发时。
2. 权限问题：启动的进程可能需要特定的权限，确保有足够的权限来启动它。
3. 资源管理：由于 startDetached 启动的进程是独立的，启动进程无法直接管理其生命周期和资源，因此需要确保新进程能够独立运行并正确管理自己的资源。

总结

QProcess::startDetached 是在 Qt 中启动独立后台进程的一个便捷方法，适用于需要在启动进程退出后继续运行的场景。使用时需要注意路径、权限和资源管理等问题。

2.QApplication::applicationFilePath() 

QApplication::applicationFilePath() 是 Qt 框架中的一个成员函数，用于获取当前应用程序可执行文件的完整路径。这个函数在需要访问应用程序自身路径的场景下非常有用，例如定位资源文件、配置文件或者日志文件等。

函数签名

QString QApplication::applicationFilePath() const;

返回值

• 返回一个 QString，表示应用程序可执行文件的完整路径。

示例

获取应用程序路径

#include <QApplication>
#include <QDebug>

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

    QString appPath = app.applicationFilePath();
    qDebug() << "应用程序路径：" << appPath;

    // 继续应用程序的其他初始化
    // ...

    return app.exec();
}

使用场景

1. 资源定位：根据应用程序的路径来定位与其同目录下的资源文件。
2. 日志记录：将日志文件存储在应用程序路径下，或者在日志中记录应用程序的启动路径。
3. 自更新程序：在需要更新应用程序时，获取当前可执行文件的路径以便替换或更新。
4. 调试信息：在调试时输出应用程序路径以帮助定位问题。

注意事项

1. 路径格式：返回的路径格式依赖于操作系统。例如，在 Windows 上路径会使用反斜杠（\），而在 Unix/Linux 系统上使用正斜杠（/）。
2. 可执行文件：该函数返回的是可执行文件的路径，而不是应用程序的工作目录。如果需要获取工作目录，可以使用 QDir::currentPath()。
3. 打包后的应用：在打包应用程序时（例如使用 Qt 的打包工具），确保路径的正确性，特别是在应用程序被移动到其他目录或设备上时。

总结

QApplication::applicationFilePath() 是一个方便的工具，用于获取应用程序可执行文件的路径。在需要访问自身路径的应用场景中，它可以极大地简化路径处理逻辑。

3.std::vector::emplace_back 

std::vector::emplace_back 是 C++11 引入的标准库方法，属于 std::vector 容器的一部分。它用于在 std::vector 的末尾直接构造一个元素。与 push_back 不同，emplace_back 可以在容器内部直接构造对象，从而避免不必要的复制或移动操作，提高性能。

使用方法

emplace_back 的语法如下：

vector.emplace_back(args...);

• args... 是传递给元素构造函数的参数。emplace_back 使用这些参数在容器的末尾就地构造对象。

优点

1. 避免拷贝或移动：对象直接在目标位置构造，无需先构造临时对象再进行拷贝或移动。
2. 性能提升：减少了临时对象的创建和销毁，尤其在处理复杂对象时性能提升显著。
3. 灵活性：支持传递构造函数所需的任意参数，能够方便地构造不同类型的对象。

示例

以下是一个简单的示例，展示了 emplace_back 的用法：

#include <iostream>
#include <vector>
#include <string>

class MyClass {
public:
    MyClass(int x, const std::string& s) : num(x), str(s) {
        std::cout << "Constructed MyClass(" << num << ", " << str << ")\n";
    }
    ~MyClass() {
        std::cout << "Destroyed MyClass(" << num << ", " << str << ")\n";
    }

    void display() const {
        std::cout << "MyClass(" << num << ", " << str << ")\n";
    }

private:
    int num;
    std::string str;
};

int main() {
    std::vector<MyClass> vec;

    // 使用 emplace_back 直接构造对象
    vec.emplace_back(1, "Apple");
    vec.emplace_back(2, "Banana");
    vec.emplace_back(3, "Cherry");

    // 遍历并输出
    for (const auto& obj : vec) {
        obj.display();
    }

    return 0;
}

输出

Constructed MyClass(1, Apple)
Constructed MyClass(2, Banana)
Constructed MyClass(3, Cherry)
MyClass(1, Apple)
MyClass(2, Banana)
MyClass(3, Cherry)
Destroyed MyClass(1, Apple)
Destroyed MyClass(2, Banana)
Destroyed MyClass(3, Cherry)

注意事项

1. 对象重新分配：当 std::vector 容量不足时，emplace_back 可能会导致重新分配内存，此时所有现有对象会被移动构造（或拷贝构造）到新位置。
2. 与 push_back 的区别：
   • push_back 需要先创建对象，然后将其拷贝（或移动）到容器中。
   • emplace_back 直接在容器内部构造对象。

总结

std::vector::emplace_back 是一种高效、灵活的方法，用于在 std::vector 末尾添加对象。它通过就地构造避免了不必要的拷贝或移动操作，非常适合需要频繁修改容器内容的场景。