03-C++ 类和对象
类和对象
1. 概述
1.1 对象
真实存在的事物
1.2 类
多个对象抽取其共同特点形成的概念
静态特征提取出来的概念称为成员变量，又名属性
动态特征提取出来的概念称为成员函数，又名方法
1.3 类与对象的关系
在代码中先有类后有对象
一个类可以有多个对象
多个对象可以属于同一个类
2. 类的定义
2.1 语法
class 类名
{
[访问权限修饰符:]
成员变量
成员函数
};
2.2 访问权限修饰符
private: 私有的,当前类中可用,默认的
protected: 受保护的,当前类或子类中可用
public: 公共的,当前项目中可用
2.3 示例
class Person{
private:
int age;
protected:
char sex[10];
public:
char name[50];
void eat()
{
cout << name << "吃饭" << endl;
}
void sleep();
};
void Person::sleep()
{
cout << name << "睡觉" << endl;
}
3. 封装性
概念：即包装，将数据和方法封装在一起，加以权限区分使其可以保护内部，降低耦合度，便于使用
int a = 10;
int nums[5] = {1,2,3,4,5};
void fun()
{
xxx
}
class A
{
属性
函数
}
A a;
x.c文件
优点:
- 降低代码耦合度
- 提高代码复用率
- 便于使用
4. 类的设计
① 私有化所有属性
② 提供可以获取这些属性值与修改属性值的函数
示例：
#include 4.1 练习
请设计一个 Person 类，Person 类具有 name 和 age 属性，提供初始化函数(Init)
并提供对 name 和 age 的读写函数(set，get)
但必须确保 age 的赋值在有效范围内(0-100),超出有效范围，则拒绝赋值
并提供方法输出姓名和年龄
#include 4.2 练习2：分文件
设计立方体类(Cube)
其属性有长,宽,高
其函数有获取长宽高的函数,修改长宽高的函数
计算体积的函数
计算面积的函数
提示:
立方体的面积:2ab + 2ac + 2bc
体积:a * b * c
main.cpp 文件：
#include cube.cpp 文件
#include "cude.h"
#include cube.h 文件
#ifndef CUDE_H
#define CUDE_H
class Cube
{
private:
int l;
int w;
int h;
public:
int get_l();
int get_w();
int get_h();
void set_l(int length);
void set_w(int width);
void set_h(int height);
void mj();
void tj();
};
#endif // CUDE_H
5. 构造函数
5.1 概述
构造函数：类实例化对象的时候自动调用。
注意:
- 当一个类中
没有构造函数，系统将默认为其生成一个无参构造- 如果一个类中有构造函数，系统将不会为其提供默认的无参构造
一个类可以定义多个构造函数，该类中的多个构造函数为重载关系无参构造:
- 构造函数无形参列表
有参构造:
- 构造函数有形参列表
5.2 语法
类名(形参列表)
{
该类对象赋初始值
}
注意:形参列表可有可无
5.3 示例
#include 6. 析构函数
6.1 概述
对象生命周期结束的时候，自动调用析构函数。
注意:
一个类只能有一个析构函数- 如果
用户不提供析构函数 编译器默认会提供一个空的析构函数。经验:
一般不需要自定义析构函数，但是如果类中有指针成员且指向堆区空间，这时必须实现析构函数，在其中释放指针成员指向的堆区空间
6.2 语法
~类名()
{
}
注意：没有形参列表
6.3 示例
#include 7. 多对象构造与析构顺序
7.1 对象A与对象B平级，符合栈的顺序(先进后出)，谁先创建谁后释放
#include 结果：
1构造函数被调用了
2构造函数被调用了
3构造函数被调用了
4构造函数被调用了
4析构函数被调用了
3析构函数被调用了
2析构函数被调用了
1析构函数被调用了
7.2 对象A是对象B的成员，先成员构造，再对象构造，再对象析构，再成员析构
#include 8. 拷贝构造函数
8.1 概述
拷贝构造在以下情况自动触发：
- 旧对象给新对象初始化，会调用拷贝构造函数
- 对象作为函数的形参，函数调用时会调用拷贝构造
- 普通对象作为函数的返回值(vsCode会触发拷贝构造，Qt、Linux不会触发拷贝构造)
注意：
如果
用户不提供拷贝构造编译器会提供一个默认的拷贝构造（浅拷贝）。只有 类中有指针成员且指向堆区时 才有必要实现拷贝构造（深拷贝）。
浅拷贝与深拷贝:
- 浅拷贝：当类中的成员有指针成员，此时只拷贝地址
- 深拷贝：当类中的成员有指针成员，先开辟内存，再拷贝其值
8.2 语法
类名(const 类名 &ob)
{
}
8.3 示例
#include 8.4 示例：浅拷贝
注意：
- 在释放内存时，先释放p2 ，其指向的地址会被释放，但是p1的地址还是0x01，再次释放就会报错，所以浅拷贝会存在问题
#include 
8.5 示例：深拷贝
深拷贝会在堆区再开辟一块内存，将值拷贝到这块内存，即p1和 p2指向了不同的内存空间，释放时是各自释放各自的，不会存在问题
#include 9. 初始化列表
9.1 概述
构造函数：主要用于创建类的对象是给其属性赋初始值
在定义构造函数时，c++中提供了初始化列表的语法，以便于初始化成员变量的值。
9.2 语法
类名(参数列表):成员名(参数名),成员名2(参数名2),... {
}
9.3 示例
#include 10. explicit关键字
作用：禁止隐式转换
语法：
explicit 类名(形参列表):初始化列表
{
}
示例：
class C{
private:
int a;
public:
explicit C(int x):a(x){}
};
int main(int argc, char *argv[])
{
C c = 10;//构造函数的隐式转换
//当调用构造函数使用explicit修饰后防止隐式转换,此时上述代码报错
return 0;
}
11. new / delete
-
当用
new创建一个对象时，它就 在堆里为对象分配内存并调用构造函数完成初始化； -
new 表达式的反面是 delete 表达式。
delete表达式先调用析构函数，然后释放内存。正如 new 表达式返回一个指向对象的指针一样， delete 需要一个对象的地址。delete 只适用于由 new 创建的对象。
11.1 情况1：操作基本类型
作用：
- new：申请堆区空间；
- delete：释放堆区空间。
示例：
#include 11.2 情况2：操作数组
作用：
- new：申请堆区空间；
- delete：释放堆区空间。
示例：
#include 11.3 情况3：操作对象
作用：
- new：分配空间，调用构造函数 ；
- delete：调用析构函数，释放空间 。
示例：
#include 12. 对象数组
数组中存放的是对象。
对象数组：必须 显示 调用构造函数初始化
12.1 静态对象数组
示例：
#include 12.2 动态对象数组
示例：
void fun05()
{
A *arr = new A[5]{A(10),A(20),A(30),A(40),A(50)};
int i=0;
for(i=0;i<5;i++)
{
cout<<arr[i].mA<<" ";
}
cout<<endl;
//delete arr;//只会释放第0个元素
delete [] arr;
}
//A有参构造mA=10
//A有参构造mA=20
//A有参构造mA=30
//A有参构造mA=40
//A有参构造mA=50
//10 20 30 40 50
//A析构函数mA=50
//A析构函数mA=40
//A析构函数mA=30
//A析构函数mA=20
//A析构函数mA=10
13. 静态成员
static 修饰的成员为静态成员。
建议使用 类名 调用静态成员
- 静态成员在类加载之初被加载，不占用对象的空间
- 非静态成员加载在对象中
- 成员函数加载到代码区
13.1 静态成员变量
13.1.1 概述
特点：
- 静态成员是
属于类而不是对象。（所有对象共享）注意:
- 静态成员数据
不占对象的内存空间。- 静态成员数据是属于类 而不是对象（多个对象共享一份静态成员数据）
- 静态成员数据 在
定义对象之前就存在。静态成员数据在类中定义，类外初始化。
13.1.2 示例
#include 13.1.3 小结
1,属于类的，不属于对象，当前类中所有对象共有一份，不占用对象的内存空间
2,可以使用类名直接调用,也可以使用对象名调用
类名调用：
类名::静态成员变量名
对象调用：
对象名.静态成员变量名
3,在类中定义,在类外初始化,初始化时不关注访问权限修饰符,在类外使用时关注访问权限修饰符
13.2 静态成员函数
使用 static 修饰的成员函数
特点:
- 静态成员函数中
只能使用静态成员。
示例
#include 14. 单例模式
设计模式：
每一个设计模式是为了解决 一种特点的问题
概述：所属的类 只能实例化一个对象。
思想：
- 私有化构造函数
- 提供公共函数，返回该类对象
14.1 饿汉式：返回创建好的对象
缺点：占用内存多
优点：线程安全
示例：
#include 14.2 懒汉式：第一次调用时创建对象并返回，后面调用返回第一次创建的对象
缺点：线程不安全
优点：占内存少
示例：
class B{
private:
int x;
static B* b;
private:
B(){}
B(const B& b){}
public:
static B& getInstance()
{
//判断是否已经创建对象
if(b == NULL)
{
b = new B();
}
return *b;
}
};
B *B::b = NULL;
int main(int argc, char *argv[])
{
B& b1 = B::getInstance();
B& b2 = B::getInstance();
B& b3 = B::getInstance();
cout << &b1 << endl; //0xf37040
cout << &b2 << endl; //0xf37040
cout << &b3 << endl; //0xf37040
return 0;
}