[进阶]C++: 类（2）

访问控制与封装

我们虽然为类定义了接口，但并没有任何机制强制用户使用这些接口。我们没有对类进行封装。用户可以直达Sales_data对象的内部并控制它具体实现。

• 定义在public说明符之后的成员在整个程序内可被访问
• 定义在private说明符之后的成员可以被类的成员函数访问，但不能被使用该类的代码访问，private封装了类的实现细节。
• 一个类里面可以包含多个说明符，说明符的有效范围直到下一个说明符为止。

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

class与struct 关键字

• class与struct的访问权限不同，使用struct关键字，则定义在第一个访问说明符之前的成员是public的；相反，使用class关键字，这些成员是private的。

友元

如果Sales_data的数据成员是private的，我们的read，print和add函数就无法正常编译了。怎么才能访问一个类的私有变量呢？

• 类可以允许其他类或函数访问他的非公有成员，方法是另其他类或函数成为他的友元。只需加一条friend关键字在开头。
• 友元声明只能出现在类定义的内部，但是在类内出现的位置不限。

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

类的其他特性

• 为了展示新的特性，需要定义一些相互关联的类，分别是Screen和windo_mgr。

class Screen{
public:
  typedef std::string::size_type pos;
//等价的写法
//using pos= std::string::size_type;
//
private:
  pos cursor =0;
  pos height =0,width =0;
  std::string contents;
};

• Screen类的成员函数

class Screen{
public:
  typedef std::string::size_type pos;
//等价的写法
//using pos= std::string::size_type;
//
public:
  Screen()=default;
  Screen(pos ht,pos wd,char c):height(ht),width(wd),
    contents(ht*wd,c){}
  char get() const {return contents[cursor];}
  inline char get (pos ht,pos wd) const;
  Screen &move(pos r,pos c);
private:
  pos cursor =0;
  pos height =0,width =0;
  std::string contents;
  pos height =0,width =0;
  std::string contents;
};

• 可以在类内定义inline，也可以在类外定义
• 最好只在类的外部定义inline，这样类更容易理解

inline
Screen &Screen::move(pos r,pos c)
{
  pos row =r*width;
  cursor=row+c;
  return *this;
}
char Screen::get(pos r,pos c) const
{
  pos row = r*width;
  return contents[row+c];
}

• 可变数据成员
  我们希望修改数据成员，即使在一个const成员函数内。可以通过在变量的声明中加入mutable关键字做到这一点。

class Screen
{
public:
  void some_member() const;
private:
  mutable size_t access_ctr;
};
void Screen::some_member() const 
{
  ++access_ctr;//可变
}

• 类数据成员的初始值
  最好的方式就是把这个默认值的声明成一个类内初始值

class window_mgr
{
 private:
  std::vector screens{Screen(24,80,' ')};
};

返回*this的成员函数

返回的是左值，意味着这些函数返回的是对象本身而非对象的副本。

class Screen
{
public:
  Screen &set(char);
  Screen &set(pos,pos, char);
};
inline Screen &Screen::set(char c)
{
  contents[cursor]=c;
  return *this;//将this对象作为左值进行传递
}
inline Screen &Screen::set(pos r, pos col,char ch)
{
  contents[r*width+col]=ch;
  return *this;//将this对象作为左值进行传递
}

myScreen.move(4,0).set('#');
//等价于
//myScreen.move(4,0);
//myScreen.set("#");

基于const的重载

class Screen
{
public:
    Screen &display(std::ostream &os)
    { do_display(os);return *this;}
    const Screen &display(std::ostream &os) const
    { do_display(os);return *this;}
private:
    void do_display(std::ostream &os) const {os << contents;}
};

Screen myScreen(5,3);
const Screen blank(5,3);
myScreen.set('#').display(count)//调用非常量版本
blank.display(cout);//调用常量版本

• 类的声明
  就像可以把函数声明赫定义分离出来一样，我们也能仅声明类而暂时不去定义它：

class Screen;

这种声明被称为前向声明，它向程序引入名字Screen并指明Screen是一种类类型。一旦类的名字出现，类型就被声明过
，因此我们可以允许包含指向自身的指针：

class Link{
  Link *a;
  Link *b;
};

类与友元之间的关系

class Screen 
{
friend class window_mgr;
};

如果一个类指定了友元类，则友元类的成员函数可以访问此类包括非公有成员在呢你的所有成员。

• 令成员函数成为友元

class Screen
{
friend void window_mgr::clear();
};

• 重载函数和友元

如果一个类想把一组重载函数声明成它的友元，他需要对这组函数中的每一个分别声明。

• 委托构造函数

class Sales_data {
public:
  Sales_data(std::string s,int c,double p):
    book(s),units_sold(c),revenue(c*p){}
  Sales_data():Sales_data("",0,0){}
  Sales_data(std::string s):Sales_data(s,0,0){}
  Sales_data(std::istream &is):Sales_data()
            {read(is,*this);}

在这个类中除了一个工造函数其他的都委托给了他们工作。

• 默认构造函数的作用

在实际中如果定义了其他构造函数，最好也提供一个默认构造函数。

• 隐式的类类型转换

在要求隐式转换的程序上下文中，我们可以通过将构造函数声明为explicit加以阻止：

class Sales_data{
 public:
    Sales_data() =default;
    Sales_data(const std::string &s,unsinged n,double p):
                      book(s),unit_sold(n),revenue(p*n){}
    explicit Sales_data(const std::string &s):book(s){}

};

• explicit 构造函数只能用于直接初始化
  当我们用explicit关键字声明构造函数时，他将只能以直接初始化的形式使用。而且编译器将不会再自动转哈云的过程中使用该构造函数。