C++知识点11——this指针，const成员函数，访问权限控制

1.this指针

每个类都有this指针，this指针指向this指针指向的是类的对象本身

class A
{
public:
	A() {}
	~A() {}
	void func() {cout<<this<<endl;}
};

int main(int argc, char const *argv[])
{
	A t1,t2;
	cout<<&t1<<endl;
	t1.func();
	cout<<&t2<<endl;
	t2.func();
	return 0;
}

通过上述结果可知，this指针的值和类各自的对象的地址值相等。

当类的不同对象调用相同的成员函数时，会将this指针隐式传入成员函数，从而可以根据this指针来操作相同的成员变量

void A::func2(int para)
{
	a=para;
	cout<<this->a<<endl;
}

int main(int argc, char const *argv[])
{
	A t1,t2;
	t1.func2(10);
	t2.func2(20);
	return 0;
}

t1和t2在第九行执行初始化时，自动调用了构造函数，将this指针初始化为t1和t2的地址，在调用成员函数func2时，隐式地用自身的地址初始化this指针，同样是打印this->a，实际上是打印t1.a和t2.a

所以通过this指针可以对同一个类的不同对象进行区分，防止类的不同对象的同名变量混淆

此外，在对象调用成员函数时，由编译器自动隐式初始化this指针，所以不能显示初始化this指针，而且，this指针一旦初始化完成，就会一直指向这个类的对象，所以this指针是个const指针

2.const成员函数

const成员函数就是在类的成员函数的形参列表后面加上const关键字，作用是将this指针指向的对象置为const，所以，调用成员函数时，不能在const成员函数中修改类的对象。因为是修饰this，而普通函数和static成员函数没有this，所以不能在static成员函数和普通函数后面加const修饰

举例

class A
{
public:
	A() {}
	~A() {}
	A constfunc() const;

private:
	int a;
};

A A::constfunc() const 
{
	cout<<__func__<<endl;
 //a=10;
	return *this;
}

int main(int argc, char const *argv[])
{
	A t1;
	A t2= t1.constfunc();
	return 0;
}

上述代码中，类A的对象t2接收t1的拷贝，因为返回了*this，如果想接收t1本身，那么可以将函数的返回值定义为类A的引用

如果将代码15行解除注释，就会产生如下错误

显示成员变量a是只读的，如果将const修饰符去掉，则也能顺利编译通过

所以当有const修饰成员函数时，就不能在成员函数中对类的对象进行修改，

因为有const修饰成员函数时，this指针指向的对象是const的，而成员变量变化时，表示类的对象变化，所以报错

但是并不是所有的成员变量都不能在const成员函数中改变，如果一个成员变量用mutable来修饰，那么该成员变量就可以在const成员函数中被修改

class A
{
public:
	A() {}
	~A() {}
	A constfunc() const;

private:
	mutable int m;
};

A A::constfunc() const 
{
	cout<<__func__<<endl;
	m=10;
	cout<<m<<endl;
	return *this;
}

int main(int argc, char const *argv[])
{
	A a;
	a.constfunc();
	return 0;
}

可见，编译成功并且打印出m的值

此外，类的const对象和类的const对象的引用和指针只能调用const成员函数

举例

class A
{
public:
	A() {}
	~A() {}
	void func2(int para);
	A constfunc() const;

private:
	int a;
};

void A::func2(int para)
{
	//a=para;
	cout<<this->a<<endl;
}

A A::constfunc() const 
{
	cout<<__func__<<endl;
	return *this;
}

int main(int argc, char const *argv[])
{
	const A a;
	a.func2(10);
	return 0;
}

因为a是const对象，而非const成员函数有可能改变对象a中某些成员变量，所以报错，const对象的指针和引用也是一样，因为const对象的指针和引用不能改变所绑定和指向的对象

3.访问权限控制

上面代码在类的定义的过程中都出现了public和private，public访问控制符表示该访问控制符下面的成员在整个程序中是可访问的，而private访问控制符表示该访问符下面的成员只能在类中的成员函数中才能被访问

class A
{
public:
	A() {}
	~A() {}

private:
	int a;
};

int main(int argc, char const *argv[])
{
	A a;
	cout<<a.a<<endl;
	return 0;
}

因为a是私有的，main函数没有访问权，所以不能在main函数中使用，报错

但是可以定义一个public的成员函数，在main函数中修改a的值并打印a

class A
{
public:
	A() {}
	~A() {}
	void seta(int i);

private:
	int a;
};

void A::seta(int i)
{
	a=i;
	cout<<a<<endl;
}

int main(int argc, char const *argv[])
{
	A a;
	a.seta(10);
	return 0;
}