苹果开发者官网ios17seo服务套餐

一、指针

就是随性研究一下，写个类

#pragma once
#include <memory>
#include<iostream>
/*shared_ptr 允许多个指针指向同一个对象，但是VoidPtr只能指向一个对象*/
/*unique_ptr 只能指向一个对象，不能被复制*/
/*weak_ptr 指向一个对象，但是不控制对象的生命周期,它是一个非 owning 指针，不能直接访问对象，弱引用*/
#pragma once
#include <memory>
#include<iostream>
/*shared_ptr 允许多个指针指向同一个对象，但是VoidPtr只能指向一个对象*/
/*unique_ptr 只能指向一个对象，不能被复制*/
/*weak_ptr 指向一个对象，但是不控制对象的生命周期,它是一个非 owning 指针，不能直接访问对象，弱引用*/
class VoidPtr
{std::shared_ptr<std::string> ptrstring=std::make_shared<std::string>();//加入三个初始化std::shared_ptr<int>p3=std::make_shared<int>(10);//p4指向是10个'9'std::shared_ptr<std::string>p4= std::make_shared<std::string>(10,'9');//默认为0std::shared_ptr<int>p5=std::make_shared<int>();//错误，必须直接初始化//std::shared_ptr<int>p6=new int(10);//正确，使用直接初始化//std::shared_ptr<int> p6(new int(10));
public:VoidPtr(std::string& p) :ptrstring(std::make_shared<std::string>(p)) {std::cout << "VoidPtr constructor" << std::endl;}std::string  get()  { return *ptrstring; }void  set(const std::string& p) { *ptrstring = p; }void print() {std::cout << "VoidPtr: " << get() << std::endl;}~VoidPtr() {std::cout << "VoidPtr destructor" << std::endl;}VoidPtr(const VoidPtr& other) = delete;std::shared_ptr<int> clone(int p) {return std::shared_ptr<int>(new int(p));}};

写了一个私有标量 std::shared_ptrstd::string ptrstring;
Get和set去设置ptrstring，以及print,另外记录下destructor是时机

main函数调用
// c_TEST.cpp : 此文件包含 “main” 函数。程序执行将在此处开始并结束。
//

#include <iostream>
#include "VoidPtr.h"
int main()
{;// 创建一个VoidPtr对象，传入一个初始字符串std::string initial_string = "Initial string";VoidPtr vp(initial_string);vp.print();// 使用get函数获取字符串并输出std::string retrieved = vp.get();std::cout << "Retrieved string: " << retrieved << std::endl;// 使用set函数修改字符串内容vp.set("Modified string");vp.print();std::string message = vp.get();std::cout << "Message: " << message << std::endl;std::shared_ptr<int> ptr(new int(10));//这个不能在类中实现}

在 C++ 里，智能指针是用来管理动态分配内存的工具，能够自动处理内存的释放，防止内存泄漏。std::shared_ptr、std::unique_ptr 和 std::weak_ptr 是标准库中提供的三种智能指针，它们在所有权、引用计数和使用场景上存在差异。下面为你详细介绍：

1. std::unique_ptr

• 特点：
  • 独占所有权，同一时间内只允许一个 std::unique_ptr 指向某个对象。
  • 不能进行拷贝构造或赋值操作，但可以通过 std::move 转移所有权。
  • 对象在 std::unique_ptr 离开作用域时会被自动删除。
• 应用场景：当你需要确保某个对象在任何时候只有一个所有者时，可使用 std::unique_ptr。例如，管理动态分配的资源（像文件句柄、网络连接）。
• 例程：

#include <iostream>
#include <memory>// 定义一个简单的类
class MyClass {
public:MyClass() { std::cout << "MyClass 构造函数" << std::endl; }~MyClass() { std::cout << "MyClass 析构函数" << std::endl; }void doSomething() { std::cout << "MyClass 正在执行操作" << std::endl; }
};int main() {// 创建一个 unique_ptr 并指向一个新的 MyClass 对象std::unique_ptr<MyClass> uniquePtr = std::make_unique<MyClass>();// 调用对象的成员函数uniquePtr->doSomething();// 转移所有权std::unique_ptr<MyClass> anotherUniquePtr = std::move(uniquePtr);if (uniquePtr == nullptr) {std::cout << "uniquePtr 现在为空" << std::endl;}anotherUniquePtr->doSomething();// 当 anotherUniquePtr 离开作用域时，对象会被自动删除return 0;
}

2. std::shared_ptr

• 特点：
  • 共享所有权，多个 std::shared_ptr 可以指向同一个对象。
  • 采用引用计数机制，每增加一个指向该对象的 std::shared_ptr，引用计数就加 1；每减少一个，引用计数就减 1。
  • 当引用计数变为 0 时，对象会被自动删除。
• 应用场景：当多个部分的代码需要访问同一个对象，且无法确定哪个部分最后使用该对象时，适合使用 std::shared_ptr。例如，在图形处理中，多个图形元素可能共享同一块纹理数据。
• 例程：

#include <iostream>
#include <memory>class MyClass {
public:MyClass() { std::cout << "MyClass 构造函数" << std::endl; }~MyClass() { std::cout << "MyClass 析构函数" << std::endl; }void doSomething() { std::cout << "MyClass 正在执行操作" << std::endl; }
};int main() {// 创建一个 shared_ptr 并指向一个新的 MyClass 对象std::shared_ptr<MyClass> sharedPtr1 = std::make_shared<MyClass>();std::cout << "引用计数: " << sharedPtr1.use_count() << std::endl;// 创建另一个 shared_ptr 并共享同一个对象std::shared_ptr<MyClass> sharedPtr2 = sharedPtr1;std::cout << "引用计数: " << sharedPtr1.use_count() << std::endl;// 调用对象的成员函数sharedPtr2->doSomething();// 当所有 shared_ptr 离开作用域时，对象会被自动删除return 0;
}

3. std::weak_ptr

• 特点：
  • 不拥有对象，是对 std::shared_ptr 管理对象的一种弱引用。
  • 不会增加引用计数，所以不会影响对象的生命周期。
  • 可以通过 lock() 方法获取一个 std::shared_ptr，用于访问对象。若对象已被删除，lock() 会返回一个空的 std::shared_ptr。
• 应用场景：当你需要解决 std::shared_ptr 循环引用问题，或者在不影响对象生命周期的情况下观察对象时，可使用 std::weak_ptr。例如，在实现缓存机制时，使用 std::weak_ptr 来引用缓存对象，避免影响对象的正常释放。
• 例程：

#include <iostream>
#include <memory>class B;class A {
public:std::shared_ptr<B> bPtr;~A() { std::cout << "A 析构函数" << std::endl; }
};class B {
public:std::weak_ptr<A> aPtr; // 使用 weak_ptr 避免循环引用~B() { std::cout << "B 析构函数" << std::endl; }
};int main() {std::shared_ptr<A> a = std::make_shared<A>();std::shared_ptr<B> b = std::make_shared<B>();a->bPtr = b;b->aPtr = a;// 使用 weak_ptr 访问对象if (auto sharedA = b->aPtr.lock()) {std::cout << "成功通过 weak_ptr 访问 A 对象" << std::endl;}// 当 a 和 b 离开作用域时，对象会被正确删除return 0;
}

总结

• std::unique_ptr：适用于独占所有权的场景，确保对象在任何时候只有一个所有者。
• std::shared_ptr：适用于共享所有权的场景，多个指针可以共享同一个对象。
• std::weak_ptr：适用于解决循环引用问题，或者在不影响对象生命周期的情况下观察对象。