C++核心编程-4、类和对象1

4、类和对象

4.1封装

4.1.1 封装的意义

#include<iostream>
using namespace std;
//设计一个圆类，求圆的周长
const double PI = 3.14;
//class为设计一个类，后面为名称
class Circle
{
	//公共权限
public:
	//属性
	//半径
	int r;
	//行为
	//获取圆的周长
	double calculate()
	{
		return 2 * PI * r;
	}
};
int main() {

//通过圆类创建一个具体对象
	Circle c1;
	c1.r = 10;
	cout << "圆的周长为" << c1.calculate() << endl;
	system("pause");
	return 0;
}

分析：类中包含属性和行为，属性为变量r,行为为函数calculate。

而对象是通过类创建的实例化对象，具体化出一个对象。

4.1.2 实例-学生类

两种给对象赋值方法：一种使用对象的属性作为左值直接赋值，一种是使用函数进行赋值。 s_name = name;赋值函数的参数为name。具体对象.(可以是属性、函数)

#include<iostream>
using namespace std;
class Students
{
public:
	//类中的属性和行为，称为类的成员。属性称为成员属性或者成员变量，行为称为成员函数或者成员方法
	string s_name;
	int s_ID;
	void showstudent()
	{
		cout << "学生姓名为：" << s_name << "学生的ID号：" << s_ID << endl;
	}
	void setname(string name)//赋值函数
	{
		s_name = name;
	}
	void setID(int ID)
	{
		s_ID = ID;
	}
};
int main() {
	//创建具体学生
	Students s1;
	Students s2;
	//给s1进行属性的赋值操作
	s1.s_name = "张三";
	s1.s_ID = 1234567;
	s2.setname("李四");   //使用函数为实例对象赋值，即行为赋值
	s2.setID(999);
	//显示学生信息
	s1.showstudent();
	s2.showstudent();
	system("pause");
	return 0;
}

4.1.3 封装的意义2

可以看到不可以访问车和密码的成员变量。 

#include<iostream>
using namespace std;
#include<string>
//封装的访问权限
//public      成员 类内可以访问，类外也可以访问
//protected   成员 类内可以访问，类外不可以访问
//private     成员 类内可以访问，类外不可以访问(区别在继承就可以发现)

class person
{
public:
	string m_name;
protected:
	string m_car;
private:
	int m_password;
public:
	void func()
	{
		m_name = "张三";
		m_car = "拖拉机";
		m_password = 123456;
	}
};
int main() {
	person p1;
	p1.m_name = "李四";
	p1.func();
	system("pause");
	return 0;
}

4.1.4 stuct和class的区别

4.1.5成员属性设置为私有

#include<iostream>
using namespace std;
#include<string>
//成员属性设置为私有
//1、可以自己控制读写权限
//2、写权限可以检测有效性
//人类
class person
{
private:
	string m_name;  //权限可读可写
	int m_age=18;  //权限只读
	int m_ID;    //权限只写
public:
	//设置姓名
	void setname(string name)
	{
		m_name = name;
	}
	//获得姓名
	string getname()
	{
		return m_name;
	}
	//获得年龄
	int getage()
	{
		return m_age;
	}
	//设置ID
	void setID(int ID)
	{
		m_ID = ID;
	}
};
int main() {
	person p1;
	p1.setname("张三");
	cout << p1.getname() << endl;
	cout << p1.getage() << endl;
	p1.setID(123456);
	cout << p1.getID << endl;//只写状态外界访问不到
	system("pause");
	return 0;
}

 4.1.6案例1：设计立方体类

#include<iostream>
using namespace std;
#include<string>
//立方体类
class cube
{
public:
	void setL(int l)  //写入长
	{
		c_l = l;
	}
	int getL()  //获取长
	{
		return c_l;
	}
	void setW(int w)  //写入宽
	{
		c_w = w;
	}
	int getW()  //获取宽
	{
		return c_w;
	}
	void setH(int h)  //写入高
	{
		c_h = h;
	}
	int getH()  //获取高
	{
		return c_h;
	}
	int calcuateS()
	{
		return 2 * c_h * c_l + 2 * c_h * c_w + 2 * c_l * c_w;
	}
	int calcuateV()
	{
		return c_h * c_l * c_w;
	}
private:
	int c_l;
	int c_w;
	int c_h;

};
int main() {
	cube c1;
	c1.setH(10);
	c1.setL(10);
	c1.setW(10);
	cout<<c1.calcuateS()<<endl;
	cout<<c1.calcuateV()<<endl;
	system("pause");
	return 0;
}

#include<iostream>
using namespace std;
#include<string>
//立方体类
class cube
{
public:
	void setL(int l)  //写入长
	{
		c_l = l;
	}
	int getL()  //获取长
	{
		return c_l;
	}
	void setW(int w)  //写入宽
	{
		c_w = w;
	}
	int getW()  //获取宽
	{
		return c_w;
	}
	void setH(int h)  //写入高
	{
		c_h = h;
	}
	int getH()  //获取高
	{
		return c_h;
	}
	int calcuateS()
	{
		return 2 * c_h * c_l + 2 * c_h * c_w + 2 * c_l * c_w;
	}
	int calcuateV()
	{
		return c_h * c_l * c_w;
	}

	//利用成员函数判断两个立方体是否相等
	bool isSameBYclass(cube &c)
	{
		if (c_l == c.getL() && c_w == c.getW() && c_h == c.getH())
		{
			return true;
		}
		return false;
	}
private:
	int c_l;
	int c_w;
	int c_h;

};

//利用全局函数判断，两个立方体是否相等
bool isSame(cube& c1, cube& c2)  //&在这是引用，不加进行的是值传递，值传递会拷贝出一份数据
{
	if (c1.getL() == c2.getL() && c1.getW() == c2.getW() && c1.getH() == c2.getH())
	{
		return true;
	}
	return false;
}

int main() {
	cube c1;
	c1.setH(10);
	c1.setL(10);
	c1.setW(10);
	cout<<c1.calcuateS()<<endl;
	cout<<c1.calcuateV()<<endl;
	//创建第二个立方体
	cube c2;
	c2.setL(10);
	c2.setH(10);
	c2.setW(10);
	//全局判断
	bool ret = isSame(c1, c2);
	if (ret)
	{
		cout << "c1和c2是相等的" << endl;
	}
	else
	{
		cout << "c1和c2是不相等的" << endl;
	}

	//成员函数判断
	ret = c1.isSameBYclass(c2);
	if (ret)
	{
		cout << "c1和c2是相等的" << endl;
	}
	else
	{
		cout << "c1和c2是不相等的" << endl;
	}
	system("pause");
	return 0;
}

4.2对象的初始化和清理

 4.2.1构造函数和析构函数

 

#include<iostream>
using namespace std;
#include<string>
//对象的初始化和清理
//1、构造函数 进行初始化操作
class Person
{
public:
	//1.1、构造函数
	//没有返回值  不用写void
	//函数名 与类名相同
	//构造函数可以有参数，可以发生重载
	//创建对象的时候，构造函数会自动找回，而且只调用一次
	Person()   //函数名与类名相同，都是Person并且没有返回值也没有写void
	{
		cout << "Person构造函数的调用" << endl;
	}
	//2、析构函数 进行清理的操作
	//没有返回值 不写void
	//函数名与类名相同，在名称前加`
	//析构函数不可以有参数的，不可以发生重载
	//对象在销毁前 会自动调用析构函数，而且只会调用一次
	~Person()
	{
		cout << "Person析构函数的调用" << endl;
	}

};

void test01()
{
	Person p;  //在栈上的数据，test01执行完毕后，释放这个对象
}
int main() {
	
	test01();
	system("pause");
	return 0;
}

此时把函数不执行test01函数，只执行Person p，会发生什么呢？

析造函数没有运行，为什么？

其实代码运行了只是在main函数执行return0之后。点击任意键会出现一秒。

4.2.2构造函数的分类和调用

#include<iostream>
using namespace std;
#include<string>
//1构造函数的分类和调用
//分类
//按照参数，有参构造和无参构造（默认构造）
//按照类型分类  普通构造、拷贝构造函数
class Person
{
public:
	//构造函数
	Person()
	{
		cout << "Person的无参构造函数调用" << endl;
	}
	Person(int a)
	{
		age = a;
		cout << "Person的有参构造函数调用" << endl;
	}
	//拷贝构造函数
	Person(const Person& p)
	{
		//将传入的人身上的所有属性，拷贝到我身上
		age = p.age;
		cout << "Person拷贝函数调用" << endl;
	}
	int age;
};

//调用
void test01()
{
	//1、括号法
	//Person p1;  //默认构造函数调用
	//Person p2(10);  //有参函数调用
	//Person p3(p2);  //有参函数调用
	///*cout << "p2的年龄" << p2.age << endl;
	//cout << "p3的年龄" << p3.age << endl;*/
	//Person p1();  //这个不打印东西，为什么？
	编译器会认为是函数的声明  void func();函数的声明不会认为在创建对象
	//2、显示法
	Person p1;
	Person p2= Person(10);  //有参调用
	//拷贝构造
	Person p3 = Person(p2);
	//3、隐式转换法
	Person p4 = 10;  //相当于写了Person p4=Person(10);
	Person P5 = p4;  //拷贝构造
}
int main() {

	test01();
	system("pause");
	return 0;
}

4.2.3 拷贝函数调用时机

#include<iostream>
using namespace std;
#include<string>
//拷贝构造函数调用时机
//1、使用一个已经创建方式的对象来初始化一个新对象


//2、值传递的方式给函数参数传值


//3、值返回局部对象
class Person
{
public:
	Person()
	{
		cout << "Person默认构造函数调用"<<endl;
	}
	Person(int age)
	{
		cout << "Person有参函数调用" << endl;
		m_age = age;
	}
	Person(const Person& p)
	{
		cout << "Person拷贝函数调用" << endl;
		m_age = p.m_age;
	}
	~Person()
	{
		cout << "Person析构函数调用" << endl;
	}
	int m_age;
};
//1、使用一个已经创建完毕的对象来初始化一个新对象
void test01()
{
	Person p1(20);
	Person p2(p1);
	cout << "P2的年龄为：" << p2.m_age << endl; //p2的年龄为20，表示P1的年龄成功被拷贝
}
//2、值传递的方式给函数参数传值
void doWork(Person p)
{

}
void test02()
{
	Person p;
	doWork(p);
}
//3、值方式返回局部变量
Person doWork2()
{
	Person p1;
	return p1;
}
void test03()
{
	Person p=doWork2();
}
int main() {

	//test01();
	//test02();
	test03();
	system("pause");
	return 0;
}

4.2.4构造函数调用规则

#include<iostream>
using namespace std;
//构造函数的定义规则
//1、只要创建一个类，编译器会给每个类至少添加三个函数
//默认构造函数（空实现）、默认析构函数（空实现）、拷贝构造（值拷贝）

//如果我们写了有参构造函数，编译器就不再提供默认构造函数，依然提供拷贝构造
//如果我们写了拷贝构造函数那么编译器不再提供其他普通构造函数
class Person
{
public:
	Person(int age)
	{
		m_age = age;
		cout << "Person有参构造函数的调用" << endl;
	}
	
	~Person()
	{
		cout << "Person析构函数的调用" << endl;
	}
	int m_age;
};
void test02()
{
	Person p(18);
	Person p2(p);
	cout << "p2的年龄为：" << p2.m_age << endl;
}
int main() {
	/*test01();*/
	test02();
	system("pause");
	return 0;
}

#include<iostream>
using namespace std;
//构造函数的定义规则
//1、只要创建一个类，编译器会给每个类至少添加三个函数
//默认构造函数（空实现）、默认析构函数（空实现）、拷贝构造（值拷贝）

//如果我们写了有参构造函数，编译器就不再提供默认构造函数，依然提供拷贝构造
//如果我们写了拷贝构造函数那么编译器不再提供其他普通构造函数
class Person
{
public:
	/*Person()
	{
		cout << "Person默认构造函数的调用" << endl;
	}*/
	/*Person(int age)
	{
		m_age = age;
		cout << "Person有参构造函数的调用" << endl;
	}*/
	Person(const Person& p)
	{
		m_age = p.m_age;
		cout << "person拷贝构造函数的调用" << endl;
	}
	~Person()
	{
		cout << "Person析构函数的调用" << endl;
	}
	int m_age;
};
//void test01()
//{
//	Person p;
//	p.m_age = 20;
//
//	Person p2(p);
//	cout <<"p2的年龄为：" << p2.m_age << endl;
//}
void test02()
{
	Person p;
}
int main() {
	/*test01();*/
	test02();
	system("pause");
	return 0;
}

4.2.5深拷贝与浅拷贝

浅拷贝是由编译器提供的简单的赋值操作。

#include<iostream>
using namespace std;
class Person
	{
	public:
		Person()
		{
			cout << "person默认构造函数的调用" << endl;
		}
		Person(int age,int height)
		{
			m_age = age;
			m_height=new int (height);
			cout << "person有参构造函数的调用" << endl;
		}
		~Person()
		{
			//析构函数，将堆区开辟的数据进行释放操作
			if (m_height != NULL)
			{
				delete m_height;
				m_height = NULL;
			}
			cout << "Person析构函数的调用" << endl;
		}
		int m_age;
		int *m_height;  //因为要把身高的内存空间开放到堆区，因此使用指针
	};
	void test01()
	{
		Person p1(18,175);
		cout << "p1的年龄为：" << p1.m_age << endl;
		cout << "p1的身高为：" << *p1.m_height << endl;
		Person p2(p1);
		cout <<"p2的年龄为：" << p2.m_age << endl;
		cout << "p2的身高为：" << *p2.m_height << endl;
	}
int main() {

	test01();
	system("pause");
	return 0;
}

此时代码运行崩溃 。

原因在于浅拷贝是简单的赋值操作。执行p2析构函数的时候，将内存已经释放了一次，再执行p1析函数的时候又要再释放一次，操作非法。因此需要使用深拷贝解决。深拷贝自己再写一块内存空间存储。

#include<iostream>
using namespace std;
class Person
	{
	public:
		Person()
		{
			cout << "person默认构造函数的调用" << endl;
		}
		Person(int age,int height)
		{
			m_age = age;
			m_height=new int (height);
			cout << "person有参构造函数的调用" << endl;
		}
		//自己实现拷贝构造函数，解决浅拷贝带来的问题
		Person(const Person &p)
		{
			cout << "person拷贝构造函数的调用" << endl;
			m_age = p.m_age;
			//m_height = p.m_height;  //这行代码就是编辑器浅拷贝出问题的关键，导致同一段内存被重复释放。
			//深拷贝操作
			m_height = new int(*p.m_height);
		}
		~Person()
		{
			//析构函数，将堆区开辟的数据进行释放操作
			if (m_height != NULL)
			{
				delete m_height;
				m_height = NULL;
			}
			cout << "Person析构函数的调用" << endl;
		}
		int m_age;
		int *m_height;  //因为要把身高的内存空间开放到堆区，因此使用指针
	};
	void test01()
	{
		Person p1(18,175);
		cout << "p1的年龄为：" << p1.m_age << endl;
		cout << "p1的身高为：" << *p1.m_height << endl;
		Person p2(p1);
		cout <<"p2的年龄为：" << p2.m_age << endl;
		cout << "p2的身高为：" << *p2.m_height << endl;
	}
int main() {

	test01();
	system("pause");
	return 0;
}

 析构代码的用途：通常情况下不写也没有关系，但是当在堆区申请空间后，就要使用析构函数进行释放。

4.2.6初始化列表

#include<iostream>
using namespace std;
#include<string>

//初始化列表
class Person
{
public:
	传统初始化操作
	//Person(int a, int b, int c)
	//{
	//	m_A = a;
	//	m_B = b;
	//	m_C = c;
	//}
	//初始化列表初始化属性
	Person() :m_A(10), m_B(20), m_C(30)
	{

	}
	int m_A;
	int m_B;
	int m_C;
};
void test01()
{
	//Person p(10, 20, 30);
	Person p;
	cout << "m_A:" << p.m_A << endl;
	cout << "m_B:" << p.m_B << endl;
	cout << "m_C:" << p.m_C << endl;
}
int main() {

	test01();
	system("pause");
	return 0;
}

但是这种10,20,30已经写死了，不能更改。

#include<iostream>
using namespace std;
#include<string>

//初始化列表
class Person
{
public:
	传统初始化操作
	//Person(int a, int b, int c)
	//{
	//	m_A = a;
	//	m_B = b;
	//	m_C = c;
	//}
	//初始化列表初始化属性
	Person(int a,int b,int c) :m_A(a), m_B(b), m_C(c)
	{

	}
	int m_A;
	int m_B;
	int m_C;
};
void test01()
{
	//Person p(10, 20, 30);
	Person p(30,20,10);
	cout << "m_A:" << p.m_A << endl;
	cout << "m_B:" << p.m_B << endl;
	cout << "m_C:" << p.m_C << endl;
}
int main() {

	test01();
	system("pause");
	return 0;
}

4.2.7类对象作为类成员

#include<iostream>
using namespace std;
#include<string>
class Phone
{
public:
	Phone(string pname)
	{
		cout << "Phone的构造函数调用" << endl;
		m_pname = pname;
	}
	string m_pname;
};
//类对象作为类成员
class Person
{
public:
	Person(string name, string pname):m_name(name),m_phone(pname)
	{
		cout << "Person的构造函数调用" << endl;
	}
	//姓名
	string m_name;
	//手机
	Phone m_phone;
};
void test01()
{
	Person p("范淞","华为");
	cout << p.m_name << "拿着" << p.m_phone.m_pname << endl;
}
int main() {

	test01();
	system("pause");
	return 0;
}

而析构是相反的。 

4.2.8静态成员

 

 此时运行错误，类内声明，类外初始化是必须进行的操作。

进行类外初始化以后成功运行并打印结果。

示例代码：

#include<iostream>
using namespace std;
#include<string>
//1、所有对象都共享同一份数据
//2、编译阶段就分配内存
//3、类内声明，类外初始化
//静态成员变量
class Person
{
public:
	static int m_A;  //类内声明
	
};
int Person::m_A=100;  //类外初始化
void test01()
{
	Person p;
	cout << p.m_A << endl;
	Person p2;
	p2.m_A = 200;
	cout << p2.m_A << endl;
	cout << p.m_A << endl;
}
int main() {

	test01();
	system("pause");
	return 0;
}

 静态成员变量也有访问权限，在私有权限下面类外不可以访问。

 

 静态成员函数也有访问权限。

4.3C++对象模型和this指针

4.3.1成员变量和成员函数分开存储

 C++编译器会给空对象分配一个内存空间，是为了区分每个对象占内存的位置。

给类定义一个属性，对象所占的内存变为4个字节。 

再添加一个静态成员变量 ，对象所占内存还是4，因为静态成员变量不属于类的对象。

 

添加非静态成员函数，所占内存还是4。非静态成员函数也是不属于类的对象上的。

 添加静态成员函数，所占内存还是4。静态成员函数也是不属于类的对象上的。

4.3.2this指针的概念

结果：

使用this指针：this指针指向被调用成员函数的对象

 谁调用成员函数的p因此this指向p.

结果：

 示例代码如下：

#include<iostream>
using namespace std;
#include<string>

//1、解决名称冲突
//2、返回对象用*this

class Person
{
public:
	Person(int age)  //函数传入的形参
	{
		this->age = age;  //this指针指向被调用成员的对象
	}
	int age; //成员属性
};

void test01()
{
	Person p(18);
	cout << "p的年龄为：" << p.age << endl;
}

int main() {

	test01();
	system("pause");
	return 0;
}

 示例代码如下：

#include<iostream>
using namespace std;
#include<string>

class Person
{
public:
	Person(int age)  //函数传入的形参
	{
		this->age = age;  //this指针指向被调用成员的对象
	}
	Person Personaddage(Person& p)
	{
		this->age += p.age;
		//this指向p2的指针，而*this指向的就是p2这个对象本体
		return *this;
	}
	int age; //成员属性
};
//1、解决名称冲突
void test01()
{
	Person p(18);
	cout << "p的年龄为：" << p.age << endl;
}
//2、返回对象用*this
void test02()
{
	Person p1(20);
	Person p2(18);
	p2.Personaddage(p1).Personaddage(p1).Personaddage(p1);  //链式编程思想和cout思想一致
	cout << "p2的年龄为：" << p2.age << endl;
}
int main() {
	//test01();
	test02();
	system("pause");
	return 0;
}

4.3.3空指针访问成员函数

#include<iostream>
using namespace std;
#include<string>
//空指针访问成员函数
class Person
{
public:
	void showClassName()
	{
		cout << "this is Person class" << endl;
	}
	void showPersonAge()
	{
		if (this == NULL)  //加上这行代码防止下面这个问题，提升代码健壮性。
		{
			return;
		}
		cout << "age=" << m_Age << endl; 
		//这个m_Age,默认的是this指针。this->m_Age。调用函数的成员是p为空指针，因此调用这个函数会报错
	}
	int m_Age;

};
void test01()
{
	Person * p = NULL;
	p->showClassName();
	p->showPersonAge();
}

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

 4.3.4 const修饰成员函数

示例代码如下： 

#include<iostream>
using namespace std;
#include<string>
//const修饰成员函数
//常函数
class Person
{
public:
	void showPerson() const  //在成员函数后面加上const相当于一个常量指针，指向的值不可以修改，指针的指向可以修改
	{
		//m_Age = 100;  //函数内属性本身是this->m_Age，this本质是一个指针常量，指向的值可以修改，指针的指向不可以修改
		m_b = 10;
	}
	void func()
	{

	}
	int m_Age;
	mutable int m_b;  //特殊变量，即使在常函数中，也可以修改这个值
};

//常对象
void test02()
{
	const Person p;  //在对象前加const，常对象
	p.m_Age = 10;
	p.m_b = 10;
	//常对象只能调用常函数
	p.showPerson();
	p.func();
}
int main() {
	system("pause");
	return 0;
}