前言

const肤浅的时候就是定义常量，跟#define类似。
但是当实例化的类被限定为const类型的时候，又是一个搞怪点

正文

1
2
3
4
5
6
7
8
9
//Hack.h
#pragma once
class Hack{
public:
	int hp;
	int mp;
	int lv;
};

1
2
3
4
5
6
7
8
9
#include<iostream>
#include"Hack.h"

int main(){
	const Hack hc;
	hc.hp = 100;    //error

	return 0;
}

因为实例化的类被限定为了const，所以它也无法修改成员。

当然要修改一个const对象的时候，可以用指针+强转去逆它。

1
2
const Hack *HCP = &hc;
HCP->hp = 100;

这种方式仍然是不可取的，因为指针也被const修饰了，所以它也无法修改成员。
还好前面指针还有印象，知道怎么玩

1
2
Hack *HCP = (Hack*) &hc;
HCP->hp = 100;

然后打印一下hc.hp发现的确被修改了

当然这种方法有效，虽然还不知道有没有危害。

const的成员函数

当const修饰过的类后，这个类同时也直接无法访问成员函数了。

1
2
3
4
5
6
7
8
9
10
11
12
#pragma once
class Hack{
public:
	int hp;
	int mp;
	int lv;

	int test(){
		return hp;
	}
};

然后就有一种方式可以将函数也修饰成const类型。

1
2
3
4
5
6
7
8
9
10
11
12
#pragma once
#include<iostream>
class Hack{
public:
	int hp;
	int mp;
	int lv;

	int test() const{
		return hp;
	}
};

然后调用是能调用了，但是一看好像被优化成内联函数了

感觉有点怪异，找了个正常实例化的类的对象访问看看。

看到结果都是一样的内联的函数，想了想可能是因为函数是不像成员变量没生成一个就要重新划分内存，函数是可以放在代码区，等待调用的，而且这个函数正好也简单，被编译器优化了也有可能。毕竟内联就是替换简单的方法。

而且不知道为啥，函数还必须是有返回值的，void类型的函数好像没有用

至于const为什么不加前面，那是因为前面代表返回值类型，const在前面，哪有返回一个什么const类型的值的道理。

所以const成员就不能被改变了，在这个规则下，const对象只能调用const函数。
且this指针会自适应成const，也就是说直接修改，或者在函数里修改，或者通过this指针修改均无法生效。

骚操作可以…比如我上面那种强转指针哈哈，但是先基于逻辑上来讲是不能被修改的。

不过万一真的有需求要用const类。。。那么在一些常规的成员函数上就可能要尽量加上const，以保证const类对象能调用。

或者就是重载。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#pragma once
#include<iostream>
class Hack{
public:
	int hp;
	int mp;
	int lv;

    int test() const{
		return hp;
	}

	int test(){
		return hp;
	}
};

可以看到const类对象和正常构造的对象所调用的test是不一样的。

然后就是不同方法写在不同的地方就行了。虽然在没用到之前很鸡肋，要重复copy代码。

指针强转

然后就是之前说的通过强转指针改变

1
(Hack*)&ha;

这种方式是C语言风格的强转

1
const_cast<Hack*>(&ha);

c++的风格。。额感觉可能还是习惯C语言风格的。

反正都是那个味，效果都一样，只是正常逻辑下不期望有另类修改途径。

mutable

被mutable修饰的成员变量可以被const成员函数修改~

这个就感觉稍微滑稽了一点，也就累加的时候玩玩

当正常声明的成员变量，是肯定无法再const的函数下修改的。

但是加上mutable之后就行了。

表面上看着有点抽风，都让const成员无法修改了，还加个mutable玩
不过真到需要被修改的地方感觉也是debug的时候。

结语

const类还挺鸡肋~