C++中const和#define的利弊探索

const和#define的利弊，从而推导const的意义；

const和#define都有相似的功能，那就是定义一个“常量”；

想用来替换#define定义常量这种方式。这是一种定义宏的方式。由于宏替换定义常量有必定的缺陷：不作类型检查，没有做用域限制（这样很容易被后续污染）。

#include<iostream>
#include<string>
using namespace std;

void myfunc1() {
	#define a 10
}

void myfunc2() {
	printf("a=%d\n", a);
}

int main() {
	printf("外面打印：a=%d\n", a);
	myfunc1();
	myfunc2();

	system("pause");
	return 0;
}

由于只作字面上的直接替换，全局都有效，因此不管定义在哪里，全局均可以访问。由于是在预编译的时候就替换好了（只要有定义，就在预编译的时候进行全程替换，因此外面里面均可以访问）。

同时，很容易受到污染。

#include<iostream>
#include<string>
using namespace std;

#define a 10

void myfunc1() {
	#define a 20
	printf("myfunc1里面的：a=%d\n", a);
}

void myfunc2() {
	printf("myfunc2里面的：a=%d\n", a);
}

int main() {
	printf("外面打印：a=%d\n", a);
	myfunc1();
	myfunc2();

	system("pause");
	return 0;
}

提示有宏重定义，结果所有都改变为新的：

宏的方式至关于全局变量，不管在函数里仍是函数外命名的时候都要精心雕琢（有点头痛），不然很容易在之后新的函数中不当心被替换掉，这就是为何用它定义常量都基本上所有大写，而变量都弄成小写，这样既然不记得有多少宏名了，也不至于冲突。可是它的全局性仍是没有解决。

而const由于有做用域限制，解决了污染全局变量的困扰。

下面的程序是不行的：

#include<iostream>
#include<string>
using namespace std;

void myfunc1() {
	const int a = 20;
	printf("myfunc1里面的：a=%d\n", a);
}

void myfunc2() {
	printf("myfunc2里面的：a=%d\n", a);
}

int main() {
	printf("外面打印：a=%d\n", a);
	myfunc1();
	myfunc2();

	system("pause");
	return 0;
}

定义个全局的只读变量：

#include<iostream>
#include<string>
using namespace std;

const int a = 10;
void myfunc1() {
	const int a = 20;
	printf("myfunc1里面的：a=%d\n", a);
}

void myfunc2() {
	printf("myfunc2里面的：a=%d\n", a);
}

int main() {
	printf("外面打印：a=%d\n", a);
	myfunc1();
	myfunc2();

	system("pause");
	return 0;
}

里面的既不干扰外面的，还能够有优先级之分，同时要作全局也能够作全局。

这样新作的函数中要想使用a这个名字了，不用考虑什么，直接用就是了。不会影响之前外面定义的全局变量a，是否是省事的多啊。

const是只读变量，本质上仍是变量，是变量就能够传递参数，而const还作类型检查，因此好处更多，如：作形参，能够接收不一样的参数，更灵活。

你不能在里面把个人变量给改了吧，能够传递不一样的变量，所以就晓得更灵活了；

#include<iostream>
#include<string>
using namespace std;

void myfunc1(const int k) {
	printf("myfunc1里面的数据=%d\n", k);
}

int main() {
	const int a = 20;
	myfunc1(a);

	const int b = 30;
	myfunc1(b);

	system("pause");
	return 0;
}

const的应用：

因为是只读变量，所以保护了外面的实参，外面传递实参进来，在函数体里不能修改。所以让外面的实参获得安全性考虑。

#include<iostream>
#include<string>
using namespace std;

void myfunc1(const int* k) {
	*k = 3;
	printf("myfunc1里面的数据=%d\n", k);
}

int main() {
	const int a = 20;
	myfunc1(&a);

	system("pause");
	return 0;
}

宏替换的方式至关于弄全局变量，很容易被污染，没有做用域限制，作不了优先级区分。它是在预编译的时候就被替换了。

而const是在编译的时候才分配变量，有做用域区分，和类型一致的安全性检测，应用const来开发项目更方便灵活...

宏替换定义的是常量，一定全局有效；

const定义的是只读变量，有做用域之分，能够作全局的，也能够作局部的，还有优先级之分。既方便又安全，能够代替#define了。那为何都存在？由于也都有好处，只是想拿各自的好处罢了：

宏替换的方式，让整个编译过程变慢（预编译时间+真正编译的时间），可是让程序运行速度变快，由于早已直接替换好了（宏展开），直接运行就得了。

 

const和它相反，整个编译时间少，可是程序运行速度慢点了，由于要找内存空间开辟变量...