c++类之入门 ！const不在迷糊！

类来了！

什么是类？ 它是一个十分人性化的抽象概念，为什么在更多的实际项目中面向对象更有优势？就是因为类的存在，一个人：有名字，有身高，有体重，同样的它会测量自己身高，会跳，会打游戏！这里就分出类中成员变量和成员函数的区别！一个是指标一个是行为动作！

接下来来看看究竟什么是类!

class Person  //class + 类名  ,和struct很像
{
	int Age;     //年龄
	const char* Name;   //姓名
	void Jump();     //跳
	void Fight();  //打架
}；
//接着在main中定义一个我，然后初始化！
int main()
{
	Person me{100,"土豆"};   //这里就会报错了，为什么呢？
}

访问限定与Getter、Setter

1、首先类中的访问属性有public、private和另外一种（另一种现在用不到，不讲）

2、public：就是公开，谁都可以访问。

3、private类中自己才能访问！（刚学就这么理解吧!）

4、class不加限定符，则就是private属性；与struct不同，struct默认则是public属性!

所以需要一定的手段来进行设置private属性的类成员变量和读取变量，这里就用到书中常说的Setter和Getter函数。代码如下：

class Person  //class + 类名  ,和struct很像
{
private:
	int Age;
	const char* Name;
public:
	//所有的Setter和Getter尽可能添加inline关键字！
	inline int Get_Age() {return Age;} 
	inline void Set_Age(int _Age) {	Age = _Age;}
	inline const char* Get_Name() {	return Name;}
	inline void Set_Name(const char* _Name) {Name = _Name;}
	void Jump();
	void Fight();
};
int main()
{
	//这种就行不通了
	//Person me{100,"土豆"};  
	//这样设置它
	Person me; me.Set_Age(20); me.Set_Name("航行的土豆");  
	//这样读取它
	cout << "我的名字:" << me.Get_Name() << " 年龄:" << me.Get_Age() << endl;  
}

补充:

这里就可以通过Getter和Setter函数来读取private属性的成员变量和设置它了！那么加inline关键的目的就是告诉编译器可以优化它！记住是可以，而编译器优化与否！我们也不知道（可以通过反汇编看看是否优化了）;

this指针之便利

什么是this指针？

通俗点，我出生了，有一个上帝的眼睛注视着我，它看到的我的属性，它强迫我做事！它就是我自己的一个缩影，它同时指向我，对！！！没错，它就是我的一个指针！

直接引入代码看看它的优越性:

class Person  //class + 类名  ,和struct很像
{
private:
	int Age;
	const char* Name;
public:
	inline int Get_Age() {return Age;}
	//这里返回自己的引用
	inline Person& Set_Age(int _Age)
	 { Age = _Age; return *this; } //this是指向自己的指针，加*就是取内容
	inline const char* Get_Name() {	return Name;}
	//这里返回自己的引用
	inline Person& Set_Name(const char* _Name)
	 { Name = _Name; return *this; } //this是指向自己的指针，加*就是取内容
	void Jump();
	void Fight();
};

int main()
{
	//Person me{100,"土豆"};
	//Person me; me.Set_Age(20); me.Set_Name("航行的土豆");
	Person me; 
	 //这样就形成链式法则！连续设置！！！！是不是很神奇呢？
	me.Set_Age(20).Set_Name("航行的土豆"); 
}

类之const限定

在前面博客中，我也有说了关于const的各种分不清的概念！什么常量指针、指针常量、指向常量的常量指针！这些乱七八糟的，但是在类中可能稍稍有点不同，上面那些都是作为类型来使用，而在类中，const可以算是一种修饰符！（自我理解）

为了更好的说明，直接上代码:

//类还是上面的类，这里main中定义const对象
int main()
{
	const Person me; 
	//下面这句直接报错，为啥呢？
	cout << me.Get_Age() << me.Get_Name();  
}

利用const实例化类，竟然发现一个成员函数都用不了了！如何解决呢？只要在类中函数声明后面加一个const限定即可!

修改如下：

//原始
inline int Get_Age(){ return Age; } 
//改为下面
inline int Get_Age() const { return Age; } 

//这句是肯定报错的,不能这样用
inline void Set_Age(int _Age)const { Age = _Age; }  

//若改成这样,肯定也会报错的
inline int& Get_Age() const { return Age; } 

注意！！！
需要用const修饰的成员函数，函数体内一定不能有任何修改成员变量的行为，一律会报错！读取成员变量的值可以! 以引用或者指针方式传出都不可以！！！！

总结:
1、const对象只能调用const成员函数!
2、const成员函数下，this指针是const类型的!

const成员函数重载

既然我们实例化的对象有const型也有不是const的，那么我们成员函数用起来是不是很不方便呢？如何解决？函数重载一下就ok完美解决！代码如下:

	//拿这个举例
	inline int Get_Age()const { return Age; }
	inline int Get_Age() { return Age; }

结果:
非const对象的调用非const成员函数

const对象调用const成员函数

总结: 可见是没有问题的！const重载还真好用！

const_cast之去掉const属性！

语法:

const_cast<类型>(变量)

为什么要去掉const属性？？有一些移植或者历史的残留原因等等！这个留给大佬去探讨，虽然用的情况比较少，但还是有个学习储备的过程的！

下面举个例子说明：

void Older(Person* p)
{
	
}
int main()
{
	const Person user;
	const Person* puser{&user};
	//当出现下面这种情况下呢？就出现类型不匹配情况！编译过不去,如何解决？
	//Older(puser);   
	//解决方法
	Older(const_cast<Person*>(puser));
}

注意： 使用之前确保Older函数不会改变对象的内容！！！

const搭配之mutable助手

前面我们说过，const成员函数无法修改成员变量，但是若是我们有这样的需求呢？这就用到mutable关键字了!

举例如下：

class Person  
{
private:
	mutable int Age;
	mutable const char* Name;
public:
	inline int Get_Age()const { return Age; }
	inline void Set_Age(int _Age)const { Age = _Age;  }
	inline const char* Get_Name()const {return Name;}
	inline void Set_Name(const char* _Name)const { Name = _Name;}
	void Jump();
	void Fight();
};

int main()
{
	const Person user;
	user.Set_Age(18); user.Set_Name("航行的土豆");
	cout << "年龄为" << user.Get_Age() <<"姓名为:"<<user.Get_Name() << endl;
}

结果:

这里看到结果正常，const类可以通过const成员函数来修改mutable修饰的成员了！！！

老铁们，我是航行的小土豆！！努力学习中，，希望大家多点点赞支持支持！！！