与const相关

const

一：常变量

在c语言中，习惯使用#define 来定义常量，例如;
#define size 100;
实际上这种方法只是在预编译阶段进行字符替换，在预编译之后程序中不再有size这个字符，同时size不是变量没有类型，不占存储单元，而且非常容易出错，在c++中提出了一种更灵活，更安全的方式来定义变量，使用const修饰符来定义常量。
例如：
const int i=5; i是变量，5是常量
常量在定义时必须初始化。
const与define的区别
（一）const定义的常数是变量，也带类型，#define 定义的只是个常数
（二）define在预处理阶段起作用，const在编译运行时起作用。
（三）define只是简单的字符替换，没有类型检查。

二：类中的常数据成员与常成员函数

2.1常数据成员

const 修饰符；
若类中某些数据成员的值允许改变，而某些数据的值不想被改变，则用const修饰为常数据成员
常数据成员必须进行初始化而且不能更新，并且常数据成员只能通过初始化列表进行初始化，不能在构造函数内部进行赋值。

#include<iostream>
#include<string>
using namespace std;
class Person
{
public:
	Person(double newx,double newy);
	void disp();
private:
	double x;
	//常数据成员
	const double y;	
};
//初始化列表对常数据成员进行初始化
Person::Person(double newx,double newy):y(newy)
{
	x=newx;
}
void Person::disp()
{
	cout<<"坐标为:("<<x<<","<<y<<")";
}
 
void test01()
{
	Person p(2,1);
	p.disp();
}
int main() {

	test01();

	system("pause");

	return 0;
}

当常数据成员又是静态数据成员时，即为静态常数据成员时，其遵循静态成员的特点，需要在类外进行初始化。

#include<iostream>
#include<string>
using namespace std;
class Person
{
public:
	Person(double newx);
	void disp();
private:
	double x;
	static const double y;	
};
const double Person::y=1.0;
Person::Person(double newx)
{
	x=newx;
}
void Person::disp()
{
	cout<<"坐标为:("<<x<<","<<y<<")";
}
 
void test01()
{
	Person p(2.0);
	p.disp();
}
int main() {

	test01();

	system("pause");

	return 0;
}

2.2常成员函数：

常成员函数使得对数据的访问仅限于读取，从而保护了数据，使之不被修改。在只需要获取数据的场合，通常使用常成员函数实现。
一：对常数据成员的访问通常使用常成员函数完成。
二：const关键字常出现在形参列表之后，在这里const关键字是函数的组成部分。
三：常成员函数可访问类中的const数据成员和非const数据成员，但不可以改变他们。
四：常成员函数不可调用非const成员函数。

#include<iostream>
#include<string>
using namespace std;
class Person
{
public:
	Person(double newx,double newy);
	void disp()const;
private:
	double x;
	double y;	
};
Person::Person(double newx,double newy)
{
	x=newx;
	y=newy;
}
void Person::disp() const
{
	cout<<"坐标为:("<<x<<","<<y<<")";
}
 
void test01()
{
	const Person p(2.0,1.0);
	p.disp();
}
int main() {

	test01();

	system("pause");

	return 0;
}

常对象只能调用常成员函数，可以这么说，常成员函数是为常对象专门准备的。

三：指针与常量

3.1常量指针

顾名思意先有const关键字
例如：

const char *p="hello"
p[2]="t";//编译错误，修改了指针所指向对象的内容
p="wang"//正确，修改了指针的指向

指针指向的对象是常量，指针本身是变量。
即定义的指针p是个变量，它可以指向不同的字符串对象，但是在const的限定下此时此刻它所指向的对象是一个常量，因此可以修改p中的内容，

3.2指针常量

顾名思义先有指针，后有const关键字

 char *const p="hello"
p[2]="t";//编译正确，内存中的内容可以发生改变
p="wang"//不正确，指针的指向发生了改变。

也就是说指针本身是常量，那么指针的指向就固定了，只能指向当前字符串的内存，但是字符串中的内容是可以改变的

3.3指向常量的常指针

顾名思义两重const套上去，就限定住了谁也不可以发生改变。

const char *const p="hello"
p[2]="t";//不正确，内存中的内容不可以发生改变
p="wang"//不正确，指针的指向不可以发生了改变。

3.4const,指针与变量赋值

const对指针和变量之间的相互赋值具有一定的影响，在使用它们时应注意以下问题;:

3.4.1不能将非const对象的指针指向一个常量对象，否则引起编译错误。

int *pi;
const int i=9;//定义i是常量
pi=&i;//错误

修改方法：

const int *pi;
const int i=9;//定义i是常量
pi=&i;

3.4.2const对象的地址只能赋给指向const对象的指针，但指向const对象的指针可以被赋予一个非const对象的地址。

例如;

const int *pi;
int i=9;//i是变量
pi=&i;//常量指针指向变量
*pi=o;//错误，因为*pi是常量

四：引用与const限定符

引用不能绑定常数值，如果想用常量值去初始化引用，则必须用const去修饰，这样的引用成为const引
作用：常量引用主要用来修饰形参，防止误操作
const引用的两种方式;const引用可以用const对象和常量值来初始化。
一：const int& ref = 10;//常量值初始化
二：const对象初始化
const int a=10;
const int &b=a;
三：非const对象初始化
int temp = 10;
const int& ref = temp;
即ref是temp的别名，想要改变temp可以对ref进行操作，加const后不可以通过ref对temp进行更改。
在函数形参列表中，可以加const修饰形参，防止形参改变实参

//引用使用的场景，通常用来修饰形参
void showValue(const int& v) {
	//v += 10;//即对形参操作是违法的
	cout << v << endl;
}

int main() {

	//int& ref = 10;  引用本身需要一个合法的内存空间，因此这行错误
	//加入const就可以了，编译器优化代码，int temp = 10; const int& ref = temp;
	const int& ref = 10;

	//ref = 100;  //加入const后不可以修改变量
	cout << ref << endl;

	//函数中利用常量引用防止误操作修改实参
	int a = 10;
	showValue(a);

	system("pause");

	return 0;
}

[参考文档]：
《C++面向对象程序设计》西安电子科技大学出版社，李兰，张艳，任凤华
黑马程序员上课笔记