这篇文章的主要内容是const以及权限问题、static关键字、友元函数和友元类，希望对大家有所帮助，点赞收藏评论支持一下吧！
更多优质内容跳转：
const以及权限问题
1.const修饰内置类型
const名叫常量限定符，用来限定特定变量，使得这个变量不可被修改，这在特定的情况是非常实用的，比如一些只读不可写的变量，可以用const来限定。
(1).const修饰普通变量
在C++或者C语言中，const修饰普通变量的形式如下：
const int a = 10;
也可以将const和变量相邻
int const a = 10;
对于普通变量，这两种写法是一样的，都是限制a变量，使得a变量不可被修改。
强行修改会出现编译错误。这就是常量限定符的作用。
(2).const修饰指针变量
先给出变量a的指针p
1. int a = 10; 2. int* p = &a;
这里两点非常重要：const直接修饰p，会导致p不可改变，即指针指向不能改变。
const直接修饰*p，会导致*p不可改变，即指针指向的内容不可改变。
此时，会出现以下三种const对指针变量p的修饰
1. (1)const int* p = &a; 2. 等价写法:int const * p = &a;
此时，const在*p前面，直接修饰*p，即指针指向的内容(*p)不可改变，但指针指向(p)可以改变。
(2)int* const p = &a;
此时，const在p前面，直接修饰p，即指针指向(p)不可改变，指针指向的内容(*p)可以改变。
(3)const int* const p = &a;
此时const双重限定，既在*p前面，又在p前面，即指针指向(p)和指针指向内容(*p)都不可改变。
2.const修饰自定义类型
const也可以修饰自定义类型对象，赋予对象常属性，保护对象内的成员变量不可被修改。const对象调用它的成员函数时，this指针也是const类型。
有关this指针详细介绍：重生之我要学C++第三天（类和对象）_无极太族的博客-CSDN博客
用Date类来举例：
1. #include<iostream> 2. using namespace std; 3. class Date 4. { 5. public: 6. Date(int year = 1, int month = 1, int day = 1) 7. { 8. _year = year; 9. _month = month; 10. _day = day; 11. } 12. void Print() 13. { 14. cout << _year << "/" << _month << "/" << _day << endl; 15. } 16. private: 17. int _year; 18. int _month; 19. int _day; 20. }; 21. int main() 22. { 23. const Date d1;//创建const类型对象d1 24. return 0; 25. }
此时，用d1调用成员函数
d1.Print();
会出现编译错误。原因是const对象调用成员函数时，传给成员函数的this指针也是const类型。
但是此时成员函数的隐式形参是非const类型的this指针
void Print(Date* const this)//这个const是默认的，保证指向不能改变但是指向的内容还是可以改变
就会将const对象指针传给非const对象指针，涉及权限的放大：const对象的成员变量是不可以修改的，但是这个this指针只是指向不能改变，指向的内容还是可以改变。
要想解决这个问题，就需要将成员函数内的隐式形参this指针改为const类型。下面介绍const和函数有关概念来解决这个问题。
3.const修饰函数
(1).const修饰函数形参
const修饰函数形参的作用是用const类型对象来接收实参，保证实参不会被改变。在成员函数中，形参还有隐式的this指针，用来接受对象的地址。但是由于这个形参是隐式的，我们无法直接将其改为const类型。这时只需要在成员函数后面加上const
1. void Print()const 2. { 3. cout << _year << "/" << _month << "/" << _day << endl; 4. }
相当于给隐式的this指针加上const(前面的const)
void Print(const Date* const this)
这样const对象就可以调用对象的这个const成员函数了。
在这里const加在*this前面，意味着this指向对象的内容不可以改变。
const修饰this指针还可以构成函数重载：在对象调用的时候，const对象和非const对象分别调用
1. const void Print()const //const对象调用:只读 2. { 3. cout << _year << "/" << _month << "/" << _day << endl; 4. } 5. void Print() //非const对象调用:可读可写 6. { 7. cout << _year << "/" << _month << "/" << _day << endl; 8. }
(2).const修饰函数返回类型
const修饰函数的返回类型可以限制对象，保证返回对象不可被改变。
4.权限的放大、缩小、平移
在C++中，权限只能平移，缩小。禁止放大。例如：
1. const int a = 10; 2. int& b = a;
此时会出现编译错误，因为a是const类型，不能改变。但是引用b不是const类型，b可以间接改变a，所以会编译错误。 这就是权限的放大。
1. const int a = 10; 2. const int& b = a;
这样就是权限的平移。
1. int a = 10; 2. const int& b = a;
这就是权限的缩小。
注意：隐式类型转换中间会生成临时变量，临时变量具有常性。
举个栗子：
1. double d = 1.1; 2. int& a = d;
此时编译错误，原因不是类型不匹配，而是d赋值给int类型引用a时，会将d先隐式类型转换为const int& 类型，这时候只需将代码改为
1. double d = 1.1; 2. const int& a = d;
就可以通过编译。
static的效果
定义：声明为static的类成员称为类的静态成员，用static修饰的成员变量，称之为静态成员变量；用 static修饰的成员函数，称之为静态成员函数。静态成员变量一定要在类外进行初始化。
(1).静态成员变量
在类中static修饰的变量称为静态成员变量，由于static修饰，该成员变量在静态区存放，属于该类。类的所用对象公用，并不单独属于某个对象(这个特点和成员函数类似)，所以静态成员变量的定义不在参数列表中，必须在类外面进行定义，类里负责静态成员变量的声明。
1. #include<iostream> 2. using namespace std; 3. class A 4. { 5. private: 6. static int _a;//声明 7. }; 8. int A::_a = 0;//类外定义 9. int main() 10. { 11. A a; 12. return 0; 13. }
(2).静态成员函数
在类中static修饰的成员函数称为静态成员函数，由于static修饰，该成员函数属于类。由于静态成员函数没有隐式this指针，在特定对象调用时，只能访问该类的静态成员变量，不能访问对象的非静态成员变量。可以类名::静态成员函数名 直接调用。
补充，类外面突破类域的三种方式（友元下面介绍）：
不使用友元访问成员变量或者成员函数必须是共有的。
1.创建对象，通过 对象. 适用于访问公有(静态、非静态)成员变量和函数。
2.对象指针，通过 指针-> 当指针为空时，可以访问公有成员函数(静态非静态)和公有静态成员变量。因为公有成员函数和公有静态成员变量都不属于对象，不会有解引用空指针的错误。当指针不为空，和对象的访问权限相同。
3.通过 类名:: 适用于访问公有静态成员变量和公有静态成员函数。此处只能访问属于类的静态属性的成员。
友元函数&友元类
(1).友元函数
定义：友元函数可以直接访问类的私有成员，它是定义在类外部的普通函数，不属于任何类，但需要在类的内部声明，声明时需要加friend关键字。例如：
1. #include<iostream> 2. using namespace std; 3. class A 4. { 5. friend void Print(A& a);//友元函数声明 6. private: 7. int _a=1; 8. }; 9. void Print(A& a)//友元函数定义 10. { 11. cout << a._a << endl;//friend就可以直接访问类的私有成员 12. } 13. int main() 14. { 15. A a; 16. Print(a); 17. return 0; 18. }
注意：
1.友元函数不能用const修饰
2.一个函数可以是多个类的友元函数
(2).友元类
友元类可以直接访问类的私有成员，友元类和另一个类相互独立，只允许该类的友元类访问该类的私有成员，不允许该类访问友元类的私有成员。
1. class Time 2. { 3. friend class Date; // 声明日期类为时间类的友元类，则在日期类中就直接访问Time类 4. 中的私有成员变量 5. public: 6. Time(int hour = 0, int minute = 0, int second = 0) 7. : _hour(hour) 8. , _minute(minute) 9. , _second(second) 10. {} 11. 12. private: 13. int _hour; 14. int _minute; 15. int _second; 16. }; 17. class Date 18. { 19. public: 20. Date(int year = 1900, int month = 1, int day = 1) 21. : _year(year) 22. , _month(month) 23. , _day(day) 24. {} 25. 26. void SetTimeOfDate(int hour, int minute, int second) 27. { 28. // 直接访问时间类私有的成员变量 29. _t._hour = hour; 30. _t._minute = minute; 31. _t._second = second; 32. } 33. 34. private: 35. int _year; 36. int _month; 37. int _day; 38. Time _t; 39. };
友元类特性：
1.友元关系是单向的，不具有交换性。 比如上述Time类和Date类，在Time类中声明Date类为其友元类，那么可以在Date类中直接 访问Time类的私有成员变量，但想在Time类中访问Date类中私有的成员变量则不行。
2.友元关系不能传递 如果C是B的友元， B是A的友元，则不能说明C时A的友元。
3.友元关系不能继承。
今天的分享就到这里啦，如果对大家有帮助的话，记得收藏，希望程序猿们可以三连支持以下，会继续分享知识！谢谢阅读！
