知春路网站建设公司,修改wordpress用户名密码忘记,叙述网站的设计制作流程,佛山建站专文章目录 前言一、智能指针介绍二、普通指针和智能指针的比较案例三、std::shared_ptr四、std::unique_ptr五、std::weak_ptr六、std::shared_ptr |std::unique_ptr | std::weak_ptr三大智能指针的区别 前言
参考答案#xff1a;chatgpt
一、智能指针介绍
智能指针是C的一种… 文章目录 前言一、智能指针介绍二、普通指针和智能指针的比较案例三、std::shared_ptr四、std::unique_ptr五、std::weak_ptr六、std::shared_ptr |std::unique_ptr | std::weak_ptr三大智能指针的区别 前言
参考答案chatgpt
一、智能指针介绍
智能指针是C的一种对象它可以像常规指针那样用来指向堆上的数据。然而智能指针的关键优势在于**当你不再需要在堆上的数据时它们可以自动删除。**这是通过在智能指针的析构函数中调用delete来实现的当智能指针的生命周期结束时例如它离开了它的作用域它的析构函数会被自动调用。 C标准库提供了几种智能指针
std::auto_ptr这是C98标准的一部分但在C11中已被弃用C17中已被移除。它具有所有权传递语义意味着复制auto_ptr会改变原有auto_ptr的状态会失去指向对象的能力。
std::unique_ptr这是C11引入的智能指针它表现出独占所有权语义意味着在任何时间只有一个unique_ptr可以指向给定的对象。当unique_ptr被销毁例如离开其作用域时它所指向的对象也会被delete掉。 从 C14 开始建议使用 std::make_unique 函数来创建 std::unique_ptr
auto p std::make_uniqueMyClass();std::shared_ptr这也是C11引入的智能指针允许多个shared_ptr指向同一个对象。shared_ptr维护了一个引用计数当最后一个shared_ptr被销毁离开其作用域时它所指向的对象才会被delete掉。
std::weak_ptr这也是C11引入的智能指针它是对shared_ptr的补充和配合。weak_ptr指向一个由shared_ptr管理的对象但不会增加该对象的引用计数。这主要用于解决shared_ptr的循环引用问题。
后面三个智能指针用的比较多。 使用智能指针可以帮助管理动态内存避免内存泄漏。然而虽然智能指针在许多情况下都非常有用但它们并不能解决所有内存管理问题例如它们无法解决循环引用的问题除非结合使用weak_ptr。所以理解并妥善使用智能指针依然非常重要。
#include memory这个头文件在 C 中包含了许多关于内存管理的工具包括智能指针如 std::unique_ptr 和 std::shared_ptr。 回忆一下什么是内存泄露 内存泄漏是指程序中已经动态分配的堆内存由于某种原因程序未释放或者无法释放导致系统内存的浪费降低系统性能的现象。如果程序持续运行内存泄漏会导致系统可用内存逐渐下降最终可能因为没有足够的内存可用而导致系统崩溃。 例如以下是一个在 C 中产生内存泄漏的简单例子
#include iostreamint main() {while (true) {int* p new int[100]; // 分配内存但未释放}return 0;
}在这个例子中程序在一个无限循环中不断地分配内存但从未释放它。因此它会不断消耗系统内存最终可能导致系统崩溃。 解决内存泄漏的方法通常涉及找出程序中没有正确释放的内存然后修改代码以确保内存在使用后被正确释放。在一些现代编程语言中如 Java、Python、C#、Go 等提供了垃圾收集机制能够自动回收不再使用的内存从而避免内存泄漏。在 C 中使用智能指针如 std::unique_ptr 或 std::shared_ptr也可以帮助管理内存并避免内存泄漏。
二、普通指针和智能指针的比较案例
一个原始指针代码如下
#include iostreamstruct MyClass {MyClass() { std::cout MyClass constructed\n; }~MyClass() { std::cout MyClass destroyed\n; }
};int main() {MyClass* p new MyClass(); // 创建 MyClass 实例// 必须显式调用 delete 来释放内存delete p;return 0;
}在上述代码中你需要手动管理内存。你必须显式调用 delete 来释放 p 所指向的内存。如果你忘记了那就会导致内存泄漏。
智能指针
#include iostream
#include memorystruct MyClass {MyClass() { std::cout MyClass constructed\n; }~MyClass() { std::cout MyClass destroyed\n; }
};int main() {std::unique_ptrMyClass p(new MyClass()); // 创建 MyClass 实例// 不需要显式调用 delete 来释放内存// 当 p 离开作用域时它的析构函数会自动被调用释放内存return 0;
}std::unique_ptr这是一个 std::unique_ptr 模板类的实例其中的 MyClass 是模板参数指定了这个智能指针可以指向 MyClass 类型的对象。
p这是我们为智能指针变量取的名字。
new MyClass()这是使用 new 关键字创建一个新的 MyClass 对象的实例并返回其内存地址。
std::unique_ptr p(new MyClass());整个这句代码就是创建一个名为 p 的 std::unique_ptr 对象它将管理我们新创建的 MyClass 对象的内存。
这里的p()括号里是初始化的意思、std::unique_ptr p(new MyClass()); 中的 new MyClass() 是用来初始化 std::unique_ptr 的。这个表达式创建了一个 MyClass 类型的对象并返回了指向这个新创建对象的指针。然后这个指针被用来初始化 std::unique_ptr。
最后结果 接下来介绍那几种关键的智能指针
三、std::shared_ptr
下面给出一种用法
#include iostream
#include memorystruct MyClass {MyClass() { std::cout MyClass constructed\n; }~MyClass() { std::cout MyClass destroyed\n; }
};void observe(std::shared_ptrMyClass p) {std::cout Inside observe function: shared_ptr use_count: p.use_count() \n;
}int main() {// 使用 std::make_shared 创建 shared_ptrstd::shared_ptrMyClass ptr1 std::make_sharedMyClass();std::cout After ptr1 creation: shared_ptr use_count: ptr1.use_count() \n;{// 创建一个新的 shared_ptr共享 MyClass 对象的所有权std::shared_ptrMyClass ptr2 ptr1;std::cout After ptr2 creation: shared_ptr use_count: ptr1.use_count() \n;observe(ptr2);} // ptr2 离开作用域MyClass 对象的所有权计数减一std::cout After ptr2 destruction: shared_ptr use_count: ptr1.use_count() \n;// 现在只有 ptr1 拥有 MyClass 对象
} // ptr1 离开作用域MyClass 对象的所有权计数归零MyClass 对象被删除这段代码的主要目标是展示 std::shared_ptr 的用法和行为。std::shared_ptr 是一个智能指针它允许多个指针共享同一个对象的所有权。 下面是对每一部分的详细解释
首先定义了一个名为 MyClass 的结构体它有一个构造函数和一个析构函数。构造函数和析构函数都会在被调用时输出一段信息。
observe 是一个函数它接受一个 std::shared_ptr 作为参数并输出该指针的 use_count()即该指针当前的引用计数共享所有权的指针数量。
main 函数是这段代码的主要部分展示了 std::shared_ptr 的使用
使用 std::make_shared 创建了一个新的 std::shared_ptr名为 ptr1并使其指向一个新的 MyClass 实例。然后输出 ptr1 的 use_count()此时应为 1因为只有 ptr1 指向这个 MyClass 实例。
在一个新的作用域内由 {} 定义创建了一个新的 std::shared_ptr名为 ptr2并使其也指向 ptr1 所指向的 MyClass 实例。然后输出 ptr1 的 use_count()此时应为 2因为 ptr1 和 ptr2 都指向这个 MyClass 实例。
在同一作用域内调用 observe 函数并将 ptr2 作为参数传入。observe 函数会输出 ptr2 的 use_count()此时也应为 2。
当这个作用域结束即到达 }ptr2 超出其作用域并被销毁。此时 MyClass 实例的引用计数减一。然后输出 ptr1 的 use_count()此时应为 1因为只剩下 ptr1 指向这个 MyClass 实例。
当 main 函数结束ptr1 也超出其作用域并被销毁。此时 MyClass 实例的引用计数再次减一变为 0因此 MyClass 实例被删除并调用其析构函数。
总的来说这段代码展示了如何使用 std::shared_ptr 来共享一个对象的所有权并在所有指向该对象的 std::shared_ptr 都被销毁时自动删除该对象。
最后
四、std::unique_ptr
下面是一个例子
#include iostream
#include memorystruct MyClass {MyClass() { std::cout MyClass constructed\n; }~MyClass() { std::cout MyClass destroyed\n; }
};void observe(std::unique_ptrMyClass p) {if (p ! nullptr) {std::cout Inside observe function: unique_ptr is not nullptr\n;} else {std::cout Inside observe function: unique_ptr is nullptr\n;}
}int main() {// 使用 std::make_unique 创建 unique_ptrstd::unique_ptrMyClass ptr1 std::make_uniqueMyClass();observe(ptr1);// 通过 std::move 将所有权从 ptr1 转移给 ptr2std::unique_ptrMyClass ptr2 std::move(ptr1);observe(ptr1);observe(ptr2);
} // MyClass 对象被销毁因为 ptr2 超出其作用域在这段代码中首先使用 std::make_unique 创建了一个 std::unique_ptr名为 ptr1并使其指向一个新的 MyClass 实例。然后调用 observe 函数来检查 ptr1 是否为 nullptr。 接下来通过 std::move 将所有权从 ptr1 转移给新的 std::unique_ptr名为 ptr2。此时 ptr1 变为 nullptr因为所有权已经转移走了。 再次调用 observe 函数来检查 ptr1 和 ptr2。此时ptr1 应为 nullptr而 ptr2 不应为 nullptr。 当 main 函数结束时ptr2 也超出其作用域并被销毁。此时MyClass 实例也被删除并调用其析构函数。这是因为 std::unique_ptr 在超出作用域时会自动删除其所指向的对象。 五、std::weak_ptr
std::weak_ptr 是一个用于解决 std::shared_ptr 循环引用问题的智能指针。std::weak_ptr 对于对象的所有权是无影响的只是提供了一种访问共享对象的方式不会增加引用计数。 以下是一个 std::weak_ptr 的使用例子
#include iostream
#include memorystruct MyClass {MyClass() { std::cout MyClass constructed\n; }~MyClass() { std::cout MyClass destroyed\n; }
};void observe(std::weak_ptrMyClass p) {if (auto spt p.lock()) { // Must be copied into a shared_ptr before usagestd::cout Inside observe function: weak_ptr is not expired, shared_ptr use_count: spt.use_count() \n;} else {std::cout Inside observe function: weak_ptr is expired\n;}
}int main() {std::weak_ptrMyClass wptr;{// 使用 std::make_shared 创建 shared_ptrstd::shared_ptrMyClass ptr std::make_sharedMyClass();wptr ptr;observe(wptr);} // ptr 离开作用域MyClass 对象被销毁observe(wptr); // wptr 已经过期因为 MyClass 对象已经被销毁
}在这段代码中首先定义了一个 std::weak_ptr名为 wptr。 然后在一个新的作用域内由 {} 定义创建了一个 std::shared_ptr名为 ptr并使其指向一个新的 MyClass 实例。然后将 ptr 赋值给 wptr使 wptr 也指向 ptr 所指向的 MyClass 实例。 接着调用 observe 函数将 wptr 作为参数传入。在 observe 函数内部通过调用 std::weak_ptr::lock 来获取一个指向 MyClass 实例的 std::shared_ptr并输出其 use_count()。 当这个作用域结束即到达 }ptr 超出其作用域并被销毁MyClass 实例的引用计数减一变为 0因此 MyClass 实例被删除并调用其析构函数。 最后再次调用 observe 函数将 wptr 作为参数传入。此时 wptr 已经过期因为 MyClass 实例已经被销毁因此 std::weak_ptr::lock 会返回一个空的 std::shared_ptr。
六、std::shared_ptr |std::unique_ptr | std::weak_ptr三大智能指针的区别
std::shared_ptr, std::unique_ptr 和 std::weak_ptr 都是 C11 引入的智能指针它们的主要目标是提供自动化的内存管理以避免内存泄漏。然而它们之间的区别主要在于如何管理内存以及所有权语义
std::shared_ptr这是一种引用计数的智能指针。当你将一个对象的指针赋值给一个 std::shared_ptr 时它就会开始进行引用计数。如果有其他 std::shared_ptr 指向同一对象引用计数就会增加。当引用计数变为0即没有 std::shared_ptr 指向该对象时对象就会被自动删除。
std::unique_ptr这种智能指针保证了对象的唯一所有权语义。在任何时候只有一个 std::unique_ptr 可以指向一个对象。当 std::unique_ptr 超出作用域或被重新赋值时其原来指向的对象就会被自动删除。如果你需要将所有权转移给另一个 std::unique_ptr你可以使用 std::move。
std::weak_ptr这是一种特殊的智能指针主要用来解决 std::shared_ptr 的循环引用问题。std::weak_ptr 本身不对对象的生命周期造成影响也就是说拥有一个指向对象的 std::weak_ptr 不会阻止对象被删除。它只是为了提供一种访问已经存在并且被 std::shared_ptr 管理的对象的方式而不会增加引用计数。要使用 std::weak_ptr你需要先将其升级为 std::shared_ptr如果此时对象仍然存在升级操作就会成功。
这些智能指针都是 C 标准库的一部分设计用来自动管理内存以避免常规指针可能导致的内存泄漏和其他问题。在编写 C 程序时应优先考虑使用这些智能指针而不是裸指针。 小插曲 今天用vscode的时候 调试控制台不输出信息了 比如我print你好他竟然不输出只输出几个线程的信息高的很是烦人后面找到了解决方案解决方法
