chapter-7

// chapter-7.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include<iostream>
#include<string>
#include<vector>

using namespace std;

class Sales_data                                    //第一个访问说明符之前的成员属性由class和struct决定，class默认private，struct默认public
{
    // 定义友元，外部函数可以访问非共有成员（protected，private）
    friend Sales_data add(const Sales_data &lhs, const Sales_data &rhs);
    friend ostream &print(ostream &os, Sales_data &item);   //声明为其友元函数，可以访问非共有成员。（友元声明并不是一个完整意义的函数声明！）
    friend istream &read(istream &is, Sales_data &item);

public:                                             //都可访问

    //构造函数
    Sales_data() = default;                         //只有当类没有声明任何构造函数时，才会自动生成默认构造函数
    Sales_data(const string &s) :bookNo(s) {};
    Sales_data(const string &s, unsigned n, double p) :bookNo(s), units_sold(n), revenue(p*n) {};
    Sales_data(istream &);

    string isbn() const { return bookNo; };         //默认使用this，等价于this->bookNo；使用const改变this指针为指向常量（底层const）的常量指针（this默认为常量指针（顶层const）），提高函数的灵活性！指向常量的常量指针函数，才可以使常量对象调用普通成员函数！此函数有前提条件，在函数体内不会改变this所指向的对象！
    Sales_data &combine(const Sales_data&);
    double avg_price() const;
//protected:                                            //外部不可访问，继承可以访问！

  private:                                          //外部和继承不可访问，使用封装有2个重要的好处：1、确保用户不会无意间破坏封装对象；2、被封住的类具体实现细节可以随时修改，而无须调整用户级别的代码。
    string bookNo;
    unsigned units_sold = 0;
    double revenue = 0.0;
};

//Sales_data非成员接口函数
Sales_data add(const Sales_data &lhs, const Sales_data &rhs);
ostream &print(ostream &os, Sales_data &item);          //函数声明时候，形参等必须相同！
istream &read(istream &is, Sales_data &item);

double Sales_data::avg_price()const
{
    if (units_sold)
        return revenue / units_sold;
    else
    {
        return 0;
    }
}

Sales_data& Sales_data::combine(const Sales_data &rhs)
{
    units_sold += rhs.units_sold;
    revenue += rhs.revenue;
    return *this;                                       //返回调用该函数的对象。
}

istream &read(istream &is, Sales_data &item)
{
    double price = 0;
    is >> item.bookNo >> item.units_sold >> price;
    item.revenue = price*item.units_sold;
    return is;
}

//Sales_data(istream &)构造函数
Sales_data::Sales_data(istream &is)
{
    read(is, *this);
}

ostream &print(ostream &os, Sales_data &item)
{
    os << item.isbn() << " " << item.units_sold << " " << item.revenue << " " << item.avg_price();
    return os;
}

Sales_data add(const Sales_data &lhs, const Sales_data &rhs)
{
    Sales_data item = lhs;
    item.combine(rhs);
    return item;
}

class Screen
{
    friend class window_mgr;                //定义window_mgr为screen的友元类！,则window_mgr中的函数可以访问screen中的非公有成员！
                                            //友元关系不存在传递关系，每个类定义自己的友元！
public:
    using pos = string::size_type;
    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;          //类内成员函数是自动的inline，也可以用inline直接声明内联函数。
    Screen &move(pos r, pos c);

    Screen &set(char c)
    {
        contents[cursor] = c;
        return *this;
    }
    Screen &set(pos r, pos col, char ch)            //返回*this对象的引用（即对象本身）
    {
        contents[r*width + col] = ch;
        return *this;
    }

    Screen &displsy(ostream &os)                //只能传入非常量版本，返回类型为非常量的引用！
    {
        do_display(os);
        return *this;
    }
    const Screen &displsy(ostream &os) const            //如果为const成员函数，则返回类型将是常量！？？？？有什么问题没？？？
    {
        do_display(os);
        return *this;
    }

    void some_member()const;

private:
    pos cursor = 0;
    pos height = 0, width = 0;
    string contents;

    mutable pos access_ctr = 0;

    void do_display(ostream &os) const { os << contents; }
};

void Screen::some_member() const
{
    ++access_ctr;               //变量声明为可变数据成员，即使在const成员函数，还是可以改变access_ctr的值！
}

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];
}

class window_mgr
{
public:
    void clear(vector<Screen>::size_type i)
    {
        Screen &s = screens[i];
        s.contents = string(s.height*s.width, ' ');
    }
private:
    vector<Screen> screens{ Screen(24,80,' ') };            //类作为类内数据成员时，初始化方法！
};

class ConstRef
{
public:
    ConstRef() = default;
    ConstRef(int i):ii(i),ci(i),ri(i){}             //引用和const必须初始化！建议养成构造函数初始化的习惯！
private:
    int ii;
    const int ci;
    int &ri;
};

class Data
{
public:
    //非委托构造函数
    Data(string s,string::size_type i,double p):item(s),cnt(i),price(p){}
    //委托构造函数
    Data():Data(" ",0,0){}
    Data(string s):Data(s,0,0){}
    Data(istream &is) :Data() { is >> item; }
private:
    string item;
    string::size_type cnt=0;
    double price=0.0;
};
//聚合类，所有成员都是public，没有定义任何构造函数，没有类内初始值，没有基类也没有virtual函数！使用花括号进行成员初始化
struct Data
{
        int ival;
        string s;
}
Data val9={0,"Anna"};
int main()
{
    Sales_data s1(cin);             //使用构造函数Sales_data(istream &)创建对象


    Screen myscreen(5, 3,' ');
    const Screen myscreen_const(5,3,' ');       //常量screen对象。
    myscreen.set('#').displsy(cout);
    cout << endl;
    myscreen_const.displsy(cout);               //调用常量版本函数

    //Data obj1();
    //Data obj2;                                直接使用这种声明，定义一个默认初始化的对象！

    cin.ignore();
    return 0;
}

//类基本思想是数据抽象和封装。数据抽象依赖于接口和实现，接口包含用户所能执行的操作，实现包含类的数据成员、函数；封装实现了接口和实现的分离，用户只可以访问接口，而无法访问实现！
//类的定义分两步，1、编译成员声明；2、直到类全部可见后才编译函数体。
//类的构造函数，如果成员对象为const或者引用，则必须进行初始化！
//类的静态成员，所有类对象共用，可以通过对象、引用或者指针访问它~在类内声明，在类外定义！
//优秀的设计者应该关注那些有可能使用该类的程序员的需求，作为一个设计良好的类，既要有直观且易于使用的接口，也必须具备高效的实现过程！

const在函数形参，实参，返回类型的区别？
const int &i，常量引用形参！，在类内const成员函数为常量返回类型！（常量版本的函数），程序有必要同时定义一个非常量版本的函数！