【类与对象】封装&对象的初始化及清理-阿里云开发者社区

C++面向对象的三大特性：封装、继承、多态。具有相同性质的对象，抽象为类。

1 封装

1.1 封装的意义（一）

将属性和行为作为一个整体，表现为生活的事物
将属性和行为加以权限控制

语法：class 类名 { 访问权限：属性/行为}

示例：设计一个圆类，求圆的周长

/*
  设计一个圆类，求圆的周长
    圆的周长公式： 2 * PI * 半径
*/
const double PI = 3.14;

class Circle
{
  //访问权限
public:

  //1、属性
  //半径
  int m_r;

  //2、行为
  //获取圆的周长
  double calculateZC()
  {
    return 2 * PI * m_r;
  }

};
int main()
{
  system("color 1E");
  //通过圆类，创建具体的圆c ==>>实例化（通过一个类实例化一个具体的对象）
  Circle c1;
  //给圆对象的属性赋值
  c1.m_r = 10;
  cout << "圆的周长：" << c1.calculateZC() << endl;
  system("pause");  
  return 0;
}

示例2：设计一个学生类，属性：姓名、学号。给学生姓名和学号赋值，然后显示出姓名和学号

class Student
{
public: //  访问权限 ->公共权限

  //1、属性 :成员属性，成员变量
  string s_name;
  int stuId;

  //2、行为 ：成员函数 成员方法
  void showStudent()
  {
    cout << "学生的姓名：" << s_name << " 学号是：" << stuId << endl;
  }
  //给姓名赋值
  void setName(string name)
  {
    s_name = name;
  }
  //给学号赋值
  void setId(int id)
  {
    stuId = id;
  }
};
int main()
{
  system("color 1E");
  //通过学生类，创建具体那个学生 ==>>实例化（通过一个类实例化一个具体的对象）
  Student stu1;
  Student stu2;
  //给学生对象的属性赋值
  stu1.setName ("张三");
  stu1.setId( 21202201);
  stu1.showStudent();
  stu1.s_name = "李四";
  stu1.stuId = 21202202;
  stu1.showStudent();
  system("pause");  
  return 0;
}

1.2 封装的意义（二）

说明：类在设计时，可以把属性和行为放在不同的权限下，加以控制

访问权限三种：

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 = 12345;
  }
};

1.3 struct 和 class区别

说明：在C++中struct 和class唯一的区别在于默认的访问权限不同

区别：

struct：默认权限为公共
class：默认权限为私有

class C1
{
  int m_a; //默认权限 私有
};

struct C2
{
  int m_a; //默认权限 公共
};
C1 c1;
//c1.m_a = 100; //报错
C2 c2;
c2.m_a = 100; //公共权限，类内类外都可以访问

1.4 成员属性设置为私有

优点：

将所有成员属性设置为私有之后，自己可以控制读写权限
对于写权限，检测数据的有效性

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

/*
  成员属性设置为私有
    1、可以自己控制读写权限 --某些属性的读写
    2、对于以检测数据的有效性  --对于年龄的特殊设置

*/
//设计人类
class Person 
{
public:
  //设置姓名
  void setName(string name)
  {
    m_Name = name;
  }
  //获取姓名
  string getName()
  {
    return m_Name;
  }
  int setAge(int age)
  {
    m_Age = 0;
    if (age < 0 || age>150)
    {
      cout << "你输入的年龄有误，默认设置为0." << endl;
      return m_Age;
    }
    m_Age = age;
  }
  int getAge()
  {
    return m_Age;
  }
  void setLower(string lover)
  {
    m_Lover = lover;
  }

private:
  //姓名   可读可写
  string m_Name;
  //年龄   只读
  int m_Age;
  //情人    只写
  string m_Lover;

};
int main()
{
  system("color 1E");
  Person p;
  p.setName("唐三");
  cout << "输入的姓名：" << p.getName()<<endl;
  //检测数据的有效性
  p.setAge(1000);
  cout << "输入的年龄：" << p.getAge()<<endl; //年龄只读
  p.setLower("小舞");  //情人只能可写
  return 0;
}

练习案例：

1 设计立方体类

求出立方体的面积和体积。分别用全局函数和成员函数判断两个立方体是否相等

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

/*
  立方体的类的设计
    1、创建立方体类
    2、设计属性
    3、设计行为 获取立方体面积和体积
    4、分别利用全局函数和成员函数  判断两个立方体是否相等

*/
class Cube
{

public:
  void setL(double l) {
    m_L = l;
  }
  void setW(double w) {
    m_W = w;
  }
  void setH(double h) {
    m_H = h;
  }
  double getL() {
    return m_L;
  }
  double getW() {
    return m_W;
  }
  double getH() {
    return m_H;
  }
  //获取立方体的面积
  double getArea()
  {
    double area;
    area = 2 * (m_H*m_L + m_H * m_W + m_L * m_W);
    return area;
  }
  //获取立方体的体积
  double getVolu()
  {
    double volume;
    volume = m_H * m_L  * m_W ;
    return volume;
  }
  //利用成员函数判断两个立方体是否相等
  bool isSameByClass(Cube &c)
  {
    if (m_L = c.m_L && m_H == c.m_H && m_W == c.m_W)
    {
      return true;
    }
    return false;
  }

private:
  double m_L, m_W, m_H;



};

//全局函数判断两个函数是否相等
bool isSameByClasss(Cube &c1, Cube &c2)
{
  if (c1.getL() == c2.getL() && c1.getH() == c2.getH() && c1.getW() == c2.getW())
  {
    return true;
  }
  return false;
}

int main()
{
  system("color 1E");
  Cube c,c1,c2;
  c.setL(1);
  c.setW(2);
  c.setH(3);
  c1.setL(2);
  c1.setW(2);
  c1.setH(2);
  c2.setL(2);
  c2.setW(2);
  c2.setH(3);
  cout << "立方体的面积：" << c.getArea() << endl;
  cout << "立方体的体积：" << c.getVolu() << endl;
  bool gouRet = isSameByClasss(c1, c2);
  if (gouRet == true)
  {
    cout << "全局函数的两个立方体是相等的" << endl;
  }
  else
    cout << "全局函数的两个立方体是不相等的" << endl;
  bool ret = c1.isSameByClass(c2);
  if (ret == true)
  {
    cout << "两个立方体是相等的" << endl;
  }
  else
    cout << "两个立方体是不相等的" << endl;
  return 0;
}

2 对象的初始化和清理

生活中有些电子产品都有出厂设置
每个对象初始设置以及对象销毁前的清理数据的设置

2.1 构造函数和析构函数

对象的初始化和清理是重要的安全问题

一个对象或者变量没有初始状态，对其使用后果也是未知的

同样，使用完一个对象或变量，没有及时清理也会造成一定的安全问题

C++利用构造函数和析构函数解决上述问题，这两个函数会被编译器自动调用，完成对象初始化和清理工作。若是不提供构造和析构，编译器会提供构造函数和析构函数是空实现的（自己不写，有人写）

构造函数：主要作用于创建对象时为对象的成员属性赋值，构造函数由编译器自动调用，无需手动

析构函数：作用于对象销毁前自动调用，执行一些清理工作。

构造函数语法：类名(){ }

1 构造函数，没有返回值也不写void
2 函数名称与类明相同
3 构造函数可以有参数，因此可以重载
4 程序在调用对象的时候会自动调用构造，无需手动调用，且只调用一次

析构函数语法：~类名(){ }

1 析构函数，没有返回值不写void
2 函数名称与类名相同，在名称前面加上符合 ~
3 析构函数不可以有参数，因此不能发送重载
4 程序在对象销毁前会自动调用析构，无需手动调用，只调用一次

class Person
{
public:
  Person()
  {
    cout << "正在构造函数！！ " << endl;
  }

  ~Person()
  {
    cout << "正在析构函数！！ " << endl;
  } 
};
void test01() 
{
  Person p;
}
int main()
{
  test01();

  return 0;
}

2.2 构造函数的分类及调用

两种分类方式：

按照参数分：有参构造和无参构造

Person()
  {
    cout << "无参的构造函数调用！！ " << endl;
  }
  Person(int a)
  {
    age = a;
    cout << "有参的构造函数调用！！ " << endl;
  }

按照类型分：普通构造和拷贝构造

//拷贝构造函数
  /*
    定义：若是有张三这个人，然后用李四去克隆张三这个人的属性
    不过张三本身属性不能改变，加上 const只读
  
  */
  Person(const Person &p)
  {
    age = p.age;
  }

三种调用方式：

括号法(一般这个比较好 )
注意：若是无参的函数构造不要写"p1()"；这样会被认为是函数的声明

//1、括号法
  Person p1;
  //有参构造函数
  Person p2(10);
  cout << "p2的年龄为：" << p2.age << endl;
  //拷贝构造函数
  Person p3(p2);
  cout << "p3的年龄为：" << p3.age << endl;

显示法
注意：Person(10)若是在左侧，则是匿名对象；执行结束后，系统立马回收匿名对象函数

Person p1;
//有参构造函数
Person p2 = Person(10);
//拷贝构造函数
Person  p3 = Person(p2);

隐式转换法

Pensor p4=10; //相当于写了Person p4=Person(10) 有参构造
Pensor p5=p3; //拷贝构造

2.3 拷贝构造函数调用时机

C++拷贝构造函数调用时机通常有三种情况

使用一个已经创建完毕的对象来初始化一个对象
值传递的方式给函数参数传值

void doWork(Person p)
{
}
void test()
{
  Person p; //默认构造函数
    doWork(p);//拷贝构造函数，给函数的p，
}

以值的方式返回局部对象

Person doWork()
{
    Person p1;
    return p1; //返回p1的时候，也会产生一个拷贝构造函数。返回会重新生成一个跟p1一样的数据
}
void test()
{
    Person p = doWork();
}

2.4 构造函数调用规则

默认情况下，只要创建类，C++编译器至少给应该类添加3个函数

默认构造函数（无参，为空）
默认析构函数（无参，为空）
默认拷贝析构函数，对属性的值进行拷贝

构造函数调用规则如下：

如果用户定义有参构造函数，C++不提供默认无参构造，但会提供默认拷贝构造
如果用户定义拷贝构造函数，C++不再提供其他构造函数（有参、无参）

2.5 深拷贝与浅拷贝（面试提及）

浅拷贝：简单的赋值拷贝（编译器做）-》会导致堆区的内存重复释放

深拷贝：在堆区重新申请空间，进行拷贝操作

class Person
{
public:
  int age;
  int * Height;
  //构造函数
  Person()
  {
    cout << "无参的构造函数调用！！ " << endl;
  }
  Person(int a,int height)
  {
    age = a;
    //用new在堆区创建一个对象
    Height = new int(height);
    cout << "有参的构造函数调用！！ " << endl;
  }
  //自己实现拷贝构造函数 解决浅拷贝带来的问题
  Person(const Person &p)
  {
    cout << "Person 拷贝构造函数调用" << endl;
    age = p.age;
    //Height = p.Height; 编译器默认实现这行代码

    //在堆区重新申请空间，进行深拷贝
    Height = new int(*p.Height);
  }
  //析构函数
  ~Person()
  {
    //释放堆区创建的内存
    if (Height != NULL)
    {
      delete Height;
      Height = NULL;
    }
    //作用：析构代码，将堆区开辟数据做释放
    cout << "正在析构函数！！ " << endl;
  }
};
//调用
void test01()
{
  //p1走自己的析构，p2也是自己的析构
  Person p1(18, 180);
  cout << "p1的年龄为：" << p1.age << " 身高为：" << *p1.Height << endl; //*表示指针的实际化，输出的是一个值，不是地址
  Person p2(p1);
  cout << "p2的年龄为：" << p2.age << " 身高为：" << *p2.Height << endl;
}

说明：若是使用指针就会在堆区使用内存空间，p1和p2两个对象，然后两个对象指向同一块内存；delete是释放对象指向的内存，这里用浅拷贝会被释放两次。

2.6 初始化列表

说明：C++提供初始化列表语法，用来初始化属性

语法：构造类名()：属性1(值1)，属性2(值2) . . . { }

1）传统初始化列表：

class Person
{
public:
  int m_A;
  int m_B;
  int m_C;
  //传统列表赋初值
  Person(int a, int b, int c)
  {
    m_A = a;
    m_B = b;
    m_C = c;
  }
};
void test()
{
  Person p(10, 20, 30);
  cout << "m_A = " << p.m_A << endl;
  cout << "m_A = " << p.m_B << endl;
  cout << "m_A = " << p.m_C << endl;
}

改进之后的：

Person(int a,int b,int c):m_A(a),m_B(b),m_C(c)
{
}

2.7 类对象作为类成员

说明：C++类中的成员可以是另一个类的对象，称为该成员为对象成员。当其他类对象作为本类对象，构造的时候先构造其他类对象，再构造自身对象。析构的时候先释放自身内存，再释放其他对象内存。

//创建手机的类
class Phone
{
public:
  string m_Pname;
  Phone(string name)
  {
    m_Pname = name;
    cout << "正在调用手机类的构造函数" << endl;
  }

  ~Phone()
  {
    cout << "正在调用手机类的析构函数" << endl;
  }
};
class Person
{
public:

  string m_Name;
  Phone m_Phone;

  Person(string name, string phone):m_Name(name),m_Phone(phone)
  {
    cout << "正在调用Person类的构造函数" << endl;
  }

  ~Person()
  {
    cout << "正在调用Person类的析构函数" << endl;
  }
};
//调用
void test01()
{

  Person p("张三", "苹果14pro");
  cout << p.m_Name << "拿着：" << p.m_Phone.m_Pname << "手机" << endl;
   
}

2.8 静态成员

静态成员就是想在成员变量和成员函数前加上关键字static，称为静态成员

静态成员分为：

1）静态成员变量

所有对象共享一份数据（若是p1.a=100，若是p2也调用，p2.a=200，则p1.a=200;a是共享的）

在编译阶段分配内存

类内声明，类外初始化（在类外声明一个类内定义的属性，初始化：int Person::a=100)，类外访问不到私有静态成员变量。

私有成员变量访问不到

class Person
{
public:
  static int m_Age;
};
int Person::m_Age = 100;

Person p;
//访问方式一：通过对象
cout << p.m_Age << endl; ->100
//访问方式二：通过类名
cout<<Person::m_Age<<endl; ->100
Person p1;
p1.m_Age = 200;
cout << p.m_Age << endl; ->200 //修改了

2）静态成员函数

所有对象共享一个函数
静态成员函数只能访问静态成员变量，非静态成员变量函数，无法区分到底是那个对象的属性；而静态成员变量所有人共享一份，不属于任何人。
私有成员函数访问不到

【类与对象】封装&对象的初始化及清理

1 封装

1.1 封装的意义（一）

1.2 封装的意义（二）

1.3 struct 和 class区别

1.4 成员属性设置为私有

练习案例：

1 设计立方体类

2 对象的初始化和清理

2.1 构造函数和析构函数

2.2 构造函数的分类及调用

2.3 拷贝构造函数调用时机

2.4 构造函数调用规则

2.5 深拷贝与浅拷贝（面试提及）

2.6 初始化列表

2.7 类对象作为类成员

2.8 静态成员

热门文章

最新文章

相关电子书

相关实验场景

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

【类与对象】封装&对象的初始化及清理

1 封装

1.1 封装的意义（一）

1.2 封装的意义（二）

1.3 struct 和 class区别

1.4 成员属性设置为私有

练习案例：

1 设计立方体类

2 对象的初始化和清理

2.1 构造函数和析构函数

2.2 构造函数的分类及调用

2.3 拷贝构造函数调用时机

2.4 构造函数调用规则

2.5 深拷贝与浅拷贝（面试提及）

2.6 初始化列表

2.7 类对象作为类成员

2.8 静态成员

热门文章

最新文章

相关电子书

相关实验场景