C++ 智能指针实现
时间: 2023-11-14 20:09:46 浏览: 47
C++11 引入了智能指针,其中最常用的是 std::shared_ptr 和 std::unique_ptr。std::shared_ptr 是一种引用计数智能指针,多个 shared_ptr 可以指向同一个对象,当最后一个 shared_ptr 被销毁时,对象才会被释放。std::unique_ptr 是一种独占智能指针,只能有一个 unique_ptr 指向一个对象,当 unique_ptr 被销毁时,对象也会被释放。
下面是一个使用 std::unique_ptr 的例子:
```
#include <memory>
#include <iostream>
class MyClass {
public:
MyClass() {
std::cout << "MyClass constructed" << std::endl;
}
~MyClass() {
std::cout << "MyClass destructed" << std::endl;
}
};
int main() {
std::unique_ptr<MyClass> ptr(new MyClass());
return 0;
}
```
在这个例子中,我们创建了一个 std::unique_ptr 对象 ptr,并将其初始化为指向一个 MyClass 对象的指针。当程序结束时,MyClass 对象会被自动释放。
相关问题
给我一份C++智能指针实现的代码
### 回答1:
好的,以下是一个简单的C++智能指针实现的代码示例:
```
#include <iostream>
template <typename T>
class SmartPointer {
public:
explicit SmartPointer(T* ptr = nullptr) : m_ptr(ptr) {}
~SmartPointer() { delete m_ptr; }
// 禁止拷贝构造函数和赋值运算符
SmartPointer(const SmartPointer&) = delete;
SmartPointer& operator=(const SmartPointer&) = delete;
// 获取指针
T* get() const { return m_ptr; }
// 重载解引用运算符
T& operator*() const { return *m_ptr; }
// 重载箭头运算符
T* operator->() const { return m_ptr; }
// 重载布尔运算符,用于判断是否为nullptr
operator bool() const { return m_ptr != nullptr; }
private:
T* m_ptr;
};
int main() {
SmartPointer<int> p(new int(42));
std::cout << *p << std::endl;
std::cout << p->size() << std::endl;
if (p) {
std::cout << "p is not null." << std::endl;
}
return 0;
}
```
这个智能指针类的实现中,通过封装原始指针来实现自动释放内存的功能。当智能指针被销毁时,其内部保存的指针会被自动释放,从而避免了内存泄漏的问题。此外,该实现还禁止了拷贝构造函数和赋值运算符的使用,以避免多个智能指针指向同一个内存块的问题。
### 回答2:
以下是一个简单的C++智能指针的实现示例代码:
```cpp
#include <iostream>
template <typename T>
class SmartPointer {
public:
SmartPointer(T* ptr) : ptr_(ptr) {}
~SmartPointer() {
delete ptr_;
}
T& operator*() const {
return *ptr_;
}
T* operator->() const {
return ptr_;
}
private:
T* ptr_;
};
int main() {
SmartPointer<int> sp(new int(5));
std::cout << *sp << std::endl; // 输出 5
std::cout << sp->get() << std::endl; // 输出 5
return 0;
}
```
这段代码中,我们定义了一个名为SmartPointer的模板类,用于实现智能指针。它接受一个指向任意类型对象的原始指针作为构造函数参数,并负责该指针对象的内存管理。
在类的实现中,我们重载了解引用运算符*和箭头运算符->,使得智能指针的使用方式与原始指针类似。在类的析构函数中,我们释放了指向的内存。
在main函数中,我们创建了一个int类型对象的智能指针sp,并将其包装在SmartPointer类中。我们可以通过*和->运算符来访问所指向的对象,就像原始指针一样。最后,我们通过输出流输出对象的值。
这个示例是一个简单的智能指针实现,仅用于演示基本原理。在实际应用中,我们可能需要更复杂的实现,例如引用计数、拷贝控制等机制,以确保内存的正确管理和多线程安全。
c++智能指针简单实现
智能指针是一种用于自动管理动态分配内存的工具。其中最常见的智能指针是C++中的std::shared_ptr和std::unique_ptr。下面是一个简单实现智能指针的示例:
```c++
#include <iostream>
template <typename T>
class SmartPointer {
public:
SmartPointer(T* ptr)
: ptr_(ptr), ref_count_(new size_t(1)) {
}
SmartPointer(const SmartPointer<T>& other)
: ptr_(other.ptr_), ref_count_(other.ref_count_) {
++(*ref_count_);
}
~SmartPointer() {
if (--(*ref_count_) == 0) {
delete ptr_;
delete ref_count_;
}
}
SmartPointer<T>& operator=(const SmartPointer<T>& other) {
if (this != &other) {
if (--(*ref_count_) == 0) {
delete ptr_;
delete ref_count_;
}
ptr_ = other.ptr_;
ref_count_ = other.ref_count_;
++(*ref_count_);
}
return *this;
}
T& operator*() const {
return *ptr_;
}
T* operator->() const {
return ptr_;
}
private:
T* ptr_;
size_t* ref_count_;
};
int main() {
SmartPointer<int> sp1(new int(5));
std::cout << *sp1 << std::endl;
SmartPointer<int> sp2 = sp1;
std::cout << *sp2 << std::endl;
sp1 = SmartPointer<int>(new int(10));
std::cout << *sp1 << std::endl;
std::cout << *sp2 << std::endl;
return 0;
}
```
在上面的例子中,我们定义了一个模板类 SmartPointer,它保存了一个指向动态分配内存的原始指针 ptr_,以及一个引用计数 ref_count_。构造函数中,我们将引用计数初始化为1。当拷贝构造一个智能指针时,我们增加引用计数。当析构一个智能指针时,我们减少引用计数,并在引用计数变为0时释放内存。赋值运算符重载中,我们首先减少旧指针的引用计数,然后增加新指针的引用计数。
这只是一个简单的智能指针实现示例,实际上,标准库中的std::shared_ptr和std::unique_ptr提供了更多的功能和安全性保证。但是这个实现可以帮助你理解智能指针的基本原理。