滴水三期：day44.1-private和class权限控制.

EdimadeZhou

墨衍会员 · AI 创作全网分发码龄5年

关注

原创 2023-04-28 19:37:25 726 阅读 AI 写同款· GEO 优化 ›

C++之类（class）的三种成员修饰符（public、private、protected）总结主要介绍类中修饰词public、private、protected控制成员访问权限阅读详情

一、方法定义和实现分开

将声明与实现分离，代码会有更好的可读性，不是必须的
选择项目Class View，右键新建Class；在xxx.h头文件中定义类，且只声明成员方法：
```
struct Person{
	int x;
	void setx(int x);
	int getx();
};
```
，在xxx.cpp中实现方法：（但是要告诉编译器，这不是一个普通的函数，而是Person类中的成员方法）
```
void Person::setx(int x){
	this->x = x;
}
int Person::getx(){
	return this->x;
}
```

最后在要使用Person类中成员的cpp中include xxx.h引用头文件，就可以使用xxx.h中类创建对象，使用其属性和方法

#include "stdafx.h"
#include "MyClass.h"
int main(int argc, char* argv[]){		
	Person p;
	p.setx(1);
	printf("%d\n",p.getx());
	return 0;	
}

特别说明：
- xxx.h只是一个文件，头文件可以是任何的后缀名，不一定是.h，比如可以叫xxx.exe
- #include 的作用只是把里面的内容复制过来，仅此而已
- xxx.h 与 xxx.cpp并不要求一定同名

二、public和private

1.public权限说明

public权限：这个成员（属性、方法等）哪里都可以用，所以对外提供的函数或者变量，发布成public的
public/private可以修饰函数也可以修饰变量
注意：目前阶段，类的构造器只能设置成public。后面学习设计模式时定义成private也有办法使用。

2.private权限说明

private权限：这个成员只用于类内部使用，即只有结构体内部的函数才可以访问private的成员，不能在其他的地方使用，所以不对外公布的，发布成private

一般来说类的成员变量不能让别人轻易改动，如果要改动，也必须要对修改的值进行判断检验是否合法，所以一般都会对外发布可以修改或打印私有成员变量的方法，在方法中检验修改是否合法：

#include "stdafx.h"	
struct Person{
private:   //私有成员变量
	int age;
public:  //共有成员方法
	void SetAge(int age){
		if(age > 0 && age <= 100){
			this->age = age;  //private成员变量只有类中的其他成员可以访问
		}
	}
	int GetAge(){
		return age;
	}
};
int main(int argc, char* argv[]){		
	Person p;
    //不能p.age = 18;
	p.SetAge(18);
	printf("%d\n",p.GetAge());
	return 0;	
}

1）private成员分配空间

当创建一个类的对象时，不管是公有变量还是私有变量，编译器分配空间时都一视同仁，还是会分配空间，只不过我们要使用私有变量时，编译器是不允许的
```
#include "stdafx.h"	
struct Person{
private:
	int x;
	int y;
public:
	int z;
	void Init(int x,int y,int z){
		this->x = x;
		this->y = y;
		this->z = z;
	}
};
int main(int argc, char* argv[]){		
	Person p;
	p.Init(1,2,3);
    printf("%d\n",sizeof(p));  //12,从这里也可以发现，不管私有还是公有成员变量，都会为其分配空间
	return 0;	
}
```
查看反汇编发现：创建p对象后，最后一个参数就是对象的首地址，所以ebp-0xC也是成员x的地址，存到ecx寄存器中；接着进入到函数内部，ecx中就是x的地址（即对象首地址），然后把x的地址值存入到ebp-4，接着又把地址值存入到eax，所以mov dword ptr [eax],ecx就是在给成员x赋值；接着又把x的地址值存入到edx，所以[edx+4]中存的就是y；后面以此类推。还可以通过栈窗口发现，x,y,z成员就是挨着存的，看不出来哪一个是private哪一个是public

2）private成员变量其实可以访问

前面讲过，不管是private成员变量还是public成员变量，在内存中都是一视同仁，就存储在对象的内存空间中，所以可以用指针访问即可

#include "stdafx.h"	
struct Person{
private:
	int x;
	int y;
public:
	int z;
	void Init(int x,int y,int z){
		this->x = x;
		this->y = y;
		this->z = z;
	}
};
int main(int argc, char* argv[]){		
	Person p;
	p.Init(1,2,3);
    
	int* pp = (int*)&p;  //定义一个int*指针，访问x，y，z的值即可
	printf("%d %d %d\n",*pp,*(pp + 1),*(pp + 2));  //1 2 3
	return 0;	
}

所以再次印证了：private修饰的成员与普通的成员没有区别只是编译器会检测

三、class和struct区别

编译器默认class中的成员为private，而struct中的成员为public

继承中的区别：

如果一个子类继承一个父类时，没有声明以什么方式继承，默认以private的方式继承，即继承（复制）过来的成员都是私有的！

#include "stdafx.h"	
class Person{
private:
	int x;
	int y;
public:
	int z;
	void Init(int x,int y,int z){
		this->x = x;
		this->y = y;
		this->z = z;
	}
};
class Student:Person{  //由于这里没有声明以什么方式继承，默认以private方式继承
private:
	int m;
public:
	void changeZ(){
		//z = 10;   //因为以private方式继承，即使父类中的z是public，但是继承来后就变成private
		//x = 1;    //x本来就是私有的，当然使用不了
	}
};
int main(int argc, char* argv[]){		
	
	return 0;	
}

如果子类中想使用父类中的public的变量或方法，就需要声明以public的方式继承

class Student:public Person{  //以public方式继承
private:
	int m;
public:
	void changeZ(){
		z = 10;   //因为以public方式继承，所以可以使用父类中public的成员
		//x = 1;    //x本来就是私有的，当然使用不了
	}
};

但是注意：父类中的私有成员是会被继承的，即还是会为私有成员变量分配空间，只是子类中无法使用父类的私有成员变量（所以说嘛，子类对象想访问父类中的私有成员变量，也是有办法的，和上面一样）

#include "stdafx.h"	
class Person{
private:
	int x;
	int y;
public:
	int z;
	Person(){
		this->x = 1;
		this->y = 2;
		this->z = 3;
	}
};

class Student:public Person{
private:
	int m;
public:
	void changeZ(){
		m = 4;
	}
};
int main(int argc, char* argv[]){		
	Student stu;  //创建子类对象时，是会先调用父类的构造器的！所以x,y,z才会被赋值1,2,3
	stu.changeZ();

	int* stup = (int*)&stu;
    printf("%d\n",sizeof(stu)); //16,说明父类中无论私有公有的成员变量都被继承过来了
	printf("%d %d %d %d\n",*(stup),*(stup + 1),*(stup + 2),*(stup + 3)); //1 2 3 4
	return 0;	
}

四、作业

1.class和private练习

将上一节课的所有练习改为class实现，并添加private/public进行权限控制，而且将类的定义与实现分开来写：定义写到xxx.h中，函数实现写在xxx.cpp中

在MyClass.h中声明DataInfo类，TimeInfo类：

#if !defined(AFX_MYCLASS_H__44CA5D47_B224_42F2_A26E_CAD8CD157CD1__INCLUDED_)
#define AFX_MYCLASS_H__44CA5D47_B224_42F2_A26E_CAD8CD157CD1__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
class DataInfo{
private:
    int year;
	int month;
	int day;
public:
	DataInfo(int year,int month,int day){
		this->year = year;
		this->month = month;
		this->day = day;
	}
	DataInfo(){
		year = 2015;
		month = 4;
		day = 2;
	}
                                  
	void SetDay(int day);
	int GetDay();
	void SetYear(int year);
	int GetYear();
	void SetMonth(int month);
	int GetMonth();
};
class TimeInfo:public DataInfo{
private:
	int hour;
	int minute;
	int second;
public:
	void SetHour(int hour);
	void SetMinute(int minute);
	void SetSecond(int second);
	int GetHour();
	int GetMinute();
	int GetSecond();
};
#endif // !defined(AFX_MYCLASS_H__44CA5D47_B224_42F2_A26E_CAD8CD157CD1__INCLUDED_)

在MyClass.cpp中实现方法：

#include "stdafx.h"
#include "MyClass.h"
void DataInfo::SetDay(int day){
	this->day = day;
}
int DataInfo::GetDay(){
	return day;
}
void DataInfo::SetYear(int year){
	this->year = year;
}
int DataInfo::GetYear(){
	return year;
}
void DataInfo::SetMonth(int month){
	this->month = month;
}
int DataInfo::GetMonth(){
	return month;
}

void TimeInfo::SetHour(int hour){
	this->hour = hour;
}
void TimeInfo::SetMinute(int minute){
	this->minute = minute;
}
void TimeInfo::SetSecond(int second){
	this->second = second;
}
int TimeInfo::GetHour(){
	return hour;
}
int TimeInfo::GetMinute(){
	return minute;
}
int TimeInfo::GetSecond(){
	return second;
}

最后在要使用的cpp中包含MyClass头文件，创建对象并使用成员方法打印日期：

#include "stdafx.h"
#include "MyClass.h"
void Test(){
	//访问TimeInfo对象的成员
	TimeInfo t;
	t.SetHour(21);
	t.SetMinute(8);
	t.SetSecond(52);	
	printf("%04d.%02d.%02d - %02d:%02d:%02d\n",t.GetYear(),t.GetMonth(),t.GetDay(),t.GetHour(),t.GetMinute(),t.GetSecond());
}
int main(int argc, char* argv[]){		
	Test();
	return 0;	
}