C++之指针

>>>>>

对c++指针的理解。

原生指针：

	int* a{}, b;// a是指针，b是Int。别这么写，会增加理解成本。
	int c = 2000;
	int* pc = &c;// 把c的地址赋值给pd，&是取址运算符。指针命名一般用p开头。pc表示c的内存地址
	*pc = 500;// 表示在c的内存地址写入500，本质：c = 500;

	//32位系统地址大小0-2^32,64位系统地址大小0-2^64。
	sizeof(pc);// 指针pc的内存大小，在32位系统下占4字节，在64位系统下占8字节。

	int* ptrArrary[10];// 定义一个数组指针，即10个int指针。他的地址是连续的。
	unsigned e = 100;
	pc = (int*)&e;// 不同类型变量赋值到指针。原因：pc的本质是内存地址，内存地址是正整数，int的范围包含了unsigned
	// 有坑。当int的pc拿到了unsigned强转的地址，不可赋值负数，否则出现极大值。只能赋值正数。

	long long* up{ (long long*)e };// 有坑。8字节的指针up读取了4字节的e，多读取了4个未知地址的值，会出现未知的值。
	// 指针运算
	int d[]{ 1,2 };
	int* pd{ &d[0] };
	(*pd)++;// 表示d[0]++，即2
	pd++;// 地址增加一个指针类型的大小。即：*pd表示d[1]的3

	int** ppd{ &pd };// ppd表示指针*pd的地址，即：指针的指针
	*ppd;// 表示a[0]的地址
	**ppd;// 表示a[0]的值
	int*** pppd{ &ppd };// 以此类推

    // 常量指针！
    const int a{ 1000 };
    const int b{ 2000 };
    const int* cpa = {&a};// cpa是常量指针，此指针不可修改，常量修饰的是指针地址内的值
    //*cpa = 500;// 报错，因指向常量指针的值不可修改
    cpa = &b;// 地址是可以修改的，地址不是常量
	std::cout << *cpa << std::endl;

    // 指针常量！
    int a{ 1000 };
    int b{ 2000 };
    int* const pca{ &a };// pca是指针常量，常量修饰的是指针的地址
    //pca = &b;// 报错！因地址是常量不可修改
    *pca = 500;// 地址内的值可以修改

    // 常量指针的常量！
    int const a{ 1000 };
    int const b{ 2000 };
    const int* const cpca{ &a };// cpca是常量指针的常量，一经初始化不可修改。
    //cpca = &a;// 报错！地址是常量不可改
    //*cpca = 500;// 报错！值是常量不可改

    // 修改指针指向常量的值
    int const a{ 1000 };
    int* pa{ (int*)&a };// 将常量a的地址给指针pa
    *pa = 666;// 此时指针的值可以改，但a的值未改
    std::cout << *pa << std::endl;// *pa是666
    std::cout << a << std::endl;// 此时a的值仍然是1000。a是常量，*pa改不动我a的值
    // 理解->去鲁迅的地址抓周树人，鲁迅：你抓周树人跟我鲁迅有什么关系？

    // 回顾：修改指针指向变量的值
    int a{ 1000 };
    int* pa{ (int*)&a };// 将常量a的地址给指针pa
    *pa = 666;// 修改指针pa的值，本质就是修改a的值。
    // 理解->先改指针pa的值，然后再通过地址去改变量a的值。

注意：定义指针一定要指定初始化，否则非常危险。

唯一指针std::unique_ptr

特点：一块内存地址只对应一个唯一指针

	int* a{};// 原生指针
	std::unique_ptr<int> intPtr{ new int[3]{1,2,3} };// 申请3个int指针
	std::unique_ptr<int> intPtrA{};//
	intPtrA = intPtr;// 报错。唯一指针，智能有一个指向此地址的指针
	std::unique_ptr<int> intPtrA{ intPtr };// 报错。唯一指针，智能有一个指向此地址的指针

	//C++ 14以后新的申请方式
	std::unique_ptr<int[]> intPtr{ std::make_unique<int[]>(5) };// 申请5个int指针
	std::unique_ptr<int> intPtr{ std::make_unique<int>(5) };// 申请1个int指针，值为5。

	// 常用api
	intPtr.reset();// 释放内存，且设置intPtr值为nullPtr。
	a = intPtr.get();// a就会得到intPtr的地址，并且赋值给a
	a = intPtr.release();// 返回地址且设置intPtr值为nullPtr
    // 不指向内存空间，但内存占用还在，不会释放内存！！！
	intPtrA = std::move(intPtr);// 过户。把intPtr的地址给intPtrA。

共享指针std::shared_ptr

特点：一块内存地址对应多个共享指针

	int* a{};// 原生指针
	std::shared_ptr<int> PtrA{};// 申请一个 int 指针
	std::shared_ptr<int> intPtr{ std::make_shared<int>(5) };// 申请1个 int 指针，值为5。
	std::shared_ptr<int[]> ptrC{ new int[5] {1,2,3,4,5} };// 申请5个 int 指针
	std::shared_ptr<int[]> ptrD{ ptrC };// 指针赋值用法，多个指针指向同一个地址
	
	// 常用api
	ptrD.use_count();// 返回一个long，内存地址使用次数
	ptrD.unique();// 当前指针是不是最后一个使用该内存地址的指针。【C++17标准后不可使用】
	ptrD.reset();// 释放内存，且设置ptrD值为nullPtr。
    // 同时如果当前指针是最后一个拥有该内存地址的对象，则会释放该内存。

目录：C++初体验_神兽白泽-CSDN博客

>>>>>