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