【C++程序员必修课】C++基础课程-16：class 类（上）

天恩软件工作室

已于 2024-01-09 20:08:26 修改

阅读量221

点赞数 3

分类专栏： C++程序员必修课文章标签： 1024程序员节 C++类 C++ class 类 class类 C++基础课程

于 2023-10-24 15:22:56 首次发布

本文链接：https://blog.csdn.net/yanghz/article/details/134013242

版权

C++程序员必修课专栏收录该内容

17 篇文章 0 订阅

订阅专栏

1 本课主要内容：

C++ class 类是什么？class 类与 struct 的主要差异？
C++ class 类定义语法及基本使用
面向对象编程三大特性之一：封装（成员保护）public, protected, private
类构造函数、初始化列表和析构函数
面向对象编程三大特性之二：继承

2 主要知识点：

C++ class 类是什么？

C++ class 类是面向对象编程三大特性之：封装的核心技术，是面向对象编程的基础；换句话说，类是一种用户自定义数据类型，用来封装和表示某种特定对象的属性和各种行为，是一种封装了数据和函数的组合

如下例子：

// 用户类例子
class UserInfo {
public:
    UserInfo();
    ~UserInfo();
    
private:
    std::string m_userName;    // 用户名称
    std::string m_address;     // 住址
    int m_age{0};              // 年龄
    int m_gender{0};           // 性别：0表示未设定；1表示男性；2表示女性；
    // ...
}

class 类和 struct 结构体差异

使用上 class 类有点类似于 struct 结构体，但 struct 只是 C++ 支持标准 C 的一个延伸；struct 结构体成员默认是 public 开放，而 class 类成员默认是 private 私有；

在 C++ 开发中，使用更多的是 class 类；

class 类定义语法及基本使用

类定义基本语法：
class class_name {
public:    // 开放
    // 可选构造函数、析构函数
    class_name();
    class_name(...);
    ~class_name();
    
    return_type function1(...);
    ...
protected:    // 保护
    return_type function1(...);
    ...
private:    // 私有
    return_type function1(...);
    ...
private:    // 私有
    type member1;
    ...
};

// 例子：点设计类
class Point {
public:
    Point(int x, int y);
    
    float x() const { return m_x; }
    float y() const { return m_y; }

    void set_x(int x) { m_x = x; }
    void set_y(int y) { m_y = y; }

private:
    float m_x{ 0.0 };
    float m_y{ 0.0 };
};

Point p1;        // 实例化类对象
p1.set_x(1);     // 访问类成员函数
p1.set_y(2);

C++ 面向对象编程三大特性之一：封装（成员保护）

封装：将客观事务封装成抽象的类，而类可以把自己的数据和方法暴露给可信的类或者对象，对不可信的类或者对象进行信息隐藏；通过这种⽅式，类对象对内部数据提供了不同级别的保护，可以防⽌程序中⽆关的数据被意外的修改，或被错误的访问到对象的私有部分

public 开放：对所有开放

protected 保护：对外隐藏，对子类开放

private 私有：对外隐藏，只对本类开放

// 矩形设计类
class Rect {
public:
    // 对外开放
    void set_point(int x, int y) { m_x = x; m_y = y; }
    int x() const { return m_x; }
    int y() const { return m_y; }

protected:
    // 保护：对继承类（子类）开放
    bool is_valid() const { return m_width > 0 && m_height > 0; }   // 判断是否有效

private:
    // 私有：只对本类开放
    void reset() { m_x = 0; m_y = 0; }

private:
    // 私有：只对本类开放
    int m_x{ 0 };        // 矩形 X 点
    int m_y{ 0 };        // 矩形 Y 点
    int m_width{ 0 };    // 矩形宽度
    int m_height{ 0 };   // 矩形高度
};

Rect rect;
rect.set_point(100, 100);   // 只能访问 public 对外开放成员函数
std::cout << "x,y = " << rect.x() << rect.y() << std::endl;

类构造函数、初始化列表和析构函数

构造函数：C++ 用于初始化对象的数据成员的一种函数，函数名跟对象一样，没有返回值，参数个数没有限制，支持构造函数重载（就是可以有多个不同参数的构造函数）

析构函数：C++ 用于对象生命周期结束时，自动调用的一种函数，函数名跟对象一样，前面带(~)，析构函数只有一个不支持重载

例子：

// 帐号信息类例子
class AccountInfo
{
public:
    // 默认构造函数（可选）
    AccountInfo()
    {
        std::cout << "默认构造:" << std::endl;
    }
    // 带参数构造函数
    AccountInfo(int id, const std::string& account)
        : m_id(id)  // 初始化数据成员
        , m_account(account)
    {
        std::cout << "自定义构造: id = " << m_id << std::endl;
    }
    // 析构函数（可选）
    ~AccountInfo()
    {
        std::cout << "id 析构:" << m_id << std::endl;
    }

    // 类函数
    void set_account(const std::string& account) { m_account = account; }
    const std::string& get_account() const { return m_account; }

private:
    int m_id{ 0 };
    std::string m_account;  // 帐号
    std::string m_password; // 密码
    int m_level{ 0 };       // 等级
};

AccountInfo account1;                    // 调用默认构造结构对象
AccountInfo account2(100, "user2");      // 调用自定义构造结构对象
// 访问类函数
account1.set_account("user1");
std::cout << "account1 : " << account1.get_account() << std::endl;
std::cout << "account2 : " << account2.get_account() << std::endl;

C++ 面向对象编程三大特性之二：继承

所谓的继承就是一个类继承了另一个类的属性和方法，这个新的类包含了上一个类的属性和方法，被称为子类或者派生类，被继承的类被称为父类或者基类

C++ 类支持多继承，就是一个类可以同时继承于多个父类

/ 继承例子
// 画图基类
class DrawItem {
public:
    int get_x() const {return m_x;}
    void set_x(int x) {m_x = x;}
    int get_y() const {return m_y;}
    void set_y(int y) {m_y = y;}
    
    void set_visible(bool visible) {m_visible = visible;}
    bool get_visible() const {return m_visible;}
private:
    int m_x{0};                // 坐标点 x
    int m_y{0};                // 坐标点 y
    bool m_visible{true};      // 是否可见
}

// 子类1：矩形
class Rectangle : public DrawItem {
public:
    
private:
    int m_width{0};     // 矩形宽
    int m_height{0};    // 矩形高
}

// 子类2：圆形
class Circular : public DrawItem {
public:
    
private:
    int m_radius{0};    // 圆半径
}

3 一些建议：

基类的析构函数用 virtual 修饰写成纯虚析构函数，可以避免某些场景内存泄露（如销毁继承子类），如下写法：

class ClassName {
public:
    virtual ~ClassName();
}；

类成员函数如果不对外开放，只在本类使用，用 private 修饰为私有；如果只对子类开放，用 protected 保护修饰；其他对外开放才用 public 开放修饰

类成员函数如果确定不会更改类成员变量，就用 const 将函数修饰为常成员函数，如：

class ClassName {
public:
    int get_data() const {return m_data;}
}；

类成员变量建议全部用 private 私有保护起来，统一通过构造函数和成员函数来赋值和访问

4 课后练习：

修改上一课程的练习，用 class 类来定义用户信息，增加 "edit" 编辑用户信息指令和 "help" 打印帮助信息指令，详细指令功能如下：

"add" : 新建一个用户；用户编号自增长，用户名称提示用户输入
"edit" : 编辑侯用户信息；
'delete" : 删除一个用户；提示用户输入要删除的用户编号
"list" : 列出所有用户信息（包括用户编号、用户名称等）
"help" : 打印帮助信息；
"quit" : 退出程序