C++ day16 类（一）（定义类，接口，封装，访问控制，C/S模型）

男娘i 2023-07-14 05:48 27阅读 0赞

学习本文的主题——类之前，我先简短回顾了一下之前的知识，尤其是即将在类中大量使用的引用，指针。毕竟之前接触的C和C++都还是过程性思维，只有用C写ADT和学JAVA时感受了一点点OOP，所以又兴奋又担心，担心学不清楚。果然，这一部分的内容看起来会比较抓不到点，虽然认认真真看了一大段，但是感觉没捕捉到核心观点和精准概念。但总算渐入佳境·····

### 文章目录 ###

*  靠类来实现OOP的思想
 *  类把抽象转换为用户自定义类型（把数据把操作数据的方法组合为一个整洁的包）
 *   *  怎么定义类
     *   *  类设计的第一步：提供类声明
         *  类设计第二步：实现类成员函数
         *  怎么创建和使用对象
     *  接口（一种共享框架，其实就是方法原型，一般放在头文件）
     *   *  类禁止公共用户访问类（只有接口是公有的），所以只能用类提供的接口来操作类的对象
     *  访问控制（关键字private public）
     *  封装：把抽象和细节分开，把细节单独放在一起
     *   *  封装示例1：数据隐藏（关键字 private）
         *  封装示例2：把类的函数原型和函数定义放在不同文件
     *  客户/服务器模型
     *  示例1 使用类的关键是了解成员函数的功能即可，无需钻研任何细节;把消息发送给对象

# 靠类来实现OOP的思想 #

oop是一种方法，一种设计理念，它强调以下几个理念，或者说OOP特性，我们要用C++，Java等语言编程的时候努力去实现这些理念（OOP的思想可以用于任何一种语言，思想和语言无关）

*  要抽象
 *  要封装，即要隐藏
 *  要多态
 *  要继承
 *  要重用代码

这些理念全部都是OOP的重点目标，在任何时候都要尽量实现他们

有没有很像在学马克思列宁主义，毛概一类的课，领导们提出的都是高度概括和抽象的理念，全国人民紧紧围绕这些简短精要的理念执行实践，妈呀我政治觉悟太高了

那具体怎么把这几个理念，特性组合起来，实现到程序里面呢？

靠的就是累，哦不，是类。

即OOP处于高层提供思想，类扎根基层进行实践。猿们就是勤奋的劳动人民，用类工具一砖一瓦地实现OOP构建的宏伟蓝图。

那么类又是怎么实现抽像，封装，隐藏等特性的呢？

# 类把抽象转换为用户自定义类型（把数据把操作数据的方法组合为一个整洁的包） #

也就是说，类是通过定义一个新类型，来实现抽象，封装，隐藏等OOP特性的。

所以类这个工具，就是用来定义一个特殊的新类型的，我们要把所有的需要编程的问题抽象起来，然后试图设计一个新类型来表示这个问题的方方面面的要求。即把数据和方法组合为一个单元，这就是类的本质和类最吸引人的特性。

“类”就是“类型”，说全了，就是“抽象数据类型”，即就是ADT。只不过专门定义和讲解类，就只说“类”一个字，并没怎么说他和ADT的关系，但是你仔细观察，他们就是一回事！没啥玄妙和困惑的。

另外，之前说C++的结构可以有成员函数但C不能，而且成员函数在类中使用的更多，C的ADT也是用结构定义的，所以总结起来，类是由结构衍生而来，是更高级的结构，增加了成员函数，私有公有等访问控制，以及其他特性。

> 类和结构的区别：
> 
> 1.  C++还是一般只用结构表示纯数据对象，而不会在结构中使用成员函数；
> 2.  结构的默认访问类型是public，而类的默认访问类型却是private，所以类中不显式用private也属于私有部分。

## 怎么定义类 ##

从两个方面入手，非常规范，整整齐齐

*  数据成员：以数据成员的方式来描述数据部分。声明这些数据成员。
 *  函数成员：以方法（即成员函数）的方式描述公有接口/公共接口。声明这些函数成员，并定义这些函数成员。

数据和方法的声明描述了类的蓝图，概貌

方法的具体定义则是类的实现细节

概貌细节，有没有想到小波, 哈哈

### 类设计的第一步：提供类声明 ###

类声明类似于结构声明。类声明只是描述对象的形式，样子，外貌，有几个数据成员，分别什么类型，有哪些方法等等，但并不创建对象。

数据成员通常被放在私有部分，成员函数被放在公有部分，所以典型的类声明格式：  
![在这里插入图片描述][20200315162159646.png]  
其中公有部分就是公有接口，即类设计的抽象部分。

所以C++通过类工具，实现了抽象，数据隐藏，封装等OOP精神。

### 类设计第二步：实现类成员函数 ###

注意程序中**类的成员函数的定义都必须用作用域解析运算符标识函数所属的类**。  
如  
![在这里插入图片描述][20200315162520202.png]  
这说明Retort()函数不仅是char \*类型的函数，还是一个属于Bozo类的char \*函数。函数的全名或者限定名是Bozo::Retort(), 而名称Retort()只可以在类方法的代码中使用

这还说明，名称Retort的作用域是整个Bozo类，即类方法名具有类作用域。如果在类方法和类声明之外的地方使用，则必须加作用域限定运算符。

类定义中的私有部分的这句代码，值得说道说道。

void set_tot(){ total_val = shares * share_val;}

在类声明中一般是只写原型，，但是如果函数定义十分短小，可以做为内联函数，那就可以直接在类的声明中直接写定义，这时候编译器会根据**改写规则**（rewrite rule）,先把类声明中的定义替换为原型，然后在类声明后方加上刚才函数的定义，并使用inline关键字将其定义为内联函数。

即：

//stock.h
    #ifndef STOCK_H_
    #define STOCK_H_
    #include <string>
    
    class Stoch //类声明 class declaration
    //一个常见但不通用的约定：类名首字母大写
    { 
    private://可不写,类对象的默认访问控制就是private
        std::string company;
        long shares;
        double share_val;
        double total_val;
        //可以在成员函数中使用数据成员
        //定义位于类声明中的函数自动成为内联函数，无需关键字inline
        void set_tot(){ total_val = shares * share_val;}
    
    public:
        void acquire(const std::string & co, long n, double pr);
        void buy(long num, double price);
        void sell(long num, double price);
        void update(double price);
        void show();
    };//像结构体声明一样，有分号
    
    #endif // STOCK_H_

相当于

//stock.h
    #ifndef STOCK_H_
    #define STOCK_H_
    #include <string>
    
    class Stoch //类声明 class declaration
    //一个常见但不通用的约定：类名首字母大写
    { 
    private://可不写,类对象的默认访问控制就是private
        std::string company;
        long shares;
        double share_val;
        double total_val;
        //可以在成员函数中使用数据成员
        //定义位于类声明中的函数自动成为内联函数，无需关键字inline
        void set_tot();
    
    public:
        void acquire(const std::string & co, long n, double pr);
        void buy(long num, double price);
        void sell(long num, double price);
        void update(double price);
        void show();
    };//像结构体声明一样，有分号
    
    inline void Stock::set_tot()
    { 
    total_val = shares * share_val;
    } 
    #endif // STOCK_H_

总之，在类声明中直接写函数定义的函数自动成为内联函数。

### 怎么创建和使用对象 ###

之前说了，类之于对象就像是类型之于变量。并且C++设计类的时候的目标是要让类的使用和int, char等内置类型尽量相同。毕竟大家都是类型嘛，只不过类时最高级的自定义的复合类型而已。

所以创建对象就和以前创建变量一样，有两个办法：

*  声明类变量
 *  用new为类对象分配存储空间

且在对象的使用上，也和普通变量相似，比如：

*  把对象作为函数的参数和返回值
 *  把一个对象赋给另一个
 *  相似类型的对象之间可以进行自动类型转换（这个比较难）

注意，类的**不同对象都有自己独立的一套数据成员**，即每个对象的数据成员都有自己的存储空间；**但是类的方法却只有一个副本**，不管哪个对象调用A方法，都是使用那套代码，不会把方法也复制副本给每个对象。

## 接口（一种共享框架，其实就是方法原型，一般放在头文件） ##

接口用于两个系统的交互。就像是桥梁，牵扯到两个人两方势力。

之前在用C写ADT时，接口是ADT的方法的函数原型，因为它描述了程序员使用这个ADT时要输入的参数数目和类型以及程序员会得到的返回值。所以提供了使用这个ADT的程序员和ATD的交互。

类中也一样，只是在类中我们只说公有接口。只有public标识的成员函数组成了类的公共接口。private成员函数并不是公共接口的一部分。

在类中，接口是类的方法的原型（只说方法当然也没错啦）。用于实现类的对象和使用类的程序这二者之间的交互（即接口牵扯的两方势力分别是对象和程序）。既然是原型，当然一般是放在头文件了，而具体的定义放在源代码文件，这是最为经典的做法，之前一直也是这么做的。

所以我们要在接口（类方法）中写和对象交互的代码，从而使得程序能够使用类的对象。

那为啥是“公有”呢？  
因为是类外界的函数或者方法要使用类的对象完成一些事情，只要你想用，你就可以用，所以是面向公众的，public的。但是注意只有接口是公有的，面向公众的，但是类对象可不是！类禁止公众访问类的对象！

### 类禁止公共用户访问类（只有接口是公有的），所以只能用类提供的接口来操作类的对象 ###

使用的过程中，不会直接打开对象，操作对象，而是通过类提供的方法（接口）来间接获取结果。即每个类的对象还是要用这个类自己的方法来操作处理，绝不会由别的类或者程序操作。

比如，你要计算一个string类对象包含了多少个字符，由于类禁止公共用户访问类，所以你不能拿着这个对象来吭哧吭哧地算，而是要使用string类自己的size()方法。这个size()方法就是程序/用户和string类对象之间的一个公有接口。  
再比如使用预定义对象cin, 不是直接和cin对象交互让他读取输入，其实是使用了istream类的方法，比如get(),getline()等等。

总之，要想使用一个类，你就只需要了解他的公有接口；  
要想自己创建一个类，那就必须创建他的公有接口 。

## 访问控制（关键字private public） ##

访问控制可以控制程序的访问权限

访问控制关键字有三：private， public，protected。protected和类的继承有关，后面再说。

使用类对象的程序都可以访问public部分，public标识的成员函数组成了类的公共接口。  
但是只能通过公有成员函数或者友元函数来访问private私有成员。这就是数据隐藏。但是类声明中可以不用private，因为默认private，所以只需要显式写public即可，不是public的就是private。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0_size_16_color_FFFFFF_t_70]  
因此公有成员函数是程序和私有成员的桥梁，是对象和程序的接口。

本文顶上就说了，数据隐藏也是OOP的重要目标之一，所以能隐藏就隐藏，所以数据成员一般要放在私有部分。但是成员函数没法也全部隐藏，因为外部程序得访问他们呀。但是也可以把一部分成员函数放在私有部分，这样外部程序无法调用他们，只有类的公有成员函数可以调用。

而且，**公有成员函数中，使用了私有函数来处理的部分，并不算公有接口的实现细节哦。**

## 封装：把抽象和细节分开，把细节单独放在一起 ##

设计类应尽量把公有接口（抽象）和实现细节分开，且把细节放在一起

因为**抽象和细节分开可以带来实在的好处：使得程序的维护很容易**。即如果你把细节从接口中分离出来，那么以后如果需求变了但是接口不变，你就只需要改一下实现；再或者你找到了更好的实现方案，于是你可以直接改实现的代码，接口仍然不变。接口不变，则之前的代码就还是全部有效，不会影响那些陈年代码。

### 封装示例1：数据隐藏（关键字 private） ###

把实现细节隐藏在私有部分

数据隐藏是说**防止程序直接访问数据**，所以把数据放在类的私有部分就是一种隐藏办法，因为程序不能直接访问私有成员，只能通过公有成员函数间接访问。

数据隐藏还可以让开发者无需了解数据在类的内部是如何表示的。

### 封装示例2：把类的函数原型和函数定义放在不同文件 ###

这很好理解，原型就是抽象，定义是细节，把他们分开，并且细节放在一起，所以完全符合封装强调的两个点

但是C++并不是简单地把二者分开，像之前那样一个在头文件一个在源码文件就结了。  
而：

*  要用class关键字，即把数据和方法的声明都放到类声明中，使得类的描述是一个整体。
 *  并且还要把数据设置为私有成员，使得数据只可以被授权函数访问。  
    所以C语言直接访问结构成员是违背了OOP精神的，但是并不违反C语言的规则。在C++直接访问类的数据成员会报错。

## 客户/服务器模型 ##

OOP常常用这个模型来讨论程序的设计。

客户：在这里指的是**使用类的程序**。  
服务器：在这里指的是**类的声明以及类的方法定义**。

想要表达的意思是：

客户只可以用公有方式定义的接口来使用服务器，即**客户唯一需要做的事情就是学会怎么使用这个接口**。

而服务器的责任是确保服务器可以根据这个接口准确执行，**服务器设计人员只可以更改类设计的实现细节，不能改接口**！！所以服务器的更改不会对客户的行为造成任何影响。

其实很多东西都是这个模型，比如你只需要学会按电脑的开机键，不需要了解内部到底咋开机，你只需要使用键盘鼠标显示器，你不需要了解他们的内部原理。因为你只是客户，这些东西是公有接口，而实现细节是被厂家封装起来的。

## 示例1 使用类的关键是了解成员函数的功能即可，无需钻研任何细节;把消息发送给对象 ##

主函数只是用于测试类的设计而已哦。若运行情况和预期相同，则说明类的设计没问题。

//stock.h
    #ifndef STOCK_H_
    #define STOCK_H_
    #include <string>
    
    class Stock //类声明 class declaration
    //一个常见但不通用的约定：类名首字母大写
    { 
    private://可不写,类对象的默认访问控制就是private
        std::string company;
        long shares;
        double share_val;
        double total_val;
        //可以在成员函数中使用数据成员
        //定义位于类声明中的函数自动成为内联函数，无需关键字inline
        void set_tot(){ total_val = shares * share_val;}
    
    public:
        void acquire(const std::string & co, long n, double pr);
        void buy(long num, double price);
        void sell(long num, double price);
        void update(double price);
        void show();
    };//像结构体声明一样，有分号
    
    #endif // STOCK_H_

//Stock.cpp
    #include <iostream>
    #include "stock.h"
    //类的成员函数的定义都必须用作用域解析运算符标识函数所属的类
    void Stock::acquire(const std::string & co, long n, double pr)
    { 
        //首次购买
        company = co;
        if (n < 0)
        { 
            std::cout << "Number of shares can't be negative; "
                      << company << " shares set to 0.\n";
                      shares = 0;
        }
        else
            shares = n;
        share_val = pr;
        set_tot();//是私有成员函数，是实现细节的一部分，不属于公有接口
        //所以：不属于公有接口的实现函数可以设置为私有成员函数
    }
    
    void Stock::buy(long num, double price)
    { 
        //增加持有的股份
        if (num < 0)
        { 
            std::cout << "Number of shares purchased can't be nagative. "
                      << "Transaction is aborted.\n";
        }
        else
        { 
            shares += num;
            share_val = price;
            set_tot();
        }
    }
    
    void Stock::sell(long num, double price)
    { 
        //减少持有的股份
        if (num <0)
        { 
            std::cout << "Number of shares sold can't be negative. "
                      << "Transaction is aborted.\n";
        }
        else if (num > shares)
        { 
            std::cout << "You can't sell more than you have! "
                      << "Transaction is aborted!\n";
        }
        else
        { 
            shares -= num;
            share_val = price;
            set_tot();
        }
    
    
    }
    
    void Stock::update(double price)
    { 
        share_val = price;
        set_tot();
    }
    
    void Stock::show()
    { 
    //使用了ostream类的一些控制格式的成员函数
        using std::cout;
        using std::ios_base;
        //set format to #.###
        //ios_base类是在名称空间std中定义的
        //fmtflags是ios_base类中定义的一个类型
        //orig储存了所有标记，便于后面重置floatfield
        //floatfield包含定点表示法和科学表示法标记
        ios_base::fmtflags orig =
            cout.setf(ios_base::fixed, ios_base::floatfield);//设置对象的一个标记，命令cout使用定点表示法
        std::streamsize prec = cout.precision(3);//cout使用定点表示法，并显示3位小数
    
        cout << "Company: " << company
             << " Shares: " << shares << '\n'
             << " Share Price: $" << share_val;
    
        //set format to #.##
        cout.precision(2);
        cout << " Total Worth: $" << total_val << '\n';
    
        //restore original format重置格式信息，使其恢复到调用前的状态，避免影响后续输出
        cout.setf(orig, ios_base::floatfield);
        cout.precision(prec);
    }

//main.cpp
    #include <iostream>
    #include "stock.h"
    
    int main()
    { 
        Stock fluffy;//用声明类对象的方式创建一个对象
        fluffy.acquire("NanoSmart", 20, 12.50);//用成员运算符调用类方法
        fluffy.show();
        fluffy.buy(15, 18.125);
        fluffy.show();
        fluffy.sell(400, 20.0);
        fluffy.show();
        fluffy.buy(300000, 0.125);
        fluffy.show();
    
        return 0;
    }

输出

Company: NanoSmart Shares: 20
     Share Price: $12.500 Total Worth: $250.00
    Company: NanoSmart Shares: 35
     Share Price: $18.125 Total Worth: $634.38
    You can't sell more than you have! Transaction is aborted!
    Company: NanoSmart Shares: 35
     Share Price: $18.125 Total Worth: $634.38
    Company: NanoSmart Shares: 300035
     Share Price: $0.125 Total Worth: $37504.38

主函数中，fluffy.buy(15, 18.125);在OOP中，这种函数调用被称为将buy消息发送给对象fluffy。

[20200315162159646.png]: /images/20230529/c539b0656fd44c69bb49682297cc8083.png
[20200315162520202.png]: /images/20230529/bb34026214e746c89f3df48ec1f19e28.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0_size_16_color_FFFFFF_t_70]: /images/20230529/6c3034f1504d4bc4b32d563e5549a5da.png