C++中你可能会忽略掉或者搞错的重要知识

一、顶层const和底层const

修饰的是带有指针类型的变量。

这里我们先区分下要讲的概念：

int a = 10;
int *p = &a;

指针本身是指p（值为&a），指针指向的对象是指*p（值为a）

你可以这样理解顶层：就是最顶端，最原始的东西，一个变量有一个值和地址，值是通过地址得到的，所以，地址在顶层，而const是说常量，那么合起来，顶层const就是地址是一个常量，那么底层const就是说值是一个常量

顶层const：

int a = 10;
int * const p = &a;

• 修饰的是指针本身（也就是p），表示地址不可以修改。也就是说不能修改p的指向（p的值始终只能是&a），但是可以修改p指向对象的值，也就是修改*p（也就是a）的值。

// 接上
int b = 15;
p = &b; // 这里是错误的，p是顶层const，不能修改 
*p = b; // 这里是正确的，修改的是*p的值，也就是指针指向的对象的值。

底层const：

int a = 10;
const int* p = &a; // int const* p = &a; 都是正确的。

修饰的是值，表示指针指向的对象的值不可以修改。*p（也就是a）的值不能修改。

区分方法：

最简单的区分方法是看const关键字的位置：

①int * const p

放在*右边就是修饰p，修饰的是地址，就是顶层const

②int const *p 或 const int *p

放在*左边，表示修饰的是*p，修饰的是值，就是底层const

二、指针和引用

引用：并非对象，是对另一个已经存在的对象起的另外一个名字。
指针：是一个对象，指向一种类型的复合类型。

这里最大的区别在于，引用不是对象，而指针是对象，怎么去理解呢？就是指针可以获取到指针本身的地址，例如int *a; &a是指针本身的地址值，而a是指针所指的对象的地址。而引用不一样，它本身没有地址，它的地址为引用的对象的地址。

这里会有这样几个现象：

①指向指针的指针：

int *a; // a是一个对象（指针本身是对象）
int* *b = &a; // 正确的，b是指向一个指针（int*）的指针

对于指针来说，指针本身是一个对象，是有地址的。所以可以把指针本身看作一个对象，这时候用其他的指针指向这个对象，这是没有问题的，这里无论套多少层都是可以看成指向指针的指针。

②指向引用的指针（不存在的，是错误的，不要以为是对的！）

int a = 10;
int &b = a;
int &*p = &b; // 错误！相当于 int &(*p) = &b;

我们知道引用只是给其他变量取的一个别名，那么本身是不应该存在有地址一说的，*p是个指针，本身就具备地址，就与引用产生了矛盾，所以这里是不成立的。

三、引用的一些用法：

①允许常量引用绑定非常量的对象，反之则错误

int a = 10;
const int &b = a; // 正确

const int &c = 10;
int d = c; // 错误

我们进行类型转换的时候，我们可以将高精度、高容量向低精度、低容量直接转化。所以这里只能将非常量直接转为常量

四、char类型

①char类型的定义：

  先说下char，这是c风格字符串，是一种约定俗成的写法，字符串及字符数组都要以空字符结尾（‘\0’）。也就是说我们定义char* str = “123”;这个字符串后面会存在一个空字符。（注意string类型不一样，string类型没有结尾的’/0’）

char* str = "123";
cout << sizeof(str) << endl; // 这里输出的值为4，因为str的内容实际为：{'1' '2' '3' '\0'}

②char类型的输出：

char a = 's';
cout << a << endl; // 输出 s
cout << &a <<endl; // 错误，出现不确定值

单字符输出的情况，是直接输出字面值。如果采用地址输出的话，就会变成乱码，因为c风格字符串默认以'/0'结尾，它会不断读取直到出现'\0'为止，所以基本输出都是乱码，不排除运气好，正好后面出现了结束符，这样可能没有乱码。

char *s = "hello"; // 会有警告，由于低容量转化为高容量，正确无警告：const char* s = "hello";
char s2[] = "hello";

cout << *s << " " << *s2 << endl; // 输出 h h
cout << s << " " << s2 << endl; // 输出hello hello

字符串输出，字符串的变量名表示字符串的首地址，输出这个首地址，就可以输出整个字符串了（字符串在定义的时候默认最后一位是'/0'字符）。

如果加上解引用符号*的话，代表的是单个值，也就是字符串首地址对应的字面值。

五、char *s 和 char s[]的区别

char* s = "hello";
char s2[] = "hello";

先说他们的区别吧，s是指针，它的特性取决于它指向的对象，比如这里的话，它指向了一个字符串常量，所以s[n]是不可以修改的，但是s的指向是可以随便修改的（所以可以进行自增减等运算），下面的操作是正确的！

while(s!= '\0')
{
	cout << *s << endl; // 注意s指向的是常量，所以不能改变它的值
	s++;
}

s2的话，是一个分配了地址的字符数组，它里面的值只跟他自己定义有关，我们定义的是非常量字符数组的话，s2[n]的值是可以修改的。但是s2是分配了具体的地址，所以s2的指向是不能修改的（所以不能进行指针的一些计算）。

while(*s2 != '\0')
{
	cout << *s2;
	s2++; // 错误，这里的s2不是指针，它是一个实际的地址，这个地址值是不能修改的
}

for(int i = 0; i < sizeof(s2) - 1; i++)
{
	cout << s2[i]; // 正确，并可以改变它的值
}

注意：

我们要知道，指针是一个对象，指针有自己的地址，它指向的类型的地址，是作为值保存在这个地址上，可以见下图：（用于解释上述内容，不具准确性）

对于第一种情况，指针并不是直接存储"hello"这个字面值，而是保存它字面值存放的地址，由于"hello"是一个字面值，是一个常量值，是直接分配在常量池的，我们s只是指向它，由于这个值是常量值，所以它的值没法修改，而且定义的时候还会有警告，如果我们加上底层const修饰，警告会消除。

六、int (*ptr)[10] 和 int* ptr[10]的区别

① 这里先讲下数组的一些只是，数组不允许拷贝和赋值（prime c++上是这样写的，但是我觉得应该是数组名不允许拷贝和赋值）

int a[] = {0,1,2,3};
int a2[] = a; // 错误，不允许拷贝
a2 = a; // 错误，不允许赋值

② 其次不存在引用的数组。

int& a[10] = xxx; //错误，引用不是对象，没法分配内存，所以这样的数组是不存在的。

③ &数组名：表示指向整个数组的指针。
数组名：表示数组第一个元素的地址。

下面就是正式的内容了：

int (*ptr)[10]：

这里的*修饰的是ptr，说明ptr是个指针，它是一个指向有10个整型变量的数组的指针。

int a[10] = {0,1,2,3,4,5,6,7,8,9};
int (*ptr)[10] = &a; // 这里只能使用&a，如果使用a就会出错，他会告诉你：不能将int *类型传递给int (*)[4]这种类型

int ptr[10];*
这里的ptr是一个数组的首地址，该数组有10个对象，每个对象的类型是int*，就是保存了10个整型指针的数组。

int a = 10;
int* b = &a;
int* ptr[10] = {b,b,b,b,b,b,b,b,b,b}; // 这里面保存的全是 int* 指针

七、函数指针

函数指针指向函数而非对象，和其他指针一样，函数指针指向某种特定类型。函数的类型由它的返回值和形参共同决定，与函数名无关。

① bool* pf(const string&,const string&);
② bool (*pf)(const string&,const string&);

比较上面两种声明方式，第①种并不是函数指针，因为*修饰的对象变成了返回值（优先级的原因），这里就变成了pf是一个函数了，返回值是bool*类型。

第②种方式为正确的函数指针的声明，*修饰的是pf，表示pf是一个指针，指向一个返回值为bool，参数为(const string&,const string&)的函数。

由于函数的类型是由返回值和形参决定的，所以函数指针代表的为一类函数，具体要使用哪个函数，我们还得给他赋值。

int testFunc(int a, char c, float f)
{
    cout << a ;
    cout << c;
    cout << f << endl;

    return a;
}

int (*pf)(int,char,float);

int main()
{
	int a = 0;
	char c = 'k';
	float f = 1.0;

	pf = testFunc; // 这里也可以写 pf = &testFunc;
	int sum = pf(a,c,f);
	cout << sum << endl;
}

结果截图：

八、函数指针形参

函数指针作为参数传递：

void func(bool pf(const string&,const string&,...))
void func(bool (*pf)(const string&,const string&,...))

int testFunc(int a, char c, float f)
{
    cout << a ;
    cout << c;
    cout << f << endl;

    return a;
}

void func(int a,char c,float f,int myFunc(int,char,float)) // 或者写成 func(int a,char c,float f,int (*myFunc)(int,char,float))
{
	int sum = myFunc(a,c,myFunc);
	cout << sum << endl;
}

int main()
{
	int a = 0;
	char c = 'k';
	float f = 1.0;

	func(a,c,f,testFunc);
}

结果截图：

还有一种方式，就是使用std::function，需要包含头文件<functional>,std::function 可以用来包装函数、函数指针和lambda表达式等可调用对象。

std::function<T<S...>>表示返回类型为T，参数为S...（可以有多个入参）的函数。

上面的方法可以这样写：

std::function<int(int,char,float)> callback;

int testFunc(int a, char c, float f)
{
    cout << a;
    cout << c;
    cout << f << endl;

    return a;
}

int main()
{

	int a = 0;
	char c = 'k';
	float f = 1.0;

	callback = testFunc;

	int sum = callback(a,c,f);
	cout << a << endl;
}

九、返回指向函数的指针

  我们一般是无法返回函数的，只能通过返回函数指针的方法返回。所以我们要将返回类型写成指针形式，由于编译器不会自动将函数返回类型当作对应的指针类型处理。所以，想要声明一个返回函数指针的函数，最简单的方法是使用类型别名。下面这种写法是错的：

int (*)(int,char,float) retFunc() // 错误
{
	return testFunc;
}

using F = int (int,char,float); F为函数类型，并非为函数指针类型（为啥我就不说了，上面内容有）
using PF = (int*)(int,char,float) PF为函数指针类型

像下面这样定义就是正确的：

PF retFunc() // 错误
{
	return testFunc;
}

我们可以调用一下试一试：

int testFunc(int a, char c, float f)
{
    cout << a;
    cout << c;
    cout << f << endl;

    return a;
}

using PF = int(*)(int,char,float);

PF retFunc(){
    return testFunc;
}

int main()
{
    pf = retFunc();
    int sum = pf(0,'k',1);
    cout << sum << endl;
}

结果截图：