C++类：访问控制与封装、友元初识

前提

有Sales_data 类的定义以及非成员接口函数代码

struct Sales_data {
    std::string isbn() const { return bookNo; }		// 返回 isbn 编号
    Sales_data& combine (const Sales_data&);		// 模拟 += 运算
    double avg_price() const;
    std::string bookNo;
    unsigned units_sold = 0;						// 表示某书的销量
    double revenue = 0.0;							// 表示某书的总收入
};
// Sales_data 的非成员接口函数
Sales_data add(const Sales_data&, const Sales_data&);
std::ostream &print(std::ostream&, const Sales_data&);
std::istream &read(std::istream&, Sales_data&);

// 具体实现
istream &read(istream &is,Sales_data &item) {
    double price = 0;							// price 表示某书单价
    is >> item.bookNo >> item.units_sold >> price;
    item.revenue = price * item.units_sold;
    return is;
}

ostream &print(ostream &os,const Sales_data &item) {
    os << item.isbn() << " " << item.units_sold << " "
        << item.revenue << " " << item.avg_price();
    return os;
}
Sales_data add(Sales_data &lhs,Sales_data &rhs) {
    Sales_data sum = lhs;
    sum.combine(rhs);
    return sum;
}

访问控制与封装

​ 在没有使用访问控制符时，用户可以直达类的内部并且控制具体的实现细节。所以在 C++ 中，使用访问控制符来加强类的封装性。

• public 说明符之后的成员在整个程序都可以被访问，public 成员定义接口
• private说明符之后的成员可以被类的成员函数访问，但是不能使用该类的代码访问，private部分封装(隐藏了)类的实现细节

新增访问说明符后的 Sales_data 代码：

class Sales_data {
public:
    Sales_data() = default;
    Sales_data(const std::string &s,unsigned n,double p):
    		bookNo(s), units_sold(n), revenue(p * n) { }
    Sales_data(const std::string &s): bookNo(s) { }
    Sales_data(std::istream &);
    std::string isbn() const { return bookNo; }
    Sales_data &combine(const Sales_data &);
private:
    double avg_price() const {
        return units_sold ? revenue / units_sold : 0;
    }
    std::string bookNo;
    unsigned units_sold = 0;
    double revenue = 0.0;
};

每一个类可以有 0 个或者多个访问控制符。

封装的好处

• 确保用户代码不会无意间破坏封装对象的状态
• 被封装的类的具体实现细节可以随时更改，而不需要调整用户级别的代码

使用 class 和 struct 关键词

​ 其实 class 和 struct 没有太大区别。唯一的区别是 strcut 中，第一个访问控制符前面的成员默认是 public，而 class 第一个访问控制符前面默认是 private。所以如果所有成员是 public，就可以直接使用 struct，所有成员是 private 可以直接使用 class。

友元

​ 让我们回顾以上 add、read 以及 print 函数，它们是类接口的一部分，而不是类的成员。但函数内容都有直接访问类成员(包括 private)，那么肯定是无法编译的。

​ 为了解决这个问题，类可以允许其他类或者函数访问它的非 public 成员，方法是令它们称为该类的友元。如果一个函数想作为类的友元，只需要再函数返回类型前加上 friend 关键字即可。

​ 那么以上代码可以这样更改：

class Sales_data {
// 做友元声明
    friend Sales_data add(const Sales_data &,const Sales_data &);
    friend std::istream read(std::istream&, Sales_data &);
    friend std::ostream print(std::ostream&, const Sales_data &);
// 剩下的与之前一致
public:
    Sales_data() = default;
    Sales_data(const std::string &s,unsigned n,double p):
    		bookNo(s), units_sold(n), revenue(p * n) { }
    Sales_data(const std::string &s): bookNo(s) { }
    Sales_data(std::istream &);
    std::string isbn() const { return bookNo; }
    Sales_data &combine(const Sales_data &);
private:
    double avg_price() const {
        return units_sold ? revenue / units_sold : 0;
    }
    std::string bookNo;
    unsigned units_sold = 0;
    double revenue = 0.0;
};
// Sales_data 接口的非成员组成部分的声明
Sales_data add(const Sales_data &,const Sales_data &);
std::istream read(std::istream&, Sales_data &);
std::ostream print(std::ostream&, const Sales_data &);

友元的具体出现位置不限，出现在类定义的内部即可。但是一般都是在类定义开始或者结束前的位置集中声明友元

友元的声明

​ 友元声明只是指定访问权限，不是通常意义上的函数声明。如果希望类的用户能够调用某个友元函数，就必须在友元声明之外再专门对函数进行一次声明。

一些编译器允许在尚无友元函数的初始声明的情况下就调用它。但是最好还是提供一个独立的函数声明。这样即使换了一个强制要求初始声明的编译器，可以不用修改代码。

此后还会介绍更多关于友元的知识