C++核心编程——4.类和对象

已于 2022-11-27 15:17:39 修改
阅读量326 收藏
点赞数
分类专栏： C++编程 文章标签： c++ 开发语言
于 2022-11-24 10:55:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44983833/article/details/127954613
版权

C++面向对象的三大特性为：封装、继承、多态

C++认为万事万物皆为对象，对象上有其属性、行为

例如：人可以作为对象，属性有姓名、年龄、身高、体重......行为有走、跑、跳、吃饭、唱歌......车也可以作为对象，属性有轮胎、方向盘、车灯......行为有载人、放音乐、放空调......具有香港铜性质的对象，我们可以抽象称为类，人属于人类，车属于车类

4.1封装

4.1.1封装的意义

封装是C++面向对象三大特性之一

封装意义：

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

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

        封装意义一： 在设计类的时候，属性和行为写在一起，表现事物

示例1：

#include <iostream>
using namespace std;

const double PI  = 3.14;
//设计一个圆类，求圆的周长
//圆求周长的公式： 2*PI*半径
class Circle{
    //访问权限
    //公共权限
    public:
    //属性:半径
    int m_r;
    //行为：获取圆的周长
    double calculateZC(){
        return 2 * PI * m_r;
    }
};

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

运行结果：

圆的周长为：62.8

示例2：

#include <iostream>
#include <string>
using namespace std;
//设计一个学生类，属性有姓名和学号；可以给姓名和学号赋值，可以显示学生的姓名和学号
class Student {
    public://公共权限
    //属性
    string m_Name;//学号
    int m_Id;//姓名
    //行为
    //显示学号和姓名
    void showStudent() {
        cout << "姓名：" << m_Name << "\t学号： " << m_Id <<endl;
    }
};

int main(){
    //创建一个具体的学生，实例化对象
    Student s1;
    //给s1对象，进行属性赋值操作
    s1.m_Name = "张三";
    s1.m_Id = 1;
    s1.showStudent();
    system("pause");
    return 0;
}

运行结果：

姓名：张三      学号： 1

示例3：

#include <iostream>
#include <string>
using namespace std;
//设计一个学生类，属性有姓名和学号；可以给姓名和学号赋值，可以显示学生的姓名和学号
class Student {
public://公共权限
    //类中的属性和行为统一称为“成员”
    //属性 别名：成员属性、成员变量
    //行为 别名：成员函数、成员方法
    //属性
    string m_Name;//学号
    int m_Id;//姓名
    //行为
    //显示学号和姓名
    void showStudent() {
        cout << "姓名：" << m_Name << "\t学号： " << m_Id <<endl;
    }
    //给姓名赋值
    void setName(string name) {
        m_Name = name;
    }
    //给学号赋值
    void setId(int id) {
        m_Id = id;
    }
};

int main(){
    //创建一个具体的学生，实例化对象
    Student s1;
    //给s1对象，进行属性赋值操作
    //s1.m_Name = "张三";
    s1.setName("张三");
    //s1.m_Id = 1;
    s1.setId(1);
    s1.showStudent();
    system("pause");
    return 0;
}

运行结果：

姓名：张三      学号： 1

        封装的意义二：类在设计是，可以把属性和行为放在不同的权限下，加以控制

        访问权限有三种：

  1.  public 公共权限：成员 类内可以访问，类外可以访问
  2. protected 保护权限：成员 类内可以访问，类外不可以访问，儿子可以访问父亲中的保护内容
  3. private 私有权限：成员 类内可以访问，类外不可以访问，儿子不可以访问父亲的私有内容

示例：

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

class Person {
public://公共权限
    string m_Name; //姓名

protected://保护权限
    string m_Car;//汽车

private://私有权限
    int m_Password;//银行卡密码 
private:
    void func() {
        m_Name = "Peter";
        m_Car = "BMW";
        m_Password = 12346;
    }

};

int main(){
    //实例化具体对象
    Person p1;
    p1.m_Name = "Joey";
    //p1.m_Car = "FALALI"//保护权限内容，在类外访问不到
    //p1.m_Password = 123; //私有权限内容，在类外访问不到
    //p1.func();//私有权限内容，在类外访问不到
    system("pause");
    return 0;
}

4.1.2struct和class的区别

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

区别：

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

示例：

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

class C1 {
    int m_A;//默认权限是私有
};
struct C2 {
    int m_A;//默认权限是公共
};

int main(){
    C1 c1;
    //c1.m_A = 100;//报错，在class里默认权限私有，因此类外不可以访问
    C2 c2;
    c2.m_A = 100;//在struct中默认权限为公共，因此可以访问
    system("pause");
    return 0;
}

4.1.3成员属性设置为私有

        优点1：将所有成员属性设置为私有，可以自己控制读写权限

        优点2：对于写权限，我们可以检测数据的有效性

示例：

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

class Person {
public:
    //设置姓名
    void setName(string name)
    {
        m_Name = name;
    }
    //获取姓名
    string getName()
    {
        return m_Name;
    }
    //设置年龄
    void setAge(int age)
    {
        if(age < 0 || age >150)
        {
            m_Age = 0;
            cout << "年龄输入有误" << endl;
            return;
        }
        m_Age = age;
    }
    //获取年龄
    int getAge()
    {
        //m_Age = 0;//初始化为0岁
        return m_Age;
    }
    //设置情人
    void setLover(string lover)
    {
        m_Lover = lover;
    }

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

int main(){
    Person p;
    p.setName("Peter");
    cout << "姓名为：" << p.getName() << endl; 
    p.setAge(18);
    cout << "年龄为：" << p.getAge() << endl;
    p.setLover("寡姐");
    //cout << "情人为：" << p.getLover() << endl;//情人是不可以被访问的
    system("pause");
    return 0;
}

运行结果：

姓名为：Peter
年龄为：18

4.2对象的初始和清理

  • 生活中我们买的电子产品基本都会有出厂设置，在某一天我们不用的时候也会删除自己的信息数据保证安全

  • C++中的面向对象来源于生活，每个对象也都会有初始设置以及对象销毁前的清理数据的设置

4.2.1构造函数和析构函数

对象的初始化和清理也是两个非常重要的安全问题

  • 一个对象或者变量没有初始状态，对其使用后果是未知
  • 同样的，使用完一个对象或变量，没有及时清理，也会造成一定的安全问题

C++利用了构造函数和析构函数解决上述问题，这两个函数将会被编译器自动调用，完成对象初始化和清理工作。对象的初始化和清理工作是编译器强制我们做的事情，因此如果我们不提供构造和析构函数，编译器会提供。但编译器提供的构造函数和析构函数是空实现

  • 构造函数：主要作用在于创建对象时为对象的成员属性赋值，构造函数由编译器自动调用，无需手动调用
  • 析构函数：主要作用在于对象销毁前系统自动调用，执行一些清理工作

构造函数语法： 类名（）{}

        1.构造函数，没有返回值也不写void；

        2.函数名称与类名相同；

        3.构造函数可以有参数，因此可以发生重载；

        4.程序在调用对象时会自动调用构造，无需手动调用，而且只会调用一次

析构函数语法： ~类名（）{}

        1.析构函数，没有返回值也不写void；

        2.函数名称与类名相同，在名称前加上符号~

        3.构造函数不可以有参数，因此不可以发生重载

        4.程序在对象销毁时会自动调用析构，无需手动调用，而且只会调用一次

示例：

#include <iostream>
using namespace std;
class Person
{
public:
    Person ()//构造函数
    {
        cout << "Person 构造函数的调用" << endl;
    } 
    ~ Person ()//析构函数
    {
        cout << "Person 析构函数的调用" << endl;
    }

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

运行结果：

Person 构造函数的调用
Person 析构函数的调用

4.2.2构造函数的分类和调用

两种分类方式：

        按参数分为：有参构造和无参构造（默认构造）

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

三种调用方式：

        括号法、显示法、隐式转换法

示例：

#include <iostream>
using namespace std;
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;
    }
    ~ Person ()//析构函数
    {
        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();

    //2.显示法
    Person p4;//无参构造
    Person p5 = Person(10);//有参构造
    Person p6 = Person(p2);//拷贝构造
    //Person(10);//匿名对象，特点：当前行执行结束后，系统会立即回收掉匿名对象
    //注意事项：不要利用拷贝构造函数，初始化匿名对象，编译器会认为是对象声明 Person (p3) == Person p3;
    //Person(p3);

    //3.隐式转换法
    Person p7 = 10;//相当于写了Person p4 = Person(10);有参构造
    Person p8 = p7;//拷贝构造
}
int main(){
    test01();
    system("pause");
    return 0;
}

运行结果：

Person 无参构造函数的调用
Person 有参构造函数的调用
Person 拷贝构造函数的调用
p2的年龄为: 10
p3的年龄为: 10
Person 无参构造函数的调用
Person 有参构造函数的调用
Person 拷贝构造函数的调用
Person 有参构造函数的调用
Person 拷贝构造函数的调用
Person 析构函数的调用
Person 析构函数的调用
Person 析构函数的调用
Person 析构函数的调用
Person 析构函数的调用
Person 析构函数的调用
Person 析构函数的调用
Person 析构函数的调用

4.2.3拷贝构造函数的调用时机

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

  • 使用一个已经创建完毕的对象来初始化一个新对象
  • 值传递的方式给函数参数传值
  • 以值方式返回局部对象

示例：

#include <iostream>
using namespace std;
class Person
{
public:
    Person ()//无参构造函数
    {
        cout << "Person 无参构造函数的调用" << endl;
    } 
    Person (int a)//有参构造函数
    {
        m_age = a;
        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 p1(20);
    Person  p2(p1);
    cout << "p2的年龄为： " << p2.m_age << endl;
}
//以值传递的方式给函数函数传值
void doWork(Person p)
{

}
void test02()
{
    Person p;
    doWork(p);
}
//值方式返回局部对象
Person doWork2(){
    Person p1;
    return p1;
}
void test03()
{
    Person p = doWork2();
}
int main(){
    test01();
    test02();
    test03();
    system("pause");
    return 0;
}

运行结果：（test03()的调用结果和视频中不一致，少显示了拷贝构造函数的调用及析构函数调用两行）

Person 有参构造函数的调用
Person 拷贝构造函数的调用
p2的年龄为： 20
Person 析构函数的调用
Person 析构函数的调用
Person 无参构造函数的调用
Person 拷贝构造函数的调用
Person 析构函数的调用
Person 析构函数的调用
Person 无参构造函数的调用
Person 析构函数的调用

4.2.4构造函数调用规则

默认情况下，C++编译至少给一个类添加3个函数

  1. 默认构造函数（无参，函数体为空）
  2. 默认析构函数（无参，函数体为空）
  3. 默认拷贝函数，对属性进行拷贝

构造函数调用规则如下：

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

示例：

#include <iostream>
using namespace std;
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 = 18;
    Person p2(p);
    cout << "p2的年龄为： " << p2.m_age << endl;
}
int main(){
    test01();
    system("pause");
    return 0;
}

运行结果:

Person 无参构造函数的调用
Person 拷贝构造函数的调用
p2的年龄为： 18
Person 析构函数的调用
Person 析构函数的调用

注释掉自定义的拷贝构造函数后的运行结果：

Person 无参构造函数的调用
p2的年龄为： 18
Person 析构函数的调用
Person 析构函数的调用

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 (const Person &p)//拷贝构造函数
    {
        m_age = p.m_age;
        //m_height = p.m_height;//编译器默认实现的就是这行代码
        //深拷贝操作
        m_height = new int(*p.m_height);
        cout << "Person 拷贝构造函数的调用" << endl;
    }
    ~ Person ()//析构函数
    {
        //析构代码，将堆区开辟数据做释放操作
        if(m_height != NULL)
        {
            delete m_height;
            m_height = NULL;
        }
        cout << "Person 析构函数的调用" << endl;
    }
public:
    int* m_height;
    int m_age;

};
void test01()
{
    Person p1(18,160);
    cout << "p1的年龄为： " << p1.m_age << "    p1的身高为：　" << *p1.m_height << endl;
    
    Person p2(p1);
    cout << "p2的年龄为： " << p1.m_age << "    p2的身高为：　" << *p1.m_height << endl;
}
int main(){
    test01();
    system("pause");
    return 0;
}

运行结果：

Person 有参构造函数的调用
p1的年龄为： 18    p1的身高为：　160
Person 拷贝构造函数的调用
p2的年龄为： 18    p2的身高为：　160
Person 析构函数的调用
Person 析构函数的调用

 总结：如果属性中有堆区开辟的，一定要自己提供拷贝构造函数，防止浅拷贝带来的问题。也一定要在析构函数中释放掉在堆区申请的空间

4.2.6初始化列表

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

语法：构造函数（）：属性1（值1），属性2（值2）...{}

示例：

#include <iostream>
using namespace std;
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(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;
}

运行结果：

m_A = 30
m_B = 20
m_C = 10

4.2.7类对象作为类成员

        C++类中的成员可以是另一个类的对象，我们称该成员为对象成员

例如：

class A {}
class B
{
    A a;
}

B类中有对象A作为成员，A为对象成员。那么当创建B对象时，A与B的构造与析构的顺序是谁先谁后?

示例：

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

class Phone//手机类
{
public:
    Phone(string PName)
    {
        cout << "Phone 的构造函数调用" << endl;
        m_PName = PName;
    }
     ~Phone(){
        cout << "Phone 的析构函数调用" << endl;
    }
    string m_PName;//手机品牌名称
};
class Person//人类
{
public:
    //Phone m_Phone = pName 隐式转换法
    Person(string name,string pName): m_Name(name),m_Phone(pName){
        cout << "Person 的构造函数调用" << endl;
    }
    ~Person(){
        cout << "Person 的析构函数调用" << endl;
    }
    string m_Name;//姓名
    Phone m_Phone;//手机
};
//当其他类对象作为本类成员，构造时先构造类对象，再构造自身,析构与顺序与构造相反
void test01()
{
    Person p("张三","苹果 MAX");
    cout << p.m_Name << "拿着： " << p.m_Phone.m_PName << endl;
   
}
int main(){
    test01();
    system("pause");
    return 0;
}

运行结果：

Phone 的构造函数调用
Person 的构造函数调用
张三拿着： 苹果 MAX
Person 的析构函数调用
Phone 的析构函数调用

绿豆君
关注
专栏目录
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值