C++——智能指针

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了C++——智能指针，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含7756字，纯文字阅读大概需要12分钟。

内容图文

智能指针的目的：

解决内存泄漏和指针悬挂。

内存泄漏：

不再使用的内存没有得到释放。

悬挂指针：

悬挂指针也叫野指针，是未初始化或未清零的指针。与空指针（NULL）不同，悬挂指针无法通过简单地判断是否为 NULL避免，而只能通过养成良好的编程习惯来尽力减少。

悬挂指针的成因主要有两种：

指针变量没有被初始化，任何指针变量刚被创建时不会自动成为NULL指针，它的缺省值是随机的，它会乱指一气。所以，指针变量在创建的同时应当被初始化，要么将指针设置为NULL，要么让它指向合法的内存。
指针p被free或者delete之后，没有置为NULL，让人误以为p是个合法的指针。它们只是把指针所指的内存给释放掉，但并没有把指针本身干掉。

智能指针auto_ptr（只能指向动态内存）（也是unique_ptr的一种）

auto_ptr是c++标准库的类模板，auto_ptr对象通过初始化指向new创建的动态内存，auto_ptr对象即为这块内存的拥有者，一块内存不能有两个拥有者。（C++98标准）

当auto_ptr对象的生命周期结束时，析构函数会将auto_ptr对象拥有的动态内存自动释放，防止内存泄漏。

#include <iostream>
#include <memory>
using namespace std;

class Test
{
public:
    Test(int a = 0 )
    : m_a(a)
    {}

    ~Test( )
    {
        cout<<"Calling destructor"<<endl;
    }
public:
    int m_a;
};

int main()
{
    auto_ptr<Test> t1(new Test(3));
    cout << t1->m_a <<endl;

    return 0;
}

使用方法：

初始化：
1.构造函数
1>.直接：auto_ptr<int> api(new int(22));
2>.用普通指针构造: int *p=new int(22);    auto_ptr<int> api(p);
2.拷贝构造:用已存在的智能指针构造新的智能指针:
auto_ptr<string> ap_string(new string("keke"));
auto+ptr<string> ap_stringnew(ap_string); 
//构造或赋值会造成拥有权转移，ap_string失去对keke的所有权，由ap_stringnew获得，
对象销毁时，ap_stringnew负责内存的自动销毁。
3.赋值
auto_ptr<int> p1(new int(1024));
auto_ptr<int> p2(new int(2048));
p1=p2; 
//赋值前，p1指向对象被删除，赋值后，p2不再指向该对象，p1拥有2048这块内存的控制权
//这就有问题了



1、base1.get()：返回当前指针对象；
2、base1.release()：清空当前智能指针对象，并返回类型指针。所以假如我们要正常删除，那么需要这样：
        Base1*base2 = base1.release();
        delete base2;
3、base1.reset()：是重置智能指针，即把内存删除，且智能指针指向空，但类型不变，所以可以这样安全便捷地删除：

auto_ptr的问题：

auto_ptr将所有权转让给另一个auto_ptr时。在函数之间传递auto_ptr时，这确实是个问题。例如，我在Foo()中有一个auto_ptr，这个指针从Foo中传递了另一个函数Fun()。现在一旦Fun()完成执行，所有权就不会返回给Foo()。
多个auto_ptr不能同时拥有同一个对象，
- 例如：Test *t1 = new Test(3); auto_ptr<Test> ptr1(t1); auto_ptr<Test> ptr2(t1);
- ptr1与ptr2都认为指针t1是归它管的，在析构时都试图删除t1，这样就造成了重复释放问题。
不能用auto_ptr管理数组指针，auto_ptr的析构函数中删除指针用的是delete，而不是delete []。
auto_ptr不可做为容器(vector, list, map)元素，因为进行值传递时，当从函数返回时，容器中的元素会被置位为NULL。

智能指针unique_ptr：独占所有权，防拷贝

和auto_ptr有区别，控制权唯一，不能随意转换。用法都差不多。实现原理是防止对象间的拷贝与赋值。具体实现是将拷贝构造函数和赋值运算符重载函数设置为保护或私有，并且只声明不实现，并将标志设置为保护或私有，防止他人在类外拷贝，简单粗暴，但是也提高了代码的安全性。

unique_ptr指针本身的生命周期：从unique_ptr指针创建时开始，直到离开作用域。离开作用域时，若其指向对象，则将其所指对象销毁(默认使用delete操作符，用户可指定其他操作)。

unique_ptr指针与其所指对象的关系：在智能指针生命周期内，可以改变智能指针所指对象，如创建智能指针时通过构造函数指定、通过reset方法重新指定、通过release方法释放所有权、通过移动语义转移所有权。

常规用法：

unique_ptr类中有get()、reset()、release()等函数。 
get()： 获得原生指针，返回当前指针对象
reset()：重置，显式释放资源 
reset(new XX)：重置，重新指定对象 
release()：释放所有权到某一原生指针上 
另外可以通过std::move将所有权由一个unique_ptr对象转移到另一个unique_ptr对象上，

unique_ptr<int> p1(new int(10));
unique_ptr<int> p2(new int(48));
p1.reset(); // 释放p1指向的内存, p1置空
int *pt = p2.release(); // p2放弃对指针的控制权，返回一个普通指针，并将p2置成空。
p1.reset(pt); // p1获得pt的控制权，如果p1对其它指针有控制权，那么就放弃原来的控制权。
p2 = unique_ptr<int>(new int(21));

p1 = nullptr;
// same as:
// p1.reset();
p2.reset(nullptr);
// same as:
// p2 = nullptr;

#include <iostream>
#include <memory>
using namespace std;

int main()
{
    //1. unique_ptr的创建
    //1.1)创建空的，然后利用reset指定对象
    unique_ptr<int> up1; 
    up1.reset(new int(3)); 
    //1.2）通过构造函数在创建时指定动态对象
    unique_ptr<int> up2(new int(4));

    //2. 获得原生指针(Getting raw pointer )
    int* p = up1.get();

    //3.所有权的变化
    //3.1)释放所有权,执行后变为empty
    int *p1 = up1.release();
    //3.2)转移所有权,执行后变为empty
    unique_ptr<int> up3 = std::move(up2);

    //4.显式释放资源
    up3.reset();

    return 0;
}

unique_ptr禁止赋值和复制，“唯一”地拥有其所指对象，同一时刻只能有一个unique_ptr实例指向给定对象。也就是说模板类unique_ptr的copy构造函数以及等号（“=”）操作符是无法使用的。

#include <iostream>
#include <memory>
using namespace std;

void Fun1( unique_ptr<int> up )
{
}

int main()
{
    unique_ptr<int> up1 = unique_ptr<int>(new int(10));

    //不允许复制(Copy construction is not allowed)，所以以下三个均错误
    unique_ptr<int> up2 = up1;  // error
    unique_ptr<int> up3(up1);   // error
    Fun1(up1);                  // error

    //不允许赋值('=')，所以下面错误
    unique_ptr<int> up4;
    up4 = up1;                  // error

    return 0;
}

针对auto_ptr缺陷的改善：

管理数组指针：因为unique_ptr有unique_ptr< X[ ] >重载版本，销毁动态对象时调用delete[]，所以可以用unique_ptr来管理数组指针。

unique_ptr< Test[ ] > uptr1(new Test[3]);
//注意 unique_ptr<Test> uptr3(new Test[3]);是不对的
unique_ptr<int[]> uptr2(new int[5]);

容器(vector, list, map)元素

智能指针shared_ptr：

利用引用计数；每有一个指针指向相同的一片内存时，引用计数+1，每当一个指针取消指向一片内存时，引用计数-1, 减为0时释放内存。

常见操作：

shared_ptr类中有get()、reset()、unique()、swap()等函数。 
get()： 获得原生指针 
reset()：重置，显式释放资源 
reset(new XX)：重新指定对象 
unique ()：检测对象管理者是否只有一个shared_ptr实例 
　　在shared_ptr的RAII实现机制中，默认使用delete实现资源释放，也可以定义自己的函数来释放，比如当其管理数组指针时，需要delete[]，这时就需要自定义释放函数。自定义释放的方法有两种：lambda表达式和括号操作符的重载

问题：

在多线程环境下，引用计数的更新存在安全隐患
- 第一个比较容易理解，我们可以在改变引用计数的时候加上一把互斥锁，防止多线程带来的隐患。
循环引用问题
- 2
  
  3
  
  4
  
  5
  
  6
  
  7
  
  void TestSharedPtr()
  
  {
  
  ????shared_ptr<Node> cur(new(Node));
  
  ????shared_ptr<Node> next(new(Node));
  
  ????cur->_next = next;????// 1
  
  ????next->_prev = cur;????// 2
  
  原因：加了这两句代码后，这两个节点的引用计数都增加了1。出了作用域进行析构时，两个对象均不能释放，因为prev的要释放的前提是next释放，而next的释放又依赖于prev的释放。最后就形成了循环引用，谁都释放不了。

C++——智能指针 - 文章图片

解决办法：

template<class T>
struct Node
{
public:
    ~Node()
    {
        cout << "delete:" << this << endl;
    }
public:
    weak_ptr<Node> _prev;
    weak_ptr<Node> _next;
};
  
void TestWeakPtr()
{
    shared_ptr<Node> cur(new Node());
    shared_ptr<Node> next(new Node());
  
    cout << "连接前：" << endl;
    cout << "cur:" << cur.use_count() << endl;
    cout << "next:" << next.use_count() << endl;
  
    cur->_next = next;
    next->_prev = cur;
  
    cout << "连接后：" << endl;
    cout << "cur:" << cur.use_count() << endl;
    cout << "next:" << next.use_count() << endl;
  
}

因为weak_ptr（弱引用智能指针）会对引用计数会做特殊处理(上述情况不加1)。

定制删除器
- 在shared_ptr中只能处理释放new开辟的空间，而对于malloc，以及fopen打开的文件指针不能处理，所以提出了定制删除器，方便释放其他类型的指针，而其实现则是通过仿函数（通过重载operator()）来实现。

智能指针weak_ptr：

weak_ptr类中有use_count()、expired()等函数。 
use_count()：观测资源的引用计数 
expired()：等价于use_count()==0，但更快 
lock()：获取shared_ptr，当expired()==true的时候，lock()函数将返回一个存储空指针的shared_ptr

总结：

auto_ptr 管理权的转移 ->不建议使用

unique_ptr 防拷贝 ->简单粗暴

shared_ptr 引用计数 ->增减引用计数，直到对象的引用计数为0时再释放

week_ptr 弱指针 ->辅助shared_ptr解决循环引用的问题。

本文转载总结的博客原文：

https://blog.csdn.net/zhou753099943/article/details/52412381

https://blog.csdn.net/shuishanga/article/details/52982102

内容总结

以上是互联网集市为您收集整理的C++——智能指针全部内容，希望文章能够帮你解决C++——智能指针所遇到的程序开发问题。如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容，请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/738254.html

来源：【匿名】

【上一篇】Win7 64bit下MexOpenCV的安装，Matlab和C++&OpenCV的完美结合【下一篇】c++有个库什么的吗?

更多 ►

【C++——智能指针】教程文章相关的互联网学习教程文章

C++智能指针智能指针与异常如果使用智能指针, 如果程序块过早的结束, 智能指针能保证在内存不再需要时进行释放. (特别是在有多个出口的函数中 -- 虽然应尽量避免设计这样的函数, 但凡事总有例外 -- 此时使用智能指针来自动释放内存是非常方便的) 对于异常处理来说, 考虑下面两个函数, 当程序发生异常时, 智能指针也能正确的释放内存. 　　void f3() 　　{ 　　　　int* p = new int(10); ...

C++11中智能指针的原理、使用、实现【代码】

目录理解智能指针的原理智能指针的使用智能指针的设计和实现1.智能指针的作用 C++程序设计中使用堆内存是非常频繁的操作，堆内存的申请和释放都由程序员自己管理。程序员自己管理堆内存可以提高了程序的效率，但是整体来说堆内存的管理是麻烦的，C++11中引入了智能指针的概念，方便管理堆内存。使用普通指针，容易造成堆内存泄露（忘记释放），二次释放，程序发生异常时内存泄露等问题等，使用智能指针能更好的管理堆内存。理...

转载：C++中两个类中互相包含对方对象的指针问题【代码】【图】

原文链接：http://www.cnblogs.com/hanxi/archive/2012/07/25/2608068.html　　前几天很不爽，因为C++中两个类中互相包含对方对象的指针编译时提示某一个类未定义。。。所以我就想啊想，这样也对，我的头文件都有#ifndef的，包含了一次就不能再包含了，以为就实现不了这样的功能，于是就改了设计方案：class A { public:A(B* pB):m_pB(pB){}private:B* m_pB; };class B { public:B() {} private:int m_i; };只在一个类中包含另一个...

【C++】利用指针实现通过函数改变多个参数的值【代码】

写惯了python，对于C++的语法越来越生疏，不同于python中函数可以return多个变量，C++的函数要想返回多个参数可以利用指针实现。因为在函数内部的变量都是局部变量，所以当参数传入函数中，不return不会改变函数之外的全局变量的值。但是如果传入指针参数或者地址参数，则可以实现对外部变量的改变。有以下2种做法：1、函数定义：void function(int &a){a = 500;//return; //void时可以省略return }　函数调用：int b = 10; func...

C++ void/指针与其他数据类型的相互转换【代码】

在写opencv多线程的时候用到了pthread_create()函数，int pthread_create(pthread_t *tidp,const pthread_attr_t *attr,(void*)(*start_rtn)(void*),void *arg);其中函数里最后一个变量声明为void* args。因为涉及到函数之间的传参，因此考虑将void*指针转换为string类型存放opencv图片存放路径，因为void*指针的特殊性，将void*作为中间指针变量，在string转换后的void*指针传入后，再将void* 转换为string类型，在调用的线程函数...

C/C++中利用空指针简化代码,提高效率

这里的写法，可以避免使用 for 循环，减少栈空间内存的使用和减少运行时的计算开销！#include <iostream> #include <string> using namespace std; void print_char(char* array[]);//函数原形声明 void main(void) { char* test[]={"abc","cde","fgh",NULL};//这里添加一个NULL,表示不指向任何地址,值为0 print_char(test); cin.get(); } void print_char(char* array[]) { ...

c++ 指向类成员函数的函数指针【代码】

// ConsoleApplication34.cpp : 定义控制台应用程序的入口点。 //#include "stdafx.h" #include <iostream> usingnamespace std;class Parent { public:Parent(){//cout << "我是爹" << endl; }virtualvoid print() {cout << "我是爹" << endl;} private:int a; }; class Child :public Parent { public:Child(){}void print() {cout << "我是儿子" << endl;} private:int b; };int main() {//返回值类型 (域作用符::*函数指针...

#C++初学记录（字符串与指针操作库函数）【代码】

测试程序#include<iostream> #include<cstring> using namespace std; int a[204],b[204],lena,n; char s1[100]="12345"; char s2[100]="abcdefg"; char s3[100]="ABCDE"; int main() {strncat (s1,s2,3);//s1="12345abc";strncpy(s1,s3,3);//s3的前三个字符拷贝到s1，s1="ABC45abc"; strncpy(s2,s3,6);//s2="ABCDE";strncmp(s1,s3,3);//比较s1和s3的前三个字符，比较结果相等则输出0，小于则输出负数，大于则输出正数； char *p=s...

【C++】智能指针【代码】

auto_ptr　　auto_ptr是当前C++标准库中提供的一种智能指针。　　auto_ptr在构造时获取某个对象的所有去（ownership),在析构时释放该对象。我们可以这样使用auto_ptr来提高代码安全性：int* p = newint(0); auto_ptr<int> ap(p);　　从此我们不必关心应该何时释放p,也不必担心发生异常会有内存泄漏，这是因为auto_ptr的析构函数会执行指针的释放，而析构函数会在ap除了作用域以后执行。　　auto_ptr的出现，主要是为了解决“被异常...

C++ 智能指针【代码】

智能指针概念C/C++ 语言最为人所诟病的特性之一就是存在内存泄露问题，因此后来的大多数语言都提供了内置内存分配与释放功能，有的甚至干脆对语言的使用者屏蔽了内存指针这一概念。这里不置贬褒，手动分配内存与手动释放内存有利也有弊，自动分配内存和自动释放内存亦如此，这是两种不同的设计哲学。有人认为，内存如此重要的东西怎么能放心交给用户去管理呢？而另外一些人则认为，内存如此重要的东西怎么能放心交给系统去管理呢？...

关于c/c++指针，指针的指针

伪军迷祝：建军节快乐！当调用一个函数时，实际上入参使用的都是副本（除非是引用），指针也不例外。举个例子如：void func(int a, int * p);当调用func时无论是a还是p其实传入的都是副本，假设调用func时传给p的值是pt，则p这个pt的副本保存着和pt一样的地址，*p和*pt都是同一地址上的值，改变*p也就改变了*pt。但是，对p本身的操作是不会影响pt的，例如不能在函数func内部给p动态分配内存，或者使p指向别的地方，因为这只是对p这...

c++ 11学习笔记--智能指针【代码】

C++ 98的 std::auto_ptr已经被彻底遗弃了，取而代之的是unique_ptr、shared_ptr与weak_ptr。大部分时候我们自己手动申请内存方式内存都是没有问题的，问题是如果程序很大了之后，一个复杂的对象，多次拷贝的代价非常高，很多地方都会使用到，只存在一份拷贝显然是最好的，这个时候对象生命周期的管理就会很复杂，所以c++引入了智能指针。任何事物都会有两面性。 Shared_ptr摘录于Effective C++, 3rd Edition, Item 17: 在 standal...

C/C++ 指针数组、二维数组

一、二维数组1> 初始化int a[3][3] = { {1,0,0}, {0,1,0}, {0,0,1} }; // 这里是 {} , 而不是()2> 将二维数组当做一维数组处理void print_array( int * p, int row, int line){　　for(int i=0; i<row; ++i)　　{　　　　for(int j=0; j<line; ++j)　　　　{　　　　　　printf("%d \n", *( p + i * row + j ) ); // 相当于 *( *(p+i) + j ); // p[i][j]　　　　}　　}}// 调用print_array( (int *)a, 3, 3 );3> 二维数组当二维数...

【C/C++学院】0828-数组与指针/内存分配/数据结构数组接口与封装

【送给在路上的程序员】对于一个开发者而言，能够胜任系统中任意一个模块的开发是其核心价值的体现。对于一个架构师而言，掌握各种语言的优势并可以运用到系统中，由此简化系统的开发，是其架构生涯的第一步。对于一个开发团队而言，能在短期内开发出用户满意的软件系统是起核心竞争力的体现。每一个程序员都不能固步自封，要多接触新的行业，新的技术领域，突破自我。数组与指针#include<stdio.h> #include<stdlib.h>void main1()...

c++指针笔记一

左值和右值的区别：左值就是在赋值中可以放在赋值操作符两边的值，比如： int a = 1; double b = 2.0 a = b; b = a; 这里a和b都是左值，一切变量都是左值，但const量是例外。而右值则是只可以放在赋值操作符右边的值，比如： int a = 0; char *b = "hello"; 3 = a; // ERROR "howdy" = b // ERROR 这里3和"howdy"都是右值，所以不能放在赋值操作符左边，一切常数、字符和字符串都是右值。指针变量的声明与初始化1.指针包含的是包含...

首页 / C++ / C++——智能指针

C++——智能指针

内容导读

内容图文

内容总结

内容备注

内容手机端

【C++——智能指针】教程文章相关的互联网学习教程文章

C++智能指针【代码】

C++11中智能指针的原理、使用、实现【代码】

转载：C++中两个类中互相包含对方对象的指针问题【代码】【图】

【C++】利用指针实现通过函数改变多个参数的值【代码】

C++ void/指针与其他数据类型的相互转换【代码】

C/C++中利用空指针简化代码,提高效率

c++ 指向类成员函数的函数指针【代码】

#C++初学记录（字符串与指针操作库函数）【代码】

【C++】智能指针【代码】

C++ 智能指针【代码】

关于c/c++指针，指针的指针

c++ 11学习笔记--智能指针【代码】

C/C++ 指针数组、二维数组

【C/C++学院】0828-数组与指针/内存分配/数据结构数组接口与封装

c++指针笔记一

指针 - 相关标签

C++ - 技术教程分类

C++ - 最新教程

C++ - 最热教程