【C++】Const小结

今天简单小结一下C++中的const关键字，仅仅只是就目前而言的一些理解。
C++两个重要的关键字，Const，Static，今天先说Const

1. Const修饰变量

Const修饰变量：修饰全局变量，修饰局部变量,下面用程序依次说明.

首先：Const修饰全局变量

#include <iostream>
using namespace std;
const int a = 10;

int main(int argc,char* argv[])
{
	//这里给指针初始化时，一定要类型匹配，不然会报错.
	int* p = (int*)(&a);
	cout << "全局a=" << a << endl; //result:10
	*p = 11;
	cout << "*p=" << *P << endl; //result:??
	
	system("pause");
	return 0;
}
//其实这个程序是跑不起来的
//原因:因为const修饰全局变量有一个语义约束，就是不允许修改修饰的这个全局变量，编译器会强制执行这个约束。

如果没有Const修饰可不可以呢？想必了解过指针的都知道是可以的。

#include <iostream>
using namespace std;
int a = 10;

int main(int argc,char* argv[])
{
	int* p = &a;
	cout << "全局a=" << a << endl; //result:10
	*p = 11;
	cout << "*p=" << *P << endl; //result:11
	
	system("pause");
	return 0;
}

然后：Const修饰局部变量

#include <iostream>
using namespace std;

int main()//main中的参数可写可不写，默认有
{
	const int a = 10;
	int* p = (int*)(&a);
	*P = 11;
	cout << "局部a=" << a << endl; //result:10
	cout << "*p" << *p << endl; //result:11
	//局部变量指针是可以随意修改的,局部的非const修饰就不用写了吧.
	system("pause");
	return 0;
}

细心的人应该已经看到了，上面的值不一样，不是修改了吗，应该a和*p一样才对啊。
是的，所以这里要特别说一下，volatile这个关键字。

#include <iostream>
using namespace std;

int main()
{
	volatile const int a = 19;
	int* p = (int*)(&a);
	*p = 12;
	cout << a << endl; //result:12
	cout << *p << endl; // result:12
	
	system("pause");
	return 0;
}

//这里就一致了，没有贴程序结果图，是因为加密软件限制了截图功能。你们可以自己试试，肯定是No problem.

2. Const用于类中（五种形式）

类中的Const型数据一共有五种，如下：

2.1.常对象
定义格式：类名+const+对象名
作用：定义为常对象，里面的值不允许外面以任何方式修改。

#include <iostream>
using namespace std;
class Cain
{
};

int main()
{
	const Cain c; //常对象
	system("pause");
	return 0;
}

2.2.常函数
//const一定是写在函数名后面，如下所示。
作用：建立一个常函数，函数不能修改里面的数据，为只读函数

#include <iostream>
using namespace std;
class Cain
{
	Cain(); //无参构造函数
	~Cain(); //析构函数
	void test() const;//常函数。
}


int main()
{
	
	system("pause");
	return 0;
}

2.3.常指针

常指针就分为两种形式：第一种是指向常对象的指针，第二种是指向对象的常指针

#include <iostream>
using namespace std;
class Cain
{
	Cain();
	~Cain();
public:
	int age;
};

int main()
{
	const Cain* pCain = NULL; //指针初始化
	//这里：由于指针修饰的是Cain,而不是pCain,所以为指向常对象的指针，修饰的是对象
	pCain->age = 10; //error,表达式必须是可以修改的左值
	system("pause");
	return 0;
}

//指向常对象的指针可以指向常对象，也可以指向非常对象，但是调用必须由常指针或者常引用来进行传参，否则就是错误的。

#include <iostream>
using namespace std;
class Cain
{
	Cain();
	~Cain();
};
//假如a，b都是对象。这里没有定义
int main()
{
	 Cain*const pCain = &a; //指针初始化
	//这里：由于指针修饰的是pCain,而不是Cain,所以为指向对象的常指针，修饰的是指针变量
	pCain=&b;  //error,指针的指向不能改变.
	system("pause");
	return 0;
}

//指向对象的常指针只能指向非常对象。

上面没有写什么程序，只是认识了下，所以这里对常指针做下总结：
简记：左定值，右定向；
当const在的左边，则指针指向的值不能通过指针修改，但是可以通过其他方式修改
当const在的右边，则指针的指向就不能修改
当然也可以const Cain*const pCain; 值和指向都不能改变了。

2.4.常引用
const 类名 & 引用变量名

#include <iostram>
using namespace std;
class Cain
{

};

int main()
{
	Cain c1;
	const Cain & c = c1;
	//作用：传入了引用对象的地址，且保证了在被传入的函数中，原来的数据不会被修改
	system("pause");
	return 0;
}

说明：

1.常对象中的数据并不一定都是常数据，但是对于常数据类型，必须采用构造函数参数列表化形式进行初始化，不能采用构造函数的函数体部分进行初始化

2.若待初始化对象中有数组类数据，在使用参数化列表形式的构造函数时，必须使用函数体部分，使用循环的方法进行初始化

Const暂时就说到这里，谢谢。
版权所有，转载请注明出处.

猜你喜欢