【C\C++】C++11 智能指针所有使用场景及实例代码

最新推荐文章于 2024-02-19 15:57:13 发布

Michael_Good

最新推荐文章于 2024-02-19 15:57:13 发布

阅读量1k

点赞数 1

分类专栏： C++11 文章标签： c++ c语言开发语言

本文链接：https://blog.csdn.net/qq_37286579/article/details/130283415

版权

C++11 专栏收录该内容

26 篇文章 1 订阅

订阅专栏

线程间应用

使用 std::unique_ptr 管理动态分配的对象，并在多个线程中共享：

class MyObject {
public:
    void doSomething() {
        // ...
    }
};

void threadFunc(std::unique_ptr<MyObject> obj) {
    obj->doSomething();
}

int main() {
    std::unique_ptr<MyObject> obj(new MyObject());
    std::thread t1(threadFunc, std::move(obj));
    std::thread t2(threadFunc, std::move(obj));
    t1.join();
    t2.join();
    // obj会在离开作用域时自动释放内存
    return 0;
}

在这个例子中，MyObject 对象被动态分配，并使用 std::unique_ptr 管理其生命周期。然后，两个线程分别使用 std::move 将 std::unique_ptr 转移给线程函数 threadFunc，并在函数中使用对象。由于 std::unique_ptr 是独占所有权的智能指针，因此在转移后，原始的 std::unique_ptr 将不再拥有对象的所有权（这里是直接夺权了吗？如何证明 t2 夺取了 t1 的独占式智能指针的使用权），避免了多个线程同时访问同一个对象的问题。（那如果后续t1又要使用，会夺取回去吗？）

使用 std::shared_ptr 管理动态分配的对象，并在多个线程中共享：

class MyObject {
public:
    void doSomething() {
        // ...
    }
};

void threadFunc(std::shared_ptr<MyObject> obj) {
    obj->doSomething();
}

int main() {
    std::shared_ptr<MyObject> obj(new MyObject());
    std::thread t1(threadFunc, obj);
    std::thread t2(threadFunc, obj);
    t1.join();
    t2.join();
    // obj会在离开作用域时自动释放内存
    return 0;
}

在这个例子中，MyObject 对象被动态分配，并使用 std::shared_ptr 管理其生命周期。然后，两个线程分别使用 std::shared_ptr 共享对象，并在函数中使用对象。由于 std::shared_ptr 是共享所有权的智能指针，因此多个线程可以同时访问同一个对象，由智能指针来管理对象的生命周期，避免了多个线程同时访问或释放同一个对象的问题。（如何使用 gdb 确认当前智能共享指针引用计数）

这些例子展示了智能指针的更复杂的用法，包括在多线程编程中共享资源、使用独占所有权和共享所有权的智能指针等。智能指针是一种非常有用的C++语言特性，可以提高程序的健壮性和可维护性。

类内应用

以下是更复杂的例子，展示了智能指针的使用场景：

使用 std::unique_ptr 管理动态分配的对象，并在类中使用：

class MyClass {
public:
    MyClass(std::unique_ptr<MyObject> obj) : m_obj(std::move(obj)) {}
private:
    std::unique_ptr<MyObject> m_obj;
};

int main() {
    std::unique_ptr<MyObject> obj(new MyObject());
    MyClass myClass(std::move(obj));
    // obj会在离开作用域时自动释放内存
    return 0;
}

在这个例子中，MyObject 对象被动态分配，并使用 std::unique_ptr 管理其生命周期。然后，std::unique_ptr 被转移给类 MyClass 的成员变量 m_obj，由智能指针来管理对象的生命周期，避免了手动释放内存的问题。

使用 std::shared_ptr 管理动态分配的对象，并在类中使用：

class MyClass {
public:
    MyClass(std::shared_ptr<MyObject> obj) : m_obj(obj) {}
private:
    std::shared_ptr<MyObject> m_obj;
};

int main() {
    std::shared_ptr<MyObject> obj(new MyObject());
    MyClass myClass(obj);
    // obj会在离开作用域时自动释放内存
    return 0;
}

在这个例子中，MyObject 对象被动态分配，并使用 std::shared_ptr 管理其生命周期。然后，std::shared_ptr 被传递给类 MyClass 的成员变量 m_obj，由智能指针来管理对象的生命周期，避免了手动释放内存的问题。

使用 std::unique_ptr 管理动态分配的对象，并在容器中存储：

std::vector<std::unique_ptr<MyObject>> vec;
vec.push_back(std::unique_ptr<MyObject>(new MyObject()));
// vec会在离开作用域时自动释放内存

在这个例子中，MyObject 对象被动态分配，并使用 std::unique_ptr 管理其生命周期。然后，std::unique_ptr 被转移给容器 std::vector，由智能指针来管理对象的生命周期，避免了手动释放内存的问题。

使用 std::shared_ptr 管理动态分配的对象，并在容器中存储：

std::vector<std::shared_ptr<MyObject>> vec;
vec.push_back(std::shared_ptr<MyObject>(new MyObject()));
// vec会在离开作用域时自动释放内存

在这个例子中，MyObject 对象被动态分配，并使用 std::shared_ptr 管理其生命周期。然后，std::shared_ptr 被传递给容器 std::vector，由智能指针来管理对象的生命周期，避免了手动释放内存的问题。

这些例子展示了智能指针的更复杂的用法，包括在类中使用、在容器中存储等。

异常场景应用

以下是更复杂的例子，展示了智能指针的使用场景：

使用 std::unique_ptr 管理动态分配的对象，并在异常发生时自动释放内存：

void foo() {
    std::unique_ptr<MyObject> obj(new MyObject());
    // do some operations on obj
    if (someCondition) {
        throw std::runtime_error("something went wrong");
    }
    // obj会在离开作用域时自动释放内存
}

int main() {
    try {
        foo();
    } catch (const std::exception& e) {
        // handle exception
    }
    return 0;
}

在这个例子中，MyObject 对象被动态分配，并使用 std::unique_ptr 管理其生命周期。然后，在函数 foo 中进行一些操作，如果发生异常，则会在函数退出时自动释放内存，避免了内存泄漏的问题。

使用 std::shared_ptr 管理动态分配的对象，并在异常发生时自动释放内存：

void foo() {
    std::shared_ptr<MyObject> obj(new MyObject());
    // do some operations on obj
    if (someCondition) {
        throw std::runtime_error("something went wrong");
    }
    // obj会在离开作用域时自动释放内存
}

int main() {
    try {
        foo();
    } catch (const std::exception& e) {
        // handle exception
    }
    return 0;
}

在这个例子中，MyObject 对象被动态分配，并使用 std::shared_ptr 管理其生命周期。然后，在函数 foo 中进行一些操作，如果发生异常，则会在函数退出时自动释放内存，避免了内存泄漏的问题。

使用 std::weak_ptr 避免循环引用：

class B;

class A {
public:
    void setB(std::shared_ptr<B> b) {
        m_b = b;
    }
private:
    std::weak_ptr<B> m_b;
};

class B {
public:
    void setA(std::shared_ptr<A> a) {
        m_a = a;
    }
private:
    std::weak_ptr<A> m_a;
};

int main() {
    std::shared_ptr<A> a(new A());
    std::shared_ptr<B> b(new B());
    a->setB(b);
    b->setA(a);
    // a和b会在离开作用域时自动释放内存，避免循环引用导致的内存泄漏
    return 0;
}

在这个例子中，类 A 和 B 互相引用，如果使用 std::shared_ptr 相互持有，会导致循环引用，从而导致内存泄漏。为了避免这个问题，可以使用 std::weak_ptr 来解决循环引用的问题，避免内存泄漏。

这些例子展示了智能指针的更复杂的用法，包括异常安全、避免循环引用等。

结合 Lambda 表达式的应用

使用 std::unique_ptr 管理动态分配的对象，并在lambda表达式中使用：

std::unique_ptr<MyObject> obj(new MyObject());
auto lambda = [ptr = std::move(obj)]() {
    // do some operations on ptr
};
// obj会在离开作用域时自动释放内存

在这个例子中，MyObject 对象被动态分配，并使用 std::unique_ptr 管理其生命周期。然后，使用 std::move 将 std::unique_ptr 转移给lambda表达式，并在表达式中使用对象。由于 std::unique_ptr 是独占所有权的智能指针，因此在转移后，原始的 std::unique_ptr 将不再拥有对象的所有权，避免了手动释放内存的问题。

使用 std::shared_ptr 管理动态分配的对象，并在lambda表达式中使用：

std::shared_ptr<MyObject> obj(new MyObject());
auto lambda = [ptr = obj]() {
    // do some operations on ptr
};
// obj会在离开作用域时自动释放内存

在这个例子中，MyObject 对象被动态分配，并使用 std::shared_ptr 管理其生命周期。然后，使用 std::shared_ptr 传递给lambda表达式，并在表达式中使用对象。由于 std::shared_ptr 是共享所有权的智能指针，因此多个lambda表达式可以同时访问同一个对象，由智能指针来管理对象的生命周期，避免了多个lambda表达式同时访问或释放同一个对象的问题。

Michael_Good

关注

1
点赞
踩
9

收藏

觉得还不错? 一键收藏
0
评论
【C\C++】C++11 智能指针所有使用场景及实例代码

是共享所有权的智能指针，因此多个线程可以同时访问同一个对象，由智能指针来管理对象的生命周期，避免了多个线程同时访问或释放同一个对象的问题。如何证明 t2 夺取了 t1 的独占式智能指针的使用权），避免了多个线程同时访问同一个对象的问题。这些例子展示了智能指针的更复杂的用法，包括在多线程编程中共享资源、使用独占所有权和共享所有权的智能指针等。是共享所有权的智能指针，因此多个lambda表达式可以同时访问同一个对象，由智能指针来管理对象的生命周期，避免了多个lambda表达式同时访问或释放同一个对象的问题。
复制链接

扫一扫