【C++程序员必修第一课】C++基础课程-16:class 类(上)

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" : 退出程序

附录:在线视频课程

【C++程序员必修第一课】C++基础课程

你可能感兴趣的:(1024程序员节,C++类,C++,class,类,class类,C++基础课程)