07.类和对象
目录介绍
- 7.1 面向对象思想
- 7.1.1 类的含义
- 7.1.2 struct和class区别
- 7.2 类定义和对象
- 7.2.1 类的定义
- 7.2.2 创建对象
- 7.2.3 访问类成员
- 7.2.4 对象指针
- 7.2.5 案例实践
- 7.3 类成员属性
- 7.3.1 成员变量
- 7.3.2 成员函数
- 7.3.3 访问权限
- 7.3.4 成员设置私有
- 7.3.5 案例实践
- 7.4 对象初始化
- 7.4.1 构造和析构函数
- 7.4.2 构造函数分类
- 7.4.3 拷贝构造函数
- 7.4.4 构造调用规则
- 7.4.5 初始化列表
7.1 面向对象思想
C++面向对象的三大特性为:==封装、继承、多态==
C++认为==万事万物都皆为对象==,对象上有其属性和行为
例如:
- 人可以作为对象,属性有姓名、年龄、身高、体重...,行为有走、跑、跳、吃饭、唱歌...
- 车也可以作为对象,属性有轮胎、方向盘、车灯...,行为有载人、放音乐、放空调...
- 具有相同性质的==对象==,我们可以抽象称为==类==,人属于人类,车属于车类
7.1.1 类的含义
类和对象是 C++ 的重要特性,它们使得 C++ 成为面向对象的编程语言,可以用来开发中大型项目。
类是创建对象的模板,一个类可以创建多个对象,每个对象都是类类型的一个变量;创建对象的过程也叫类的实例化。每个对象都是类的一个具体实例(Instance),拥有类的成员变量和成员函数。
与结构体一样,类只是一种复杂数据类型的声明,不占用内存空间。而对象是类这种数据类型的一个变量,或者说是通过类这种数据类型创建出来的一份实实在在的数据,所以占用内存空间。
7.1.2 struct和class区别
在C++中 struct和class唯一的区别就在于 默认的访问权限不同
- struct 默认权限为公共
- class 默认权限为私有
class C1 {
int a; //默认是私有权限
};
struct C2 {
int a; //默认是公共权限
};
int main() {
C1 c1;
//c1.a = 10; //错误,访问权限是私有
C2 c2;
c2.a = 10; //正确,访问权限是公共
return 0;
}
7.2 类定义和对象
7.2.1 类的定义
类是用户自定义的类型,如果程序中要用到类,必须提前说明,或者使用已存在的类(别人写好的类、标准库中的类等),C++语法本身并不提供现成的类的名称、结构和内容。
在设计类的时候,属性和行为写在一起,表现事物。
语法: class 类名{ 访问权限: 属性 / 行为 };
一个简单的类的定义:
class Student{
public:
//成员变量
char *name;
int age;
float score;
//成员函数
void say(){
cout<<name<<"的年龄是"<<age<<",成绩是"<<score<<endl;
}
};
类只是一个模板(Template),编译后不占用内存空间,所以在定义类时不能对成员变量进行初始化,因为没有地方存储数据。只有在创建对象以后才会给成员变量分配内存,这个时候就可以赋值了。
7.2.2 创建对象
在创建对象时,class 关键字可要可不要,但是出于习惯我们通常会省略掉 class 关键字。除了创建单个对象,还可以创建对象数组:
例如:
void test2_2(){
class Student yc1; //正确
Student yc2; //同样正确
Student yc3[100]; //创建对象数组
}
7.2.3 访问类成员
创建对象以后,可以使用点号.来访问成员变量和成员函数,这和通过结构体变量来访问它的成员类似,如下所示:
class Student{
public:
string name;
int age;
float score;
void say() {
cout << name << "的年龄是" << age << "分数是" << score << endl;
}
};
int main() {
Student stu;
stu.name = "打工充";
stu.age = 30;
stu.score = 100;
stu.say();
return 0;
}
打印结果如下所示:
打工充的年龄是30分数是100
stu 是一个对象,占用内存空间,可以对它的成员变量赋值,也可以读取它的成员变量。
7.2.4 对象指针
C语言中经典的指针在 C++ 中仍然广泛使用,尤其是指向对象的指针,没有它就不能实现某些功能。
创建的对象 stu 在栈上分配内存,需要使用&获取它的地址,例如:
Student stu;
Student *pStu = &stu;
也可以在堆上创建对象,这个时候就需要使用前面讲到的new关键字
Student *pStu = new Student;
在栈上创建出来的对象都有一个名字,比如 stu,使用指针指向它不是必须的。但是通过 new 创建出来的对象就不一样了,它在堆上分配内存,没有名字,只能得到一个指向它的指针,所以必须使用一个指针变量来接收这个指针,否则以后再也无法找到这个对象了,更没有办法使用它。也就是说,使用 new 在堆上创建出来的对象是匿名的,没法直接使用,必须要用一个指针指向它,再借助指针来访问它的成员变量或成员函数。
栈内存是程序自动管理的,不能使用 delete 删除在栈上创建的对象;堆内存由程序员管理,对象使用完毕后可以通过 delete 删除。在实际开发中,new 和 delete 往往成对出现,以保证及时删除不再使用的对象,防止无用内存堆积。
class Student {
public:
string name;
int age;
float score;
void say() {
cout << name << "的年龄是" << age << ",成绩是" << score << endl;
}
};
int main() {
Student *pStu = new Student;
pStu->name = "打工充";
pStu->age = 30;
pStu->score = 92.5f;
pStu->say();
delete pStu; //删除对象
return 0;
}
7.2.5 案例实践
**示例1:**设计一个圆类,求圆的周长
示例代码:
//圆周率
const double PI = 3.14;
//1、封装的意义
//将属性和行为作为一个整体,用来表现生活中的事物
//封装一个圆类,求圆的周长
//class代表设计一个类,后面跟着的是类名
class Circle
{
public: //访问权限 公共的权限
//属性
int m_r;//半径
//行为
//获取到圆的周长
double calculateZC()
{
//2 * pi * r
//获取圆的周长
return 2 * PI * m_r;
}
};
int main() {
//通过圆类,创建圆的对象
// c1就是一个具体的圆
Circle c1;
c1.m_r = 10; //给圆对象的半径 进行赋值操作
//2 * pi * 10 = = 62.8
cout << "圆的周长为: " << c1.calculateZC() << endl;
system("pause");
return 0;
}
**示例2:**设计一个学生类,属性有姓名和学号,可以给姓名和学号赋值,可以显示学生的姓名和学号
示例2代码:
//学生类
class Student {
public:
void setName(string name) {
m_name = name;
}
void setID(int id) {
m_id = id;
}
void showStudent() {
cout << "name:" << m_name << " ID:" << m_id << endl;
}
public:
string m_name;
int m_id;
};
int main() {
Student stu;
stu.setName("德玛西亚");
stu.setID(250);
stu.showStudent();
system("pause");
return 0;
}
7.3 类成员属性
7.3.1 成员变量
7.3.2 成员函数
7.3.3 访问权限
类在设计时,可以把属性和行为放在不同的权限下,加以控制。
访问权限有三种:
- public 公共权限
- protected 保护权限
- private 私有权限
示例:
//三种权限
//公共权限 public 类内可以访问 类外可以访问
//保护权限 protected 类内可以访问 类外不可以访问
//私有权限 private 类内可以访问 类外不可以访问
class Person {
//公共权限
public:
string name;
//保护权限
protected:
string car;
//私有权限
private:
int password;
public:
void func() {
name = "打工充";
car = "雅阁";
password = 123456;
}
};
int main() {
Person p;
p.name = "逗比";
//p.car = "奔驰"; //保护权限类外访问不到
//p.password = 123; //私有权限类外访问不到
return 0;
}
7.3.4 成员设置私有
**优点1:**将所有成员属性设置为私有,可以自己控制读写权限
**优点2:**对于写权限,我们可以检测数据的有效性
示例:
class Person {
private:
string name; //可读可写 姓名
int age; //只读 年龄
string lover; //只写 情人
public:
string getName() {
return name;
}
void setName(string name) {
Person::name = name;
}
int getAge(){
return age;
}
void setAge(int age) {
Person::age = age;
}
void setLover(string lover) {
this->lover = lover;
}
};
int main() {
Person p;
//姓名设置
p.setName("张三");
cout << "姓名: " << p.getName() << endl;
//年龄设置
p.setAge(50);
cout << "年龄: " << p.getAge() << endl;
//情人设置
p.setLover("逗比");
//cout << "情人: " << p.lover << endl; //只写属性,不可以读取
return 0;
}
7.3.5 案例实践
练习案例1:设计立方体类
设计立方体类(Cube),求出立方体的面积和体积,分别用全局函数和成员函数判断两个立方体是否相等。
练习案例2:点和圆的关系
设计一个圆形类(Circle),和一个点类(Point),计算点和圆的关系。
7.4 对象初始化
7.4.1 构造和析构函数
对象的初始化和清理也是两个非常重要的安全问题
- 一个对象或者变量没有初始状态,对其使用后果是未知
- 同样的使用完一个对象或变量,没有及时清理,也会造成一定的安全问题
c++利用了构造函数和析构函数解决上述问题,这两个函数将会被编译器自动调用,完成对象初始化和清理工作。
对象的初始化和清理工作是编译器强制要我们做的事情,因此如果我们不提供构造和析构,编译器会提供
编译器提供的构造函数和析构函数是空实现。
- 构造函数:主要作用在于创建对象时为对象的成员属性赋值,构造函数由编译器自动调用,无须手动调用。
- 析构函数:主要作用在于对象销毁前系统自动调用,执行一些清理工作。
构造函数语法:类名(){}
- 构造函数,没有返回值也不写void
- 函数名称与类名相同
- 构造函数可以有参数,因此可以发生重载
- 程序在调用对象时候会自动调用构造,无须手动调用,而且只会调用一次
析构函数语法: ~类名(){}
- 析构函数,没有返回值也不写void
- 函数名称与类名相同,在名称前加上符号 ~
- 析构函数不可以有参数,因此不可以发生重载
- 程序在对象销毁前会自动调用析构,无须手动调用,而且只会调用一次
class Person {
public:
Person(){
cout << "Person的构造函数调用" << endl;
}
~Person() {
cout << "Person的析构函数调用" << endl;
}
};
int main() {
Person p;
return 0;
}
7.4.2 构造函数分类
两种分类方式:
- 按参数分为: 有参构造和无参构造
- 按类型分为: 普通构造和拷贝构造
三种调用方式:
- 括号法
- 显示法
- 隐式转换法
示例:
class Person {
public:
int age;
public:
//无参(默认)构造函数
Person() {
cout << "无参构造函数!" << endl;
}
//有参构造函数
Person(int a) {
age = a;
cout << "有参构造函数!" << endl;
}
//拷贝构造函数
Person(const Person& p) {
age = p.age;
cout << "拷贝构造函数!" << endl;
}
//析构函数
~Person() {
cout << "析构函数!" << endl;
}
};
//调用无参构造函数
void test01() {
Person p; //调用无参构造函数
}
//调用有参的构造函数
void test02() {
//1.括号法,常用
Person p1(10);
//注意1:调用无参构造函数不能加括号,如果加了编译器认为这是一个函数声明
//Person p2();
//2.显式法
Person p2 = Person(10);
Person p3 = Person(p2);
//Person(10)单独写就是匿名对象 当前行结束之后,马上析构
//3隐式转换法
Person p4 = 10; // Person p4 = Person(10);
Person p5 = p4; // Person p5 = Person(p4);
//注意2:不能利用 拷贝构造函数 初始化匿名对象 编译器认为是对象声明
//Person p5(p4);
}
int main() {
test01();
test02();
return 0;
}
7.4.3 拷贝构造函数
C++中拷贝构造函数调用时机通常有三种情况
- 使用一个已经创建完毕的对象来初始化一个新对象
- 值传递的方式给函数参数传值
- 以值方式返回局部对象
示例:
class Person {
public:
int age;
public:
Person() {
cout << "无参构造函数!" << endl;
age = 0;
}
Person(int age) {
cout << "有参构造函数!" << endl;
age = age;
}
Person(const Person& p) {
cout << "拷贝构造函数!" << endl;
age = p.age;
}
//析构函数在释放内存之前调用
~Person() {
cout << "析构函数!" << endl;
}
};
//1. 使用一个已经创建完毕的对象来初始化一个新对象
void test1() {
Person man(80);//p对象已经创建完毕
Person newman1(man); //调用拷贝构造函数
Person newman2 = man; //拷贝构造
Person newman3;
newman3 = man;//不是调用拷贝构造函数,赋值操作
}
//2. 值传递的方式给函数参数传值
//相当于Person p1 = p;
void doWork(Person p) {
cout << "给函数参数传值 " << &p << endl;
}
void test2() {
Person p; //无参构造函数
doWork(p);
}
Person doWork2() {
Person p1;
cout << (int *)&p1 << endl;
return p1;
}
//3. 以值方式返回局部对象
void test3() {
Person p = doWork2();
cout << (int *)&p << endl;
}
int main() {
test1();
test2();
test3();
return 0;
}
7.4.4 构造调用规则
默认情况下,c++编译器至少给一个类添加3个函数
- 默认构造函数(无参,函数体为空)
- 默认析构函数(无参,函数体为空)
- 默认拷贝构造函数,对属性进行值拷贝
构造函数调用规则如下:
- 如果用户定义有参构造函数,c++不在提供默认无参构造,但是会提供默认拷贝构造
- 如果用户定义拷贝构造函数,c++不会再提供其他构造函数
示例:
class Person {
public:
int age;
public:
Person() {
cout << "无参构造函数!" << endl;
}
Person(int a) {
age = a;
cout << "有参构造函数!" << a << endl;
}
Person (Person& p) {
age = p.age;
cout << "拷贝构造函数!" << &p << endl;
}
~Person() {
cout << "析构函数" << endl;
}
};
void test1() {
Person p1(10);
//如果不写拷贝构造,编译器会自动添加拷贝构造,并且做浅拷贝操作
Person p2(p1);
cout << "p2的年龄为: " << p2.age << endl;
}
void test2() {
//如果用户提供有参构造,编译器不会提供默认构造,会提供拷贝构造
Person p1; //此时如果用户自己没有提供默认构造,会出错
Person p2(10); //用户提供的有参
Person p3(p2); //此时如果用户没有提供拷贝构造,编译器会提供
//如果用户提供拷贝构造,编译器不会提供其他构造函数
Person p4; //此时如果用户自己没有提供默认构造,会出错
Person p5(10); //此时如果用户自己没有提供有参,会出错
Person p6(p5); //用户自己提供拷贝构造
}
int main() {
test1();
test2();
return 0;
}
7.4.5 初始化列表
作用:
C++提供了初始化列表语法,用来初始化属性
语法:构造函数():属性1(值1),属性2(值2)... {}
示例:
class Person {
private:
int a;
int b;
int c;
public:
// Person(int a , int b , int c) {
// //this.a = a;
// this->a = a;
// this->b = b;
// this->c = c;
// }
Person(int a , int b , int c) : a(a), b(b) , c(c) {
cout << "有参构造函数!" << endl;
}
void printPerson() {
cout << "a:" << a << endl;
cout << "b:" << b << endl;
cout << "b:" << c << endl;
}
};
int main() {
Person p(1,2,3);
p.printPerson();
return 0;
}