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:设计立方体类![](https://img-blog.csdnimg.cn/direct/a78def0a823947af8f6feae5e5a67837.png)
#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;
}