文章目录
- C++的指针和引用
- C++指针
- C++中内存单元内容和地址
- 指针的定义和间接访问操作
- 指针和数组
- 左值和右值
- 几种C++中的原始指针
- 原始指针的基本运算
- 存储区域划分
- 栈和队列
- 代码在内存单元中的分布
- cpp动态分配资源和回收原则
- 资源管理方案-RAII
- C++中几种变量对比
- 内存泄漏
- 智能指针
- C++的智能指针
- auto_ptr
- unique_ptr
- share_ptr 和 weak_ptr
- C++的引用
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 arrayint c[4] = { 0x80000000, 0xFFFFFFFF, 0x00000000, 0x7FFFFFFF };int* a[4]; // array of pointers 指针的数组int(*b)[4]; // a pointer to an array 数组的指针b = &c; // 注意：这里数组个数得匹配// 将数组c中元素赋给数组afor (unsigned int i = 0; i<4; i++){a[i] = &(c[i]);}// 输出看下结果cout << *(a[0]) << endl; // -2147483648cout << (*b)[3] << endl; // 2147483647return 0;
}
左值和右值
-
概念：
一般说法，编译器为其单独分配了一块存储空间，可以取其地址的，左值可以放在赋值运算符左边；
右值指的是数据本身，不能取到自身地址，右值只能放在赋值运算符右边。
-
具体分析：
左值最常见的情况如函数和数据成员的名字；
右值是没有标识符、不可取地址的表达式，一般称之为临时对象。
几种C++中的原始指针
- 一般类型指针T*;
T是一个泛型，泛指任何一种类型
-
指针的数组与数组的指针
指针的数组 T *t[] 数组的指针 T(*t)[]
-
const pointer和pointer to const
- 关于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* constpStr1 = 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不用时，置为NULLreturn 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; // errorc = a++ + b;//d = a++++b; // errorchar 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)
- 从现代编程语言角度，使用堆或者说使用动态内存分配，是一件很自然的事情
- 动态分配内存带来了不确定性：内存分配耗时？失败怎么办？
- 一般而言，当我们在堆上分配内存时，很多语言会使用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中删除）
- 这里我们从应用场景中来分析智能指针
- 应用场景： 对象所有权 生命周期
- 性能分析
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_ptrauto 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 此时等于 nullptrcout << ((w.get() != nullptr) ? (*w.get()) : -1) << endl; // -1cout << ((w2.get() != nullptr) ? (*w2.get()) : -1) << endl; // 10return 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() 等于 1cout << ((wAA.get() != nullptr) ? (*wAA.get()) : -1) << endl; // -1cout << ((wAA2.get() != nullptr) ? (*wAA2.get()) : -1) << endl; // 30cout << wAA.use_count() << endl; // 0cout << 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()); // 1shared_ptr<B> tB(new B()); // 1cout << tA.use_count() << endl;cout << tB.use_count() << endl;tA->pb = tB;tB->pa = tA;cout << tA.use_count() << endl; // 2cout << 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; // 1cout << tB.use_count() << endl; // 1tA->pb = tB;tB->pa = tA;cout << tA.use_count() << endl; // 1cout << tB.use_count() << endl; // 2
}int main()
{Test();Test2();return 0;
}C++的引用
引用是什么？变量的别名，是一种特殊的指针，不允许修改的指针。
使用指针有哪些坑:
- 空指针
- 野指针
- 不知不觉改变了指针的值，却继续使用
使用引用则可以：
- 不存在空引用
- 必须初始化
- 一个引用永远指向它的初始化的那个对象
- 基本使用：可以认为是变量的别名，使用时候可以认为是变量本身
有了指针为什么还要有引用？
为了支持运算符重载。
有了引用为什么还需要指针？
为了兼容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++）
- 对内置基础类型，传值更高效；
- 对OO面向对象中自定义的类型而言，在函数中传递const引用更高效。
