C++之const

目录

笔试题考点：

const作用:

1.const可以定义常量

2.const可以定义指针

3.const可以修改函数形参--提高程序的可读性和健壮性

笔试题考点:

4.const可以修饰成员函数--放在函数参数外面---常成员函数--在此函数中不能修改本类数据成员的值

5.const可以修饰函数返回值---返回值为引用才有意义

6.假设只想输出m_i或者m_j中的一个

7.思考--想在主函数中修改m_i的值 

笔试题考点：

构造函数除了能构造对象还可以用作类型转换\n\n当前构造函数中整形作为函数参数，所以可以用一个整型去对对象进行初始化

A b=7；//用7初始化b

class A
{
public:
	A():m_i(NULL)
	{}
	A(int i) :m_i(i)
	{
		cout << "A" << i << endl;
	}//构造函数可以用作类型转换，将int转换为类对象 A b
	
	void print()
	{
		cout << m_i << endl;
	}
private:
	int m_i;
};

void main()
{
	A c();//声明函数c,无参，返回类型为A
	A d;//如果要定义无参对象，那么一定不能带()
	A a(5);//调用了构造函数
	A b = 7;//调用了构造函数,用7初始化b,
	a.print();
	//b.print();
}

A c();//声明函数c,无参，返回类型为A
A d;//如果要定义无参对象，那么一定不能带()//调用的是 A():m_i(NULL){}
A a(5);//调用了构造函数A(int i) :m_i(i)
A b = 7;//调用了构造函数,用7初始化b,
a.print();//打印函数

explicit A(int i) :m_i(i)
	{
		cout << "A" << i << endl;
	}//加了一个限定符（explicit：明确，确定）

限定符：explicit，明确了构造函数只能构造对象，不允许转换类型

添加了explicit（限定符)：目的是消除改类型的转换写法；修改构造函数

A b = 7;//调用了构造函数,用7（int类型）初始化b（A类型）,将A类型加上限定符，这句话错误

const作用:

在C中是只读，在C++中是常量

1.const可以定义常量

const int a = 10;必须在声明的时候初始化

void main()
{
	const int a = 9;
	a = 10;//error
	const int a = 10;//ok
}

2.const可以定义指针

  指针本身
  指针所指向的内容

void main()
{
	int a = 10;
	cout << "a修改前" << a << endl;

	const int* p1 = &a;//p1本身是指针变量，所指向的内容不能修改
	int const* p2 = &a;//同上
	int* const p3 = &a; //const修饰p3本身
	const int* const p4 = &a;//p4本身和所指向内容都不能修改
	

	cout<<"*p1"<< * p1 << endl;
	cout<<"a当前的值"<<a << endl;

	//(*p1) = 60;//error，*p1所指向的内容即就是a不能改变
	cout << "p1" << p1 << endl;
	p1++;
	cout << "p1" << p1 << endl;
	
    //p3++;//error，p3被const修饰，即就是本身不能改变
	cout << "*p3" << *p3 << endl;
    cout<<"a当前的值"<<a << endl;
	(*p3)++;
	cout << "*p3" << *p3 << endl;
    cout<<"a当前的值"<<a << endl;
	
    //p4++;//error
	//(*p4)++;//error
    //p4是前三个的并集都不能改变
}

const int* p1 = &a;//p1本身是指针变量，所指向的内容不能修改（*p1)
int const* p2 = &a;//同上
int* const p3 = &a; //const修饰p3本身(p3不能改变)
const int* const p4 = &a;//p4本身和所指向内容都不能修改（*p4和p4）

3.const可以修改函数形参--提高程序的可读性和健壮性

int strcmp(const char*str1,const char*str2)
char *strcpy(char *dest,const char*src)

笔试题考点

char *strcpy(char *dest,const char*src),第一个参数dest代表的是目的字符串的首地址，为什么还需要函数返回值？

---实现链式表达式

char *strcpy(char *dest,const char*src)
cout<<strlen(strcpy(p,"123456"))<<endl;//实现链式表达，一步求出p的长度

void mystrcpy(char *dest,const char*src);
strcpy(p,"123456");//无返回值，只能实现字符串拷贝
strlen(p);//在我求出长度

4.const可以修饰成员函数--放在函数参数外面---常成员函数--在此函数中不能修改本类数据成员的值

一般情况下，将get函数，打印函数等这类函数设置为const
   int get()const{}

class A
{
public:
	A(int i = 0, int j = 0) :m_i(i), m_j(j), m_k(0), m_m(0) {}
	void Print()const
	{
		m_i = 10;
		cout << m_i << " " << m_j << " " << m_k << " " << m_m << endl;
	}
	//	int GetI()const //常成员函数,在当前函数中不能修改本类数据成员的值,即是在当前函数中不能修改m_i和m_j
	//	{
	//	    m_i = 10;//error 在此函数中不能修改
	//		return m_i;
	//	}
	int GetJ()const //常成员函数
	{
		return m_j;
	}

private:
	mutable int m_i;//如果变量过多，想要修改个别变量可在前加mutable
	int m_j;
	int m_k;
	int m_m;
};
void main()
{
	A a(4, 7);
	//cout<<a.m_i<<a.m_j<<endl; //error m_i,m_j是private
	//假设只想输出m_i或者m_j中的一个
	//cout<<"a.m_i = "<<a.GetI()<<endl;
	a.Print();
}

int GetI()const //常成员函数,在当前函数中不能修改本类数据成员的值,即是在当前函数中不能修改m_i
{
        m_i = 10;//error 在此函数中不能修改
        return m_i;

 }

5.const可以修饰函数返回值---返回值为引用才有意义

class A
{
public:
	A() {}
	void fn()const
	{
		cout << "fn const" << endl;
	}
	void fn()
	{
		cout << "fn" << endl;
	}
};
void main()
{
	const A a;
	A b;
	a.fn();
	b.fn();
}

6.假设只想输出m_i或者m_j中的一个

class A
{
public:
	A(int i = 0, int j = 0) :m_i(i), m_j(j) {}
	void Print()const
	{
		cout << m_i << " " << m_j << endl;
	}
	int GetI()
	{

		return m_i;
	}
	int GetJ() 
	{
		return m_j;
	}

private:
	int m_i;
	int m_j;

};
void main()
{
	A a(4, 7);
	//cout<<a.m_i<<a.m_j<<endl; //error m_i,m_j是private
	//cout<<"a.m_i = "<<a.GetI()<<endl;
	a.Print();
	cout << "m_i "<<a.GetI() << endl;
	cout << "m_j "<<a.GetJ() << endl;
}

7.思考--想在主函数中修改m_i的值 

class A
{
public:
	A(int i = 0) :m_i(i) {}
	void Print()
	{
		cout << "m_i = " << m_i << endl;
	}
    //以下分类讨论
    int GetI()
	{
		return m_i;
	}
	int& GetI_1()
	{
		return m_i;
	}
	const int& GetI_2()
	{
		return m_i;
	}
private:
	int m_i;
};

void main()
{
	A a(6);
	a.Print();
	//a.m_i = 7;//error//只能作为右值
	//a.GetI() = 7;
	cout << "修改后" << endl;
	a.GetI_1() = 7;
	a.Print();
	cout << "m_i:"<<a.GetI_2() << endl;
}

//error只能作为左值不能修改

	int GetI()//只能作为右值
	{
		return m_i;
	}
	

//ok//返回的是m_i本身，通过a.GetI_1() = 7;改变

int& GetI_1()  //返回的是m_i本身
{		
    return m_i;
}
	

//error//返回本身，不能修改

const int& GetI_2()//（返回本身的情况下又不能修改）
{
    return m_i;
}