重生之我要学C++第六天

这篇文章的主要内容是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
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
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
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.友元关系不能继承。

今天的分享就到这里啦，如果对大家有帮助的话，记得收藏，希望程序猿们可以三连支持以下，会继续分享知识！谢谢阅读！