C++的指针和引用
C++指针
C++中内存单元内容和地址
● 内存由很多的内存单元组成，这些内存单元用于存放各种类型数据；
● 计算机对内存的每个内存单元都进行了编号，这个编号就称为内存地址，地址决定了内存单元在内存中的位置；
● 记住这些内存单元地址不方便，因此C++语言的编译器让我们通过名字来访问这些内存位置；
int a = 112, b = -1; float c = 3.14; int *d = &a; float *e = &c;
指针的定义和间接访问操作
● 指针定义的基本形式：指针本身就是一个变量，其符合变量定义的基本形式，它存储的是值的地址。对类型T，T*是"到T的指针"类型，一个类型为T*的变量能保存一个类型T的对象的地址.
● 通过指针访问它所指向的地址的过程称为间接访问或者引用指针；
这个用于执行间接访问操作符是单目操作符*； cout << *d << endl;
#include <iostream> using namespace std; int main() { int a = 112, b = -1; float c = 3.14f; int* d = &a; float* e = &c; cout << d << endl; cout << e << endl; cout << (*d) << endl; cout << (*e) << endl; return 0; }
关于变量、地址和指针变量：
● 一个变量的三个重要信息：
- 变量地址信息
- 变量所存的信息
- 变量类型
● 指针变量是一个专门用来记录变量的地址的变量；通过指针变量可以间接的访问另一个变量的值。
指针和数组
如过是数组，数组地址是不可改变的，但是数组值是可以改变的
指针地址是可变的，指针值是否可改变取决于所指的区间的存储区域是否可变
#include <iostream> using namespace std; int main() { // T*: 注意*在定义和间接访问上的作用 //int i = 4; int* iP = &i; cout << (*iP) << endl; //double d = 3.14; double* dP = &d; cout << (*dP) << endl; //char c = 'a'; char* cP = &c; cout << (*cP) << endl; // array of pointers和a pointer to an array int c[4] = { 0x80000000, 0xFFFFFFFF, 0x00000000, 0x7FFFFFFF }; int* a[4]; // array of pointers 指针的数组 int(*b)[4]; // a pointer to an array 数组的指针 b = &c; // 注意：这里数组个数得匹配 // 将数组c中元素赋给数组a for (unsigned int i = 0; i<4; i++) { a[i] = &(c[i]); } // 输出看下结果 cout << *(a[0]) << endl; // -2147483648 cout << (*b)[3] << endl; // 2147483647 return 0; }
左值和右值
● 概念：
一般说法，编译器为其单独分配了一块存储空间，可以取其地址的，左值可以放在赋值运算符左边；
右值指的是数据本身，不能取到自身地址，右值只能放在赋值运算符右边。
● 具体分析：
左值最常见的情况如函数和数据成员的名字；
右值是没有标识符、不可取地址的表达式，一般称之为临时对象。
几种C++中的原始指针
● 一般类型指针T*;
T是一个泛型，泛指任何一种类型
● 指针的数组与数组的指针
指针的数组 T *t[] 数组的指针 T(*t)[]
● const pointer和pointer to const
○ 关于const修饰的部分
● 看左侧最近的部分
● 如果左侧没有，则看右侧
#include <iostream> using namespace std; unsigned int MAX_LEN = 11; int main() { char strHelloworld[] = { "helloworld" }; char const* pStr1 = "helloworld"; // const char* char* const pStr2 = strHelloworld; char const* const pStr3 = "helloworld"; // const char* const pStr1 = strHelloworld; //pStr2 = strHelloworld; // pStr2不可改 //pStr3 = strHelloworld; // pStr3不可改 unsigned int len = strnlen_s(pStr2, MAX_LEN); cout << len << endl; for (unsigned int index = 0; index < len; ++index) { //pStr1[index] += 1; // pStr1里的值不可改 pStr2[index] += 1; //pStr3[index] += 1; // pStr3里的值不可改 } return 0; }
● 指向指针的指针
例子：
int a = 123;
int *b = &a;
int **c = &b;
○ *操作符具有从右向左的结合性
○ **这个表达式相当于*(*c) , 必须从里向外逐层求值
○ *c得到的是b的地址 **c相当于*b,得到a的值
● 未初始化和非法指针（野指针）
例子：int *a; // a的指向不明，可能会导致程序崩溃。
*a = 12;
最坏的情况是定位到了一个可访问的地址，无意间修改了它，这样的错误难以捕捉，引发的错误可能与原先用于操作的代码完全不相干。
● NULL指针
一个特殊的指针变量，表示不指向任何东西 int *a = NULL;
○ NULL指针表示指针未指向任何东西
○ 对于一个指针，如果已经知道将被初始化的地址，那么请赋值给它，否则请将它设置为NULL
○ 在对一个指针进行间接引用的时候，请先判断该指针是否为NULL。
● 杜绝野指针：
指向一堆垃圾内存的指针。if等判断对它们不起作用，因为没有设置为NULL
一般有三种情况：
○ 指针变量没有初始化
○ 已经释放不用的指针没有设置为NULL,如delete和free之后的指针
○ 指针操作超越了变量作用范围
使用注意事项：
○ 没有初始化的，不用的或者超出范围的指针请把值置为NULL。
#include <iostream> using namespace std; int main() { // 指针的指针 int a = 123; int* b = &a; int** c = &b; // NULL 的使用 int* pA = NULL; pA = &a; if (pA != NULL) // 判断NULL指针 { cout << (*pA) << endl; } pA = NULL; // pA不用时，置为NULL return 0; }
原始指针的基本运算
● &与*操作符
#include <iostream> using namespace std; int main() { char ch = 'a'; // &操作符 //&ch = 97; // &ch左值不合法 char* cp = &ch; // &ch右值 //&cp = 97; // &cp左值不合法 char** cpp = &cp; // &cp右值 // *操作符 *cp = 'a'; // *cp左值取变量ch位置 char ch2 = *cp; // *cp右值取变量ch存储的值 //*cp + 1 = 'a'; // *cp+1左值不合法的位置 ch2 = *cp + 1; // *cp+1右值取到的字符做ASCII码+1操作 *(cp + 1) = 'a'; // *(cp+1)左值语法上合法，取ch后面位置 ch2 = *(cp + 1); // *(cp+1)右值语法上合法，取ch后面位置的值 return 0; }
● ++与–操作符
int main() { char ch = 'a'; char* cp = &ch; // ++,--操作符 char* cp2 = ++cp; char* cp3 = cp++; char* cp4 = --cp; char* cp5 = cp--; // ++ 左值 //++cp2 = 97; //cp2++ = 97; // *++, ++* *++cp2 = 98; char ch3 = *++cp2; *cp2++ = 98; char ch4 = *cp2++; // ++++, ----操作符等 int a = 1, b = 2, c, d; //c = a++b; // error c = a++ + b; //d = a++++b; // error char ch5 = ++*++cp; return 0; }
存储区域划分
栈和队列
● 栈：先进后出
● 队列：先进先出
代码在内存单元中的分布
#include <string> int a = 0; //(GVAR)全局初始化区 int* p1; //(bss)全局未初始化区 int main() //(text)代码区 { int b=1; //(stack)栈区变量 char s[] = "abc"; //(stack)栈区变量 int*p2=NULL; //(stack)栈区变量 char *p3 = "123456"; //123456\0在常量区, p3在(stack)栈区 static int c = 0; //(GVAR)全局(静态)初始化区 p1 = new int(10); //(heap)堆区变量 p2 = new int(20); //(heap)堆区变量 char* p4 = new char[7]; //(heap)堆区变量 strcpy_s(p4, 7, "123456"); //(text)代码区 //(text)代码区 if (p1 != NULL) { delete p1; p1 = NULL; } if (p2 != NULL) { delete p2; p2 = NULL; } if (p4 != NULL) { delete[ ] p4; p4 = NULL; } //(text)代码区 return 0; //(text)代码区 }
从高地址到低地址
栈空间 - 从高到低
堆空间 - 从低到高
cpp动态分配资源和回收原则
动态分配资源 – 堆(heap)
1.从现代编程语言角度，使用堆或者说使用动态内存分配，是一件很自然的事情
2.动态分配内存带来了不确定性：内存分配耗时？失败怎么办？
3.一般而言，当我们在堆上分配内存时，很多语言会使用new这样的关键字，有些语言则是隐式分配。在C++中new的对应词是delete，因为C++是可以让程序员完全接管内存分配释放的。
内存分配和回收原则：
程序通常需要牵涉到三个内存管理器操作：
● 分配一个某大小的内存块
● 释放一个之前分配的内存块
● 垃圾收集操作，寻找不再使用的内存块并且予以释放；
这个回收策略需要实现实时性、额外开销等各方面的平衡，很难有统一和高效的做法；
C++做了1， 2 两件事；java做了1，3两件事。
资源管理方案-RAII
● C++所特有的的资源管理方式。
● RAII依托栈和析构函数，来对所有资源（包括堆内存在内）进行管理。
● RAII有些比较成熟的智能指针的代表：std::auto_ptr 等
C++中几种变量对比
栈和堆中的变量对比：
| 栈区 | 堆区 | |
| 作用域 | 函数体内，语句块{}作用域 | 整个程序范围内，由 new malloc开始 ， delete free结束 |
| 编译期间大小确定 | 由变量大小范围确定 | 变量大小范围不确定，需要运行时确定 |
| 大小范围 | windows默认是1M linux是8M或者10M（可调整） | 所有系统的堆内存空间上限是接近内存（虚拟内存）的总大小的（一部分被OS占用） |
| 内存分配方式 | 地址由高到低 | 地址由低到高 |
| 内容是否可变 | 可变 | 可变 |
全局静态存储区和常量存储区的变量对比：
| 全局经验存储区 | 常量存储区 | |
| 存储内容 | 全局变量，静态变量 | 常量 |
| 编译期间大小是否确定 | 确定 | 确定 |
| 内容是否可变 | 可变 | 不可变 |
内存泄漏
● 什么事内存泄漏问题：
指的是程序中已经分配的堆内存由于某种原因程序未释放，造成系统内存的浪费，导致程序运行速度减慢甚至系统崩溃等严重后果。
● 内存泄漏发生的原因和排查方式：
○ 内存泄漏主要发生在堆内存分配方式中，即配置了内存后，多有指向该内存的指针都遗失了。若缺乏语言这样的垃圾回收机制，这样的内存片无法归还系统。
○ 因为内存泄漏属于程序运行中的问题，无法 通过编译识别，所以只能在程序运行过程中来判断。
智能指针
使用指针是非常危险的行为，可能存在空指针，野指针的问题，并且可能造成内存泄漏问题。可指针又非常高效，所以我们希望以更安全的方式来使用指针。
● 一般有两种典型的方案：
- 使用更安全的指针 - 智能指针
- 不使用指针，使用更安全的方式 - 引用
C++的智能指针
● C++中推出了常用的只能指针
unique_ptr、share_ptr、weak_ptr和C++11中已经废弃的auto_ptr（C++17中删除）
● 这里我们从应用场景中来分析智能指针
1.应用场景： 对象所有权 生命周期
2.性能分析
auto_ptr
由new expression获得对象，在auto_ptr对象销毁时，它所管理的对象也会被自动delete掉
所有权转移：不小心把它传递给另外的智能指针，原来的指针就不再拥有这个对象了，在拷贝/赋值的过程中，会直接剥夺指针对内存的控制权，转交给新对象，然后再将原对象置为nullptr
#include <string> #include <iostream> #include <memory> using namespace std; int main() { {// 确定auto_ptr失效的范围 // 对int使用 auto_ptr<int> pI(new int(10)); cout << *pI << endl; // 10 // auto_ptr C++ 17中移除 拥有严格对象所有权语义的智能指针 // auto_ptr原理：在拷贝 / 赋值过程中，直接剥夺原对象对内存的控制权，转交给新对象， // 然后再将原对象指针置为nullptr（早期：NULL）。这种做法也叫管理权转移。 // 他的缺点不言而喻，当我们再次去访问原对象时，程序就会报错，所以auto_ptr可以说实现的不好， // 很多企业在其库内也是要求不准使用auto_ptr。 auto_ptr<string> languages[5] = { auto_ptr<string>(new string("C")), auto_ptr<string>(new string("Java")), auto_ptr<string>(new string("C++")), auto_ptr<string>(new string("Python")), auto_ptr<string>(new string("Rust")) }; cout << "There are some computer languages here first time: \n"; for (int i = 0; i < 5; ++i) { cout << *languages[i] << endl; } auto_ptr<string> pC; pC = languages[2]; // languges[2] loses ownership. 将所有权从languges[2]转让给pC， //此时languges[2]不再引用该字符串从而变成空指针 cout << "There are some computer languages here second time: \n"; for (int i = 0; i < 2; ++i) { cout << *languages[i] << endl; } cout << "The winner is " << *pC << endl; //cout << "There are some computer languages here third time: \n"; //for (int i = 0; i < 5; ++i) //{ // cout << *languages[i] << endl; //} } return 0; }
unique_ptr
unique_ptr是专属版本，所以unique_ptr管理的内存，只能被一个对象持有，不支持复制和赋值
移动语义：unique_ptr禁止了拷贝语义，但有时我们也需要能够转移所有权，于是提供了移动语义，即可以使用std::move()进行控制所有权的转移。
#include <memory> #include <iostream> using namespace std; int main() { // 在这个范围之外，unique_ptr被释放 { auto i = unique_ptr<int>(new int(10)); cout << *i << endl; } // unique_ptr auto w = std::make_unique<int>(10); cout << *(w.get()) << endl; // 10 //auto w2 = w; // 编译错误如果想要把 w 复制给 w2, 是不可以的。 // 因为复制从语义上来说，两个对象将共享同一块内存。 // unique_ptr 只支持移动语义, 即如下 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 return 0; }
share_ptr 和 weak_ptr
share_ptr通过一个引用计数共享一个对象。
share_ptr是为了解决auto_ptr在对象所有权上的局限性，在使用引用计数的机制上提供了可以共享所有权的智能指针，当然这需要额外的开销。
当引用计数为0的时候，该对象没有被使用，可以进行析构。
● 循环引用的问题：引用计数会带来循环引用的问题，造成内存无法正常回收，造成内存泄漏。
weak_ptr被设计为与share_ptr共同工作，用一种观察者模式工作。
作用是协助share_ptr工作，可获得资源的观测权，像旁观者那样观测资源使用情况。观察者意味着weak_ptr只对share_ptr进行引用，而不改变其引用计数，当被观察的share_ptr失效后相应的weak_ptr也会失效。
#include <iostream> #include <memory> using namespace std; int main() { shared_ptr //{ // //shared_ptr 代表的是共享所有权，即多个 shared_ptr 可以共享同一块内存。 // 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 // //shared_ptr 内部是利用引用计数来实现内存的自动管理，每当复制一个 shared_ptr， // // 引用计数会 + 1。当一个 shared_ptr 离开作用域时，引用计数会 - 1。 // // 当引用计数为 0 的时候，则 delete 内存。 //} // 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 cout << ((wAA2.get() != nullptr) ? (*wAA2.get()) : -1) << endl; // 30 cout << wAA.use_count() << endl; // 0 cout << wAA2.use_count() << endl; // 1 //将 wAA 对象 move 给 wAA2，意味着 wAA 放弃了对内存的所有权和管理，此时 wAA对象等于 nullptr。 //而 wAA2 获得了对象所有权，但因为此时 wAA 已不再持有对象，因此 wAA2 的引用计数为 1。 return 0; }
#include <string> #include <iostream> #include <memory> using namespace std; struct B; struct A { shared_ptr<B> pb; ~A() { cout << "~A()" << endl; } }; struct B { shared_ptr<A> pa; ~B() { cout << "~B()" << endl; } }; // pa 和 pb 存在着循环引用，根据 shared_ptr 引用计数的原理，pa 和 pb 都无法被正常的释放。 // weak_ptr 是为了解决 shared_ptr 双向引用的问题。 struct BW; struct AW { shared_ptr<BW> pb; ~AW() { cout << "~AW()" << endl; } }; struct BW { weak_ptr<AW> pa; ~BW() { cout << "~BW()" << endl; } }; void Test() { cout << "Test shared_ptr and shared_ptr: " << endl; shared_ptr<A> tA(new A()); // 1 shared_ptr<B> tB(new B()); // 1 cout << tA.use_count() << endl; cout << tB.use_count() << endl; tA->pb = tB; tB->pa = tA; cout << tA.use_count() << endl; // 2 cout << tB.use_count() << endl; // 2 } void Test2() { 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(); Test2(); return 0; }
C++的引用
引用是什么？变量的别名，是一种特殊的指针，不允许修改的指针。
使用指针有哪些坑:
1.空指针
2.野指针
3.不知不觉改变了指针的值，却继续使用
使用引用则可以：
1.不存在空引用
2.必须初始化
3.一个引用永远指向它的初始化的那个对象
● 基本使用：可以认为是变量的别名，使用时候可以认为是变量本身
有了指针为什么还要有引用？
为了支持运算符重载。
有了引用为什么还需要指针？
为了兼容C语言。
#include <iostream> #include <assert.h> using namespace std; // 编写一个函数，输入两个int型变量a,b // 实现在函数内部将a,b的值进行交换。 void swap(int& a, int& b) { int tmp = a; a = b; b = tmp; } void swap2(int* a, int* b) { int tmp = *a; *a = *b; *b = tmp; } int main() { //int x = 1, x2 = 3; //int& rx = x; //rx = 2; //cout << x << endl; //cout << rx << endl; //rx = x2; //cout << x << endl; //cout << rx << endl; // 交换变量的测试 int a = 3, b = 4; swap(a, b); assert(a == 4 && b == 3); a = 3, b = 4; swap2(&a, &b); assert(a == 4 && b == 3); return 0; }
补充：（Effective C++）
1.对内置基础类型，传值更高效；
2.对OO面向对象中自定义的类型而言，在函数中传递const引用更高效。
