经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置:技术经验 » 程序设计 » C++ » 查看文章
C++学习笔记之指针引用 - time-flies
来源:cnblogs  作者:time-flies  时间:2021/5/24 10:58:35  对本文有异议

指针

指针定义

指针定义的基本形式:指针本身就是一个变量,其符合变量定义的基本形式,它存储的是值的地址。对类型T,T是“到T的指针”类型,一个类型为T的变量能保存一个类型T的对象的地址
如:

int a=112;
float c=3.14;
int* d=&a;
float* e=&c;

cout << d << endl;    cout << e << endl;
cout << (*d) << endl;    cout << (*e) << endl;

通过一个指针访问它所指向地址的过程称为间接访问(indirection)或者引用指针(dereferencing the point);这个用于执行间接访问的操作符是单目操作符*:

cout<<(*d)<<endl;
cout<<(*e)<< endl;

左值与右值

概念:

  • 编译器为其单独分配了一块存储空间,可以取其地址的,左值可以放在赋值运算符左边;
  • 右值指的是数据本身,不能取到其自身地址,右值只能赋值运算右边;

具体分析:

  • 左值最常见的情况如函数和数据成员的名字;
  • 右值是没有标识符、不可以取地址的表达式,一般也称之为“临时对象"。

比如:a=b+c; &a是允许的操作,而&(b+c)不能通过编译,因此a是一个左值,而(b+c)是一个右值;

指针数组与数组指针

指针的数组(array of pointers)与数组的指针(a pointer to an array):

  • 指针的数组 T t []*:运算符和T结合,定义数组的元素为T指针类型。
  • 数组的指针 T (*t) []:*运算符和t结合,定义变量t为指针变量。
int*  a[4];                          // array of pointers        指针的数组
int (*b) [4];                       // a pointer to an array  数组的指针

// 输出
cout << *(a[0]) << endl; 
cout << (*b)[0] << endl; 

const与指针

const pointerpointer to const例子:

char strHelloworld[]={"helloworld"};
char const * pStr1="helloworld";  //和const char* pStr1等效
char * const pStr2="helloworld";
char const * const pStr3="helloworld";
pStr1=strHelloworld;
//pStr2=strHelloworld; //pStr2不可改
//pStr3=strHelloworld; //pStr3不可改

关于const修饰的部分:

  • 看左侧最近的部分;
  • 如果左侧没有,则看右侧;

指针的指针

指向指针的指针例子:

int a=123;
int* b=&a;
int** c=&b;

*操作符具有从右向左的结合性,上面取值规则如下:

  • **这个表达式相当于*(*c),必须从里向外逐层求值;
  • *c得到的是c指向的位置,即b;
  • **c相当于*b,得到变量a的值;

NULL指针

NULL指针:一个特殊的指针变量,表示不指同任何东西。

int* a=NULL;

NULL指针给了一种方法,来表示特定的指钍目前未指向任何东西,使用的注意事项:

  • 对于一个指针,如果已经知道将被初始化为什么地址,那么请赋给它这个地址值,否则适把它设置为NULL
  • 在对一个指针进行间接引用前,请先判断这个指针的值为否为NULL
  • 没有初始化的,不用的或者超出范围的指针请把值置为NULL

内存泄漏(Memory Leak)问题

内存泄漏问题:指程序中己动态分配的维内存由于某种原因程序未释放或无法释,造成系统内存的浪费,导致程序运行速度减慢甚至系统崩溃等严重后果。

内存泄漏发生原因和排查方式:

  • 内存泄漏主要发生在堆内存分配方式中,即“配置了内存后,所有指向该内存的指针都遗失了”。
  • 因为内存泄漏属于程序运行中的问题,无法通过编译识别,所以只能在程序运行过程中来判别和诊断
while (true) 
{
      int* wp1 = new int(10); //内存泄漏
}

智能指针

C++中推出了四种常用的智能指针:

  • unique ptr:专属所有权,管理的内存只能被一个对象持有,不支持复制和赋值,可以使用std:move()进行控制所有权的转移。
auto w = std::make_unique<int>(10);
cout << *(w.get()) << endl;    // 10
//auto w2 = w;                        // 编译错误如果想要把 w 复制给 w2, 是不可以的。	
auto w2 = std::move(w);         // w2 获得内存所有权,w 此时等于 nullptr
cout << ((w.get() != nullptr) ? (*w.get()) : -1) << endl;     // -1
cout << ((w2.get() != nullptr) ? (*w2.get()) : -1) << endl;   // 10
  • shared ptre通过一个引用计数共享一个对象,当引用计数为0时,该对象没有被使用,可以进行析构。
auto wA = shared_ptr<int>(new int(20));
{
    auto wA2 = wA;
    cout << ((wA2.get() != nullptr) ? (*wA2.get()) : -1) << endl;       // 20
    cout << ((wA.get() != nullptr) ? (*wA.get()) : -1) << endl;         // 20
    cout << wA2.use_count() << endl;                                    // 2
    cout << wA.use_count() << endl;                                     // 2
}
//cout << wA2.use_count() << endl;                                               
cout << wA.use_count() << endl;                                         // 1
cout << ((wA.get() != nullptr) ? (*wA.get()) : -1) << endl;             // 20

// move 语法,意味着放弃了对内存的所有权和管理
auto wAA = std::make_shared<int>(30);
auto wAA2 = std::move(wAA);            // 此时 wAA 等于 nullptr,wAA2.use_count() 等于 1
cout << ((wAA.get() != nullptr) ? (*wAA.get()) : -1) << endl;          // -1
ccout << wAA.use_count() << endl;                                      // 0
cout << wAA2.use_count() << endl;                                      // 1
  • weak ptr:被设计为与shared_ptr共同工作(避免循环引用shared_ptr导致的内存泄露),用一种观察者模式工作,只对shared ptr进行引用而不改变其引用计数,当被观察的 shared ptr失效后相应的weak ptr也相应失效。
struct AW
{
    shared_ptr<BW> pb;
    ~AW()	{ cout << "~AW()" << endl; }
};
struct BW
{
    weak_ptr<AW> pa;          //此处改为shared_ptr则会发生内存泄漏(循环引用)
    ~BW()	{ cout << "~BW()" << endl; }
};
void Test()
{
    cout << "Test shared_ptr and shared_ptr:  " << endl;
    shared_ptr<A> tA(new A());                                               
    shared_ptr<B> tB(new B());                                                
    cout << tA.use_count() << endl;          // 1
    cout << tB.use_count() << endl;          // 1
    tA->pb = tB;
    tB->pa = tA;
    cout << tA.use_count() << endl;          // 2
    cout << tB.use_count() << endl;          // 2
}
void Test()
{
    cout << "Test weak_ptr and shared_ptr:  " << endl;
    shared_ptr<AW> tA(new AW());
    shared_ptr<BW> tB(new BW());
    cout << tA.use_count() << endl;              // 1
    cout << tB.use_count() << endl;              // 1
    tA->pb = tB;
    tB->pa = tA;
    cout << tA.use_count() << endl;              // 1
    cout << tB.use_count() << endl;              // 2
}

int main()
{
    Test();
    return 0;
}
  • auto_ptr:在拷贝/赋值过程中,会直接剥夺指针对原对象对内存的控制权(C++11中已经废弃的,在C++17中被正式删除)。

引用

C++的引用是一种特殊的指针,不允许修改的指针,参考 C++:引用的简单理解

注:C++中类的引用也需要显式定义,C#中除了值类型则全是引用类型,注意区别。

使用指针有空指针、野指针、不知不觉改变了指针的值却继续使用的问题,使用引用则:

  • 不存在空引用;
  • 必须初始化;
  • 一个引用永远指向它初始化的那个对象;
int x = 1, x2 = 3;
int& rx = x;
rx = 2;
cout << x << endl;    //2
cout << rx << endl;   //2
rx = x2;
cout << x << endl;    //3
cout << rx << endl;   //3

有了指针为什么还需要引用?
Bjarne Stroustrup的解释:为了支持函数运算符重载

有了引用为什么还需要指针?
Bjarne Stroustrup的解释:为了兼容C语言

关于函数传递参数类型的说明:

  • 内置基础类型(如int,double等)而言,在函数中传递时pass by value更高效;
  • 对OO面向对象中自定义类型而言,在函数中传递时pass by reference to const更高效;

原文链接:http://www.cnblogs.com/timefiles/p/CppStudyNotesPointerReference.html

 友情链接: NPS