C++温习笔记（慕羽★）——指针及相关内容（上）

   本系列文章用于记录，近期温习C++过程中的一些笔记内容，本文主要记录指针相关的内容。

---

   全部内容分为上下两篇

---

---

   1、变量的地址

   在C++中，每定义一个变量，系统就会给变量分配一块内存，内存是有地址的，C++用运算符&获取变量在内存中的起始地址。

   语法：&变量名

   直接用cout输出地址可能出现异常，如直接输出char类型的变量地址，我们可以用void*强制类型转换来显示正确的十六进制地址，也可以用long long强制类型转换来显示正确的十进制地址，如下的示例1所示：

   示例1：

#include <iostream>
using namespace std;

int main()
{
    
    
    int     i;   char    c;
    bool    b;   string  s;


    //直接用cout输出地址，输出结果异常
    cout << "直接输出，char类型变量地址显示异常：" << endl << endl;
    cout << "int型变量i的地址："    <<&i << endl;
    cout << "char型变量c的地址："   << &c << endl;
    cout << "bool型变量b的地址："   << &b << endl;
    cout << "string型变量s的地址：" << &s << endl << endl;

    //解决方法1：使用void*强制类型转换来显示正确的十六进制地址
    cout << "正确的十六进制地址："  << endl << endl;
    cout << "int型变量i的地址："    << (void*)&i << endl;
    cout << "char型变量c的地址："   << (void*)&c << endl;
    cout << "bool型变量b的地址："   << (void*)&b << endl;
    cout << "string型变量s的地址：" << (void*)&s << endl << endl;;

    //解决方法2：使用long long强制类型转换来显示正确的十进制地址
    cout << "正确的十进制地址："    << endl << endl;
    cout << "int型变量i的地址："    << (long long)&i << endl;
    cout << "char型变量c的地址："   << (long long)&c << endl;
    cout << "bool型变量b的地址："   << (long long)&b << endl;
    cout << "string型变量s的地址：" << (long long)&s << endl << endl;;
}

   示例1输出结果：

直接输出，char类型变量地址显示异常：

int型变量i的地址：00000056870FF594
char型变量c的地址：烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫?0{
    
    '
bool型变量b的地址：00000056870FF5D4
string型变量s的地址：00000056870FF5F8

正确的十六进制地址：

int型变量i的地址：00000056870FF594
char型变量c的地址：00000056870FF5B4
bool型变量b的地址：00000056870FF5D4
string型变量s的地址：00000056870FF5F8

正确的十进制地址：

int型变量i的地址：371633157524
char型变量c的地址：371633157556
bool型变量b的地址：371633157588
string型变量s的地址：371633157624

---

   2、指针变量

   指针变量简称指针，它是一种特殊的变量，专用于存放变量在内存中的起始地址。

   指针变量的声明 语法：数据类型 *变量名;

   数据类型必须是合法的C++数据类型（int、char、double或其它自定义的数据类型）。星号*与乘法中使用的星号是相同的，但是，在这个场景中，星号用于表示这个变量是指针。

   不管是整型、浮点型、字符型，还是其它的数据类型的变量，它的地址都是一个十六进制数。我们用整型指针存放整数型变量的地址；用字符型指针存放字符型变量的地址；用浮点型指针存放浮点型变量的地址，用自定义数据类型指针存放自定义数据类型变量的地址。

   指针变量的赋值 语法：指针=&变量名;

   示例2：

#include <iostream>
using namespace std;

int main()
{
    
    
    int     i;   char    c;
    bool    b;   string  s;

    int     *pi=&i;  
    char    *pc=&c;
    bool    *pb=&b;   
    string  *ps=&s;

    cout << "利用取地址符&输出地址：" <<endl;
    cout << "int型变量i的地址：" << (long long)&i << endl;
    cout << "char型变量c的地址：" << (long long)&c << endl;
    cout << "bool型变量b的地址：" << (long long)&b << endl;
    cout << "string型变量s的地址：" << (long long)&s << endl << endl;;

    cout << "利用指针输出地址：" <<endl ;
    cout << "int型变量i的地址：" << (long long)pi << endl;
    cout << "char型变量c的地址：" << (long long)pc << endl;
    cout << "bool型变量b的地址：" << (long long)pb << endl;
    cout << "string型变量s的地址：" << (long long)ps << endl << endl;;
}

   示例2输出结果：

利用取地址符&输出地址：
int型变量i的地址：956305045252
char型变量c的地址：956305045284
bool型变量b的地址：956305045316
string型变量s的地址：956305045352

利用指针输出地址：
int型变量i的地址：956305045252
char型变量c的地址：956305045284
bool型变量b的地址：956305045316
string型变量s的地址：956305045352

---

   对指针的赋值操作也通俗的被称为“指向某变量”，被指向的变量的数据类型称为“基类型”。如果指针的数据类型与基类型不符，编译会出现警告，可以强制转换它们的类型，如下所示：。

    char c;
    int* i = (int*)&c;

   在64位的操作系统中，不管是什么类型的指针，占用的内存都是8字节。在C++中，指针是复合数据类型，复合数据类型是指基于其它类型而定义的数据类型，在程序中，int是整型类型，int是整型指针类型，int可以用于声明变量，可以用于sizeof运算符，可以用于数据类型的强制转换，总的来说，可以把int*当成一种数据类型。

---

   3、解引用

   指针存放变量的地址，因此，指针名表示的是地址，*运算符被称为间接值或解除引用（解引用）运算符，将它用于指针，可以得到该地址的内存中存储的值

   变量和指向变量的指针就像同一枚硬币的两面。

   示例3：

#include <iostream>
using namespace std;

int main()
{
    
    
	int no = 38;
	int *ptr = &no;

	cout<<"输出值："   << no << "   " << *ptr << endl;
	cout<<"输出地址：" << &no << "   " << ptr << endl;

	//利用指针的解引用改变变量的值
	*ptr = 68;
	cout << "改变后输出值：" << no << "   " << *ptr << endl;
	cout << "输出地址：" << &no << "   " << ptr << endl;

}

   示例3输出结果：

输出值：38   38
输出地址：0000007D4EAFFB04   0000007D4EAFFB04
改变后输出值：68   68
输出地址：0000007D4EAFFB04   0000007D4EAFFB04

---

   声明一个普通变量，声明时指出数据类型和变量名（符号名），系统在内部跟踪该内存单元。声明一个指针变量，存储的值是地址，而不是值本身，程序直接访问该内存单元。

---

   4、值传递与地址传递

   在学习指针之前，我们编写的函数采用值传递的方式，函数的形参和实参都是普通的变量，在函数中对形参进行修改，并不会影响实参的值，如示例4中的fout函数所示。

   如果把函数的形参声明为指针，调用的时候把实参的地址传进去，形参中存放的是实参的地址，在函数中通过解引用的方法直接操作内存中的数据，可以修改实数的值，这种方法被通俗的称为地址传递或传地址，如示例4中的fout2函数所示。

   相比于传值，传地址的意义在于，可以在函数中修改实参的值，可以减少内存拷贝，提升性能。

   示例4：

#include <iostream>
using namespace std;

void fout(int num, string str)
{
    
    
	cout << num << "   " << str<<endl;
    num = 66;  str = "慕羽星";
}

void fout2(int *num, string *str)
{
    
    
	cout << *num << "   " << *str<<endl;
	*num = 66;  *str = "慕羽星";
}

int main()
{
    
    
	int no; string st;

    no = 99; st = "慕羽";
	fout(no, st);
	cout << no << "   " << st << endl;

	cout << endl;

    no = 99; st = "慕羽";
	fout2(&no, &st);
	cout << no << "   " << st << endl;
}

   示例4输出结果：

99   慕羽
99   慕羽

99   慕羽
66   慕羽星

---

   5、用const修饰指针

   （1）常量指针

   语法：const 数据类型 *变量名;

   ① 不能通过解引用的方法修改内存地址中的值，用原始的变量名（即指针指向的那个变量）是可以修改的

   ② 指向的变量（对象）可以改变（之前是指向变量a的，后来可以改为指向变量b）。

   ③ 一般用于修饰函数的形参，表示不希望在函数里修改内存地址中的值。

   ④ 如果用于形参，虽然指向的对象可以改变，但这么做没有任何意义。

   ⑤ 如果形参的值不需要改变，建议加上const修饰，程序可读性更好。

   示例5：

#include <iostream>
using namespace std;

int main()
{
    
    
	int a = 3, b = 8;
    const int* p = &a;
	a = 13;  //若这里若改为使用解引用*p=13来修改a的值，则会报错
	cout << "a=" << a << ",*p=" << *p << endl;
	p = &b;
	cout << "b=" << b << ",*p=" << *p << endl;
}

   示例5输出结果：

a=13,*p=13
b=8,*p=8

–

   （2）指针常量

   语法：数据类型 * const 变量名;

   ① 指向的变量（对象）不可改变。

   ② 在定义的同时必须初始化，否则没有意义。

   ③ 可以通过解引用的方法修改内存地址中的值。

   ④ C++编译器把指针常量做了一些特别的处理，改头换面之后，有一个新的名字，叫引用。

   示例6：

#include <iostream>
using namespace std;

int main()
{
    
    
	int a = 3, b = 8;
    int* const p = &a;
	*p = 13;  //可以使用解引用*p=13来修改a的值
	cout << "a=" << a << ",*p=" << *p << endl;
	//p = &b;是会报错的，不允许修改指向的变量
	cout << "b=" << b << ",*p=" << *p << endl;
}

   示例6输出结果：

a=13,*p=13
b=8,*p=13

–

   (3）常指针常量

   语法：const 数据类型 * const 变量名;

   指向的变量（对象）不可改变，不能通过解引用的方法修改内存地址中的值。

   它有一个新的名字叫常引用。

–

   总结一下：
   常量指针：指针指向可以改，指针指向的值不可以更改。
   指针常量：指针指向不可以改，指针指向的值可以更改。
   常指针常量：指针指向不可以改，指针指向的值不可以更改。
   记忆秘诀：*表示指针，指针在前先读指针；指针在前指针就不允许改变。
   常量指针：const 数据类型 *变量名
   指针常量：数据类型 * const 变量名

---

   6、void *形参

   函数形参用void *，表示接受任意数据类型的指针。

   ①不能用void声明变量，它不能代表一个真实的变量，但是，用void *可以。

   ②不能对void *指针直接解引用（需要转换成其它类型的指针）。

   ③ 把其它类型的指针赋值给void*指针不需要转换。

   ④ 把void *指针赋值给把其它类型的指针需要转换。

   示例7：

#include <iostream>
using namespace std;

void func(string varname, void* p)
{
    
    
	cout << varname << "的地址是：" << p << endl;
	cout << varname << "的值是：" << *(char*)p << endl;
}

int main()
{
    
    
	int    a = 89;
	char b = 'X';

	cout << "a的地址是：" << &a << endl;
	cout << "b的地址是：" << &b << endl;

	func("a", &a);
	func("b", &b);
}

   示例7输出结果：

a的地址是：000000E53A39F734
b的地址是：X烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫虜怘5?
a的地址是：000000E53A39F734
a的值是：Y
b的地址是：000000E53A39F754
b的值是：X

---

   7、动态分配内存new和delete

   使用堆区的内存有四个步骤：

   ① 声明一个指针；

   ②用new运算符向系统申请一块内存，让指针指向这块内存；

   ③通过对指针解引用的方法，像使用变量一样使用这块内存；

   ④如果这块内存不用了，用delete运算符释放它。

   申请内存的语法：new 数据类型(初始值); // C++11支持{}

   释放内存的语法：delete 地址;

   如果申请成功，返回一个地址；如果申请失败，返回一个空地址（暂时不考虑失败的情况）。释放内存不会失败。

   示例8：

#include <iostream>
using namespace std;

int main()
{
    
    
	int* p = new int(6);
	cout << "*p=" << *p << endl;
	*p = 9;
	cout << "*p=" << *p << endl;
	delete p;
}

   示例8输出结果：

*p=6
*p=9

   动态分配出来的内存没有变量名，只能通过指向它的指针来操作内存中的数据。 如果动态分配的内存不用了，必须用delete释放它，否则有可能用尽系统的内存。动态分配的内存生命周期与程序相同，程序退出时，如果没有释放，系统将自动回收。就算指针的作用域已失效，所指向的内存也不会释放。 用指针跟踪已分配的内存时，不能跟丢。

---

---

   8、二级指针

   指针是指针变量的简称，也是变量，是变量就有地址。指针用于存放普通变量的地址。二级指针用于存放指针变量的地址。

   声明二级指针的语法：数据类型** 指针名;

   使用指针有两个目的：1）传递地址；2）存放动态分配的内存的地址。

   在函数中，如果传递普通变量的地址，形参用指针；传递指针的地址，形参用二级指针。把普通变量的地址传入函数后可以在函数中修改变量的值；把指针的地址传入函数后可以在函数中指针的值。

   在下面的例子中，我们想要在函数fout3中修改该指针p的值，则需要将指针p的地址作为实参传给函数fout3，而p本身就是个指针，因此在fout3的形参中要声明成二级指针。

   示例9：

#include <iostream>
using namespace std;

void fout3(int** pp)
{
    
    
	*pp = new int(3);    //通过解引用，将主函数中的p改为储存新申请的int型变量3的地址
	cout << "pp=" << pp << ",*pp=" << *pp << endl;  //此时，pp中储存的其实就是p的地址，*pp就是p的值，即变量3的地址
}


int main()
{
    
    
	int* p = 0;
	fout3(&p);

	cout << "p=" << p << ",*p=" << *p << endl; //此时p即为变量3的地址，*p即为变量3的值 3
}

   示例9输出结果：

pp=0000008FD1EFF788,*pp=000001E27B0C41D0
p=000001E27B0C41D0,*p=3

   9、空指针

   在C和C++中，用0或NULL都可以表示空指针。声明指针后，在赋值之前，让它指向空，表示没有指向任何地址。

   如果对空指针解引用，程序会崩溃。如果对空指针使用delete运算符，系统将忽略该操作，不会出现异常。所以，内存被释放后，也应该把指针指向空。

   所以在函数中，应该有判断形参是否为空指针的代码，目的是保证程序的健壮性。以防止传入空指针，而函数中又有解引用操作的情况出现，若判断出形参为空指针，则不进行解引用操作。如下的fout4函数所示：

void fout4(int* no, string* str)    
{
    
    
	if ((no == 0) || (str == 0)) return;  //若传入的no或str中存在空指针，则直接返回

	cout << "亲爱的" << *no << "号：" << *str << endl;
}

   用0和NULL表示空指针会产生歧义，C++11加入了nullptr，可以保证在任何情况下都代表空指针，也就是(void * ) 0。因此，建议用nullptr替代NULL吧，而NULL就当做0使用。（在Linux平台下，如果使用nullptr，编译需要加-std=c++11参数。）

---

   10、野指针

   野指针就是指针指向的不是一个有效（合法）的地址。在程序中，如果访问野指针，可能会造成程序的崩溃。

   出现野指针的情况主要有三种：

   （1）指针在定义的时候，如果没有进行初始化，它的值是不确定的（乱指一气）。

   （2）如果用指针指向了动态分配的内存，内存被释放后，指针不会置空，但是，指向的地址已失效。

   （3）指针指向的变量已超越变量的作用域（变量的内存空间已被系统回收），让指针指向了函数的局部变量，或者把函数的局部变量的地址作为返回值赋给了指针。

   相对应的规避方法：

   （1）指针在定义的时候，如果没地方指，就初始化为nullptr。

   （2）动态分配的内存被释放后，将其置为nullptr。

   （3）函数不要返回局部变量的地址。

   注意：野指针的危害比空指针要大很多，在程序中，如果访问野指针，可能会造成程序的崩溃。是可能，不是一定，程序的表现是不稳定，增加了调试程序的难度。

---

   11、函数指针

   函数的二进制代码存放在内存四区中的代码段，函数的地址是它在内存中的起始地址。如果把函数的地址作为参数传递给函数，就可以在函数中灵活的调用其它函数。

   使用函数指针的三个步骤：

   （1）声明函数指针；

   声明普通指针时，必须提供指针的类型。同样，声明函数指针时，也必须提供函数类型，函数的类型是指返回值和参数列表（函数名和形参名不是）

   下面给出了3个函数的原型，可以看出func1、func2、func3的函数返回值都是int型，都有一个int型的形参和一个string型的形参，尽管这3个函数的函数名和形参名不同，但他们是同一类型的函数，在进行函数指针声明的时候是一样的

int func1(int bh,string str);
int func2(int no,string message);
int func3(int id,string info);

以上三个函数的函数指针的声明如下：
int  (*pfa)(int,string);


bool func4(int id,string info);
bool func5(int id);

以上两个函数的函数指针声明分别如下：
bool (*pfb)(int,string);
bool (*pfc)(int);

   其中pfa、pfb、pfc是函数指针名，必须用括号，否则就成了返回指针的函数。

   （2）让函数指针指向函数的地址；

   对函数指针的赋值，c++中函数名就是函数的地址。

   函数指针的赋值语法：   函数指针名=函数名;

   （3）通过函数指针调用函数。

   C语言语法：    (*函数指针名)(实参);

   C++语法：    函数指针名(实参);

   示例10：

#include <iostream>         // 包含头文件。
using namespace std;        // 指定缺省的命名空间。

void fout5(string str1, string str2)
{
    
    
	cout << "笔名：" << str1 <<endl<< "博客：" << str2 << endl;
}

int main()
{
    
    
	string Name = "慕羽";
	string Blog = R"(https://blog.csdn.net/qq_44339029?spm=1001.2014.3001.5343)";

	void (*pfunc)(string, string);           // 声明函数的函数指针。
	pfunc = fout5;                           // 对函数指针赋值，语法是函数指针名=函数名。

	pfunc(Name, Blog);                      // 用函数指针名调用函数。 C++
	(*pfunc)(Name, Blog);                   // 用函数指针名调用函数。 C语言

}

   示例10输出结果：

笔名：慕羽
博客：https://blog.csdn.net/qq_44339029?spm=1001.2014.3001.5343
笔名：慕羽
博客：https://blog.csdn.net/qq_44339029?spm=1001.2014.3001.5343

   上面的例子看不出函数指针的作用，但是当我们要调用的函数是不确定时，此时就不能通过函数名来调用函数了，只能采用函数指针来调用。

   比如下面的例子中我们想要在主函数中调用foutc函数进行一些输出，但是输出的内容有一部分是不确定的，想要通过选择调用fout5或者fout6来决定这部分不确定的输出内容，此时就需要将函数指针放到foutc的形参中，如下所示：

   示例11：

#include <iostream>         // 包含头文件。
using namespace std;        // 指定缺省的命名空间。

void fout5(string str1, string str2)
{
    
    
	cout << "笔名：" << str1 <<endl<< "博客：" << str2 << endl;
	cout << "怕什么真理无穷，进一寸有一寸的欢喜" << endl;
}

void fout6(string str1, string str2)
{
    
    
	cout << "笔名：" << str1 << endl << "博客：" << str2 << endl;
	cout << "很高兴认识大家"<<endl;
}

void foutc(string name, string blog,void (*fout)(string ,string))
{
    
    
	cout << "大家好！！！"<<endl;
    fout(name, blog);
	cout << "期待下一次的相遇！！！";

}

int main()
{
    
    
	string Name = "慕羽";
	string Blog = R"(https://blog.csdn.net/qq_44339029?spm=1001.2014.3001.5343)";

	foutc(Name, Blog,fout5);
	cout << endl << endl;
	foutc(Name,Blog,fout6);

}

   示例11输出结果：

大家好！！！
笔名：慕羽
博客：https://blog.csdn.net/qq_44339029?spm=1001.2014.3001.5343
怕什么真理无穷，进一寸有一寸的欢喜
期待下一次的相遇！！！

大家好！！！
笔名：慕羽
博客：https://blog.csdn.net/qq_44339029?spm=1001.2014.3001.5343
很高兴认识大家
期待下一次的相遇！！！