C++知识学习

最新推荐文章于 2024-09-17 23:15:52 发布

qq_47258321

最新推荐文章于 2024-09-17 23:15:52 发布

阅读量58

点赞数

文章标签：学习

本文链接：https://blog.csdn.net/qq_47258321/article/details/129782138

版权

（一）异常处理

C++ 异常处理机制是一种用于处理程序运行时错误的机制，它允许程序在出现异常情况时能够恰当地处理并从错误中恢复。在 C++ 中，异常是指程序执行过程中发生的一些不可预测的错误，例如内存分配失败、数组越界、除以零等。

C++ 的异常处理机制主要包括三个关键字：try、throw 和 catch。

try 关键字用于捕获异常，通常会将可能出现异常的代码块放在 try 块中，如果发生了异常，就会抛出一个异常对象。

throw 关键字用于抛出一个异常对象，可以将任意类型的对象作为异常抛出，通常是在 try 块中使用。

catch 关键字用于捕获异常并进行处理，通常会将处理异常的代码块放在 catch 块中，可以捕获特定类型的异常，也可以使用省略号 ... 来捕获所有类型的异常。

下面是一个简单的 C++ 异常处理的示例代码：

#include <iostream>

void foo(int x) {
    if (x == 0) {
        throw "x cannot be zero";
    }
    std::cout << "x = " << x << std::endl;
}

int main() {
    try {
        foo(0);
    } catch (const char* msg) {
        std::cerr << "Exception caught: " << msg << std::endl;
    }
    return 0;
}

在上面的代码中，foo 函数接收一个参数 x，如果 x 为 0，则会抛出一个字符串类型的异常，表示 x 不能为零。在 main 函数中，我们将 foo 函数的参数设置为 0，然后使用 try-catch 块捕获异常。如果 foo 函数抛出了异常，则会进入 catch 块中，打印异常信息。

需要注意的是，在 C++ 中，异常处理机制会带来一些性能开销，因此应该尽量避免不必要的异常，只在必要时使用。此外，也需要注意在异常处理过程中的资源释放和异常安全问题。

（二）多线程编程

C++ 多线程是一种并发编程模型，它允许程序通过创建多个线程来并发执行多个任务，从而提高程序的执行效率和响应速度。在 C++ 中，使用标准库提供的 std::thread 类可以创建多个线程，同时也提供了一些同步和互斥机制，以确保多个线程之间的协同工作。

1. 线程创建：使用 std::thread 类可以创建新的线程。可以将一个函数或者一个函数对象作为参数传递给 std::thread 的构造函数，这个函数或对象将在新线程中执行。例如：

#include <thread>
#include <iostream>

void myThreadFunc() {
    std::cout << "This is my thread." << std::endl;
}

int main() {
    std::thread myThread(myThreadFunc);
    myThread.join();
    return 0;
}

上面的代码中，我们创建了一个名为 myThread 的线程，并将函数 myThreadFunc 作为参数传递给了它的构造函数。这个线程在启动后，将会执行 myThreadFunc 函数中的代码。在主线程中，调用了 join 函数来等待子线程执行结束。

2. 线程同步：在线程之间进行同步可以确保它们按照正确的顺序执行，从而避免出现竞争条件和死锁。C++ 标准库提供了一些同步机制，例如互斥锁（std::mutex）、条件变量（std::condition_variable）和原子变量（std::atomic）。

互斥锁用于控制对共享资源的访问，保证在任何时候只有一个线程可以访问共享资源，从而避免出现竞争条件。例如：

#include <thread>
#include <mutex>
#include <iostream>

std::mutex myMutex;

void myThreadFunc() {
    std::lock_guard<std::mutex> myLock(myMutex);
    std::cout << "This is my thread." << std::endl;
}

int main() {
    std::thread myThread(myThreadFunc);
    {
        std::lock_guard<std::mutex> myLock(myMutex);
        std::cout << "This is main thread." << std::endl;
    }
    myThread.join();
    return 0;
}

上面的代码中，我们在 myThreadFunc 函数中使用了互斥锁 myMutex，保证了在任何时候只有一个线程可以访问 std::cout，从而避免了输出混乱的问题。

3. 线程互斥：线程互斥是指多个线程之间相互等待，以获得资源或锁的情况。当两个或多个线程试图同时访问同一共享资源或锁时，可能会发生死锁。例如：

#include <iostream>
#include <thread>
#include <mutex>

std::mutex mtx;

void threadFunction() {
    std::lock_guard<std::mutex> lock(mtx); // 加锁
    std::cout << "Hello from thread!" << std::endl;
} // 解锁

int main() {
    std::thread t(threadFunction);
    t.join();
    return 0;
}

上述代码中使用 std::mutex 实现了对 std::cout 输出流的互斥，确保只有一个线程能够输出。

4. 死锁：当多个线程相互等待对方释放资源时，就会发生死锁。C++ 中的死锁通常发生在使用多个互斥量时，如果不正确地控制互斥量的获取和释放顺序，就可能导致死锁。例如：

#include <iostream>
#include <thread>
#include <mutex>

std::mutex mtx1, mtx2;

void threadFunction1() {
    std::lock_guard<std::mutex> lock1(mtx1);
    std::lock_guard<std::mutex> lock2(mtx2); // 线程 1 先获取 mtx1，再获取 mtx2
    std::cout << "Hello from thread 1!" << std::endl;
}

void threadFunction2() {
    std::lock_guard<std::mutex> lock2(mtx2);
    std::lock_guard<std::mutex> lock1(mtx1); //

多线程编程的优化和调试方法是多线程开发中非常重要的一部分。下面是一些常见的优化和调试方法：