CH15 面向对象程序设计

面向对象程序设计是基于三个基本概念的：数据抽象、继承和多态。

第7章介绍了数据抽象的知识，简单来说，C++通过定义自己的数据类型来实现数据抽象。

数据抽象是一种依赖于接口和实现分离的编程技术：类的设计者必须关心类是如何实现的，但使用该类的程序员不必了解这些细节。

 封装是一项将低层次的元素组合起来形成新的、高层次实体的技术！函数和类都是封装的具体形式。其中类代表若干成员的聚集。大多数（设计良好的）类类型隐藏了实现该类型的成员。

一个简单的PersonInfo类，包含类成员、成员函数、构造函数

#include <string>

using namespace std;
class PersonInfo {
public:
    PersonInfo();
    PersonInfo(string& name):strname(name),age(0){}
    string getName() { return strname; }
    int getAge() { return age; }

private:
    string strname;
    int age;
};

2.访问控制符 

程序所有部分均可访问public成员

只有在类内部才能访问类的private成员，即类的private成员对外是不可见的。

3.成员函数可以被重载，上面的PersonInfo类就定义了两个版本的构造函数，被重载的成员函数之间的参数数量和类型不能完全相同，因为重载的成员函数被调用时会根据参数数量和类型进行匹配。重载构造函数的的原理和调用和普通成员函数的重载是一样的。

4.类的声明和定义

一个源文件中一个类只能定义一次。

可以只声明一个类，而先不定义它，一般，这种情况是有关联的类

class StrBlobPtr;
class StrBlob {
    friend class StrBlobPtr;
public:
    StrBlob();
    StrBlob(initializer_list<string>il){}
    //其它成员函数
    StrBlobPtr begin();
    StrBlobPtr end();
private:
    //私有成员
};

但是只声明没有定义的类，不能使用，即：不能定义该类的对象，因为生命之后，定义之前，StrBlobPtr是不完全的类，并不知道这个类有哪些成员。不完全类型只能用于定义指向该类型的指针及引用,或者用于声明(而不是定义)使用该类型作为形参类型或返回类型的函数。，如上面的begin()和end()函数。

5.类对象

定义一个类后，就可以定义该类的对象，可以认为对象是类的实体，类通过对象实现一系列操作。定义对象时，会为其分配内存空间，定义类型时并没有进行存储分配。

//两种定义对象的方式都可以，一般是第一种
PersonInfo a;
class PersonInfo b;

6.this指针

成员函数有一个隐形形参，指向该类对象的一个隐形形参，即this指针，this的形参是由编译器定义的，与成员的当前对象绑定在一起

class Screen {
public:
    typedef string::size_type pos;//此处类为自己定义了一个局部类型，使用typedef为string::size_tyoe 定义了个别名
    //为类做了一个更好的抽象,
    Screen() = default;
    Screen(pos ht, pos wd,char c):height(ht),width(wd),contents(ht*wd,c){}//define constructor and initizalize
    char get()const { return contents[cursor]; }
    inline char get(pos ht, pos wd)const;//declare operator member function
    Screen &move(pos r, pos c);//Note：此处返回的是引用，该引用指向执行操作的那个对象
    //add some function to set the char in the position pointed by the cursor
    //和move()一样，set成员的返回值是调用set对象的引用，返回引用的函数是左值的
    Screen &set(char);
    Screen &set(pos, pos, char);
private:
    pos cursor = 0;
    pos height = 0, width = 0;
    string contents;
};

//define move()
//勒种一些规模较小是函数适合被声明为内联函数，类内部的默认自动是inlien 的。
inline Screen &Screen::move(pos r,pos c)
{//函数返回调用自己的对象，使用this 来访问该对象
    pos row = r*width;//cacculate the position of the row
    cursor = row + c;//move the cursou to the pointed column in the row
    return *this;//return the object

}

char Screen::get(pos r, pos c)const
{
    pos row = r*width;
    return contents[row + c];
}
inline Screen& Screen::set(char c)
{
    contents[cursor] = c;
    return *this;//返回的是this指向的对象，将this对象作为左值返回
}
//重载的set()函数
inline Screen& Screen::set(pos r, pos col, char ch)
{
    contents[r*width + col] = ch;
    return *this;
}
int main()
{
    
    Screen myScreen;
    
    myScreen.move(4, 0).set('*');//这句相当于下面两句，
    myScreen.move(4, 0);
    myScreen.set('*');//，
    system("pause");
    return 0;
}

Note: set()成员不能定义为const 的，因为set()返回的是调用set()对象的引用，返回的是左值，而左值必须是可以修改值的，不能是const 的

下面我们定义一个函数从const 成员返回*this

 在普通的非const成员函数中,this的类型是一个指向类类型的const指针。可以改变this所指向的值,但不能改变this所保存的地址。在const成员函数中,this的类型是一个指向const类类型对象的const指针。既不能改变this所指向的对象,也不能改变this所保存的地址。

    不能从const成员函数返回指向类对象的普通引用。const成 员函数只能返回*this作为一个 const引用。

定义一个display 成员打印出Screen的内容，只是显示Screen的内容不需要改变，因此将const定义为一个const成员，此时this 是一个指向const的指针，*this 就是const对象 ，所以display的返回类型应该是const Screen&,但是，如 如果令display返回一个const引用，则我们不能把display嵌入到一组动作的序列中

此时若用display返回的对象调用set()成员，就会发生错误，，上面说了set成员为什么不能设为常量、

所以下面调用是错误的

myScreen.dipaly(cout).set('#');

Note：一个const成员函数如果以引用方式返回*this,那么它的返回类型将是常量引用。所以定义一个非const的display成员

此处注意，定义了一个小的私有成员，do_play(),看似没简化操作，实则，这样的小程序段是非常有用的，关于这样公共代码使用私有功能函数的建议，课本P248有详细说明

class Screen {
public:
    //其它以定义的public成员
    const Screen &dipaly(ostream& os)const { do_display(os); return *this; }
    Screen& dispaly(ostream&os) { do_display(os); return *this; }
private:
    //其它以定义的prvate成员
    void do_display (ostream &os)const { os << contents; }
};

7.类作用域

名字查找与类的作用域

类的定义分两步

1.编译成员的声明

2.直到类全部可见后才编译函数体

编译器处理完类中的全部声明后才会处理成员函数的定义

 OOP概述

1.OOP核心思想是数据抽象，继承和动态绑定，使用数据抽象可以将类的接口与实现分离，使用继承可以定义相似的类型并对其相似关系建模；使用动态绑定，可以在一定程度上忽略相似类型的区别，以统一方式使用它们的对象

2.定义基类和派生类

其中Quote类是基类，Bulk_quote类是派生类。派生类的构造函数必须重新写过，不能继承。（因为毕竟两个类的类名都不一样，不可能构造函数继承）只继承其他的成员函数和成员变量。

派生类可以覆盖基类的虚函数，但是也可以选择不覆盖（即直接使用父类的函数版本）

每个类控制它自己的成员的初始化过程，派生类初始化成员时，对于从父类继承来的成员必须使用父类的构造函数进行初始化，对于自己新增加的成员，调用自己的构造函数初始化

Note：基类通常都应该定义一个虚析构函数，即使该函数不执行任何实际操作也是如此

#include <string>
//#include <cstddef>
#include <iostream>
using namespace std;
//基类
class Quote {
public:
    //将默认构造函数声明为default，则要求编译器为嗯合成默认构造函数
    Quote() = default;
    //重载constructor
    Quote(const string &book,double sales_price):bookNo(book),price(sales_price){}
    string isbn()const { return bookNo; }
    //返回某种书的销售总额
    //派生类会根据不同情形重写该函数，所以定义为虚函数
    virtual double net_price(size_t n)const { return n*price; }
    virtual ~Quote() = default;
private:
    string bookNo;
protected:
    double price = 0.0;
};
//派生类，从基类Quote那里继承了isbn()和bookNo和price，重新定义了net_price()函数
//新增加了min_qty 和discount 成员
class Bulk_quote:public Quote {
public:
    Bulk_quote() = default;
    Bulk_quote(const string&, double, size_t, double);
    double net_price(size_t)const override;
private:
    size_t min_qty = 0;//可以使用指定折扣的最低数量
    double discount = 0.0;//折扣
};
Bulk_quote::Bulk_quote(const string& book, double p, size_t qty,double disc):
    Quote(book,p),min_qty(qty),discount(disc)
{
  //注意初始化列表中对成员bookNo 和price的初始化，不是像之前那样bookNo(book),price(p)
 //进行初始化，而是调用基类的构造函数进行初始化
}
double Bulk_quote::net_price(size_t cnt)const
{
    if (cnt >= min_qty)
        return cnt*price*(1 - discount);
    else
        return cnt*price;
}
//dynamic binding
double print_total(ostream &os, const Quote &item, size_t n)
{
    //根据传入的item形参的对象类型调用net_price()
    double ret = item.net_price(n);
    os << "ISBN: " << item.isbn() <<'	'<< "#sold: " << n << " total due： "
        << ret << endl;
    return ret;
}
int main()
{
    Quote item("978-7-121-31092-8", 65);//调用基类构造函数
    Bulk_quote bulk("978-7-121-31092-8", 65, 20, 0.2);//call the constructor of sub class
    //bookA.net_price(20);
    //Quote item;//基类对象
    //Bulk_quote bulk;//派生类对象
    
    Quote *p =&item;
    p->net_price(40);//dynamic binding
//    Quote base;
//    Bulk_quote subcls;
    print_total(cout, item, 20);
    print_total(cout, bulk, 20);
    system("pause");
    return 0;
}

继承与静态成员

如果基类有一个静态成员，那么基类和所有派生类（包括派生类的派生类）都共同拥有这仅有的一个静态成员。并且，对该成员的访问控制与非静态成员的访问控制方式一样，即，如果是private的，则派生类无权访问，，如果是可访问的，则既可以通过基类使用它，也可通过派生类使用它。

     

class Base {
public:
    static void statmem();//static member
};
class Derived :public Base {
    void f(const Derived&);
};

void Derived::f(const Derived& derived_obj)
{
    Base::statmem();//correct:difine in Base
    Derived::statmem();//correct: Derived derived it from Base
    derived_obj.statmem();//correct:visit it throgh the object of Derived
    statmem();//correct: visit it through object of pointed by this 
}

类型转换与继承

可以将基类的指针或引用绑定到派生类对象上（上面Quote例子中的63,64行）：当使用基类引用（或指针）时，实际上我们并不清楚该引用（指针）所绑定的真实类型，该对象可能是基类的对象，也可能是派生类对象。

静态类型在编译时总是已知的，而动态类型的对象直到运行时才可知。

3.虚函数

我们必须为每一个虚函数都提供定义，不管它是否被用到了，因为编译器无法确定到底会使用哪个虚函数。
OOP的核心思想就是多态(polymorphism):具有继承关系的多个类型称为多态类型。

派生类中的虚函数,当在派生类中覆盖了基类的某个虚函数，可以使用virtual关键字指明，即使不这么做，C++也是默认virtual的。

一个派生类的函数如果覆盖了某个继承而来的虚函数，则它的形参类型必须与被它覆盖的基类函数完全一致。

同样，派生类中虚函数的返回类型也必须与基类函数匹配，当类的虚函数返回类型是类本身的指针或引用时例外。

只有虚函数才能被覆盖

基类的虚函数默认实参最好与派生类的虚函数默认实参一致。

因为如果通过基类的引用或指针调用函数，则将使用基类的默认实参版本，但是该函数的实现是动态绑定的，即可能是基类的函数也可能是派生类的函数。

struct B {
    virtual void f1(int)const;
    virtual void f2();
    void f3();
};
struct D :B {
    void f1(int)const;//correct:f1matched with f1 in class  B
    void f2(int)override;//incorrect:theris no f2(int) in class B
    void f3()override;//incorrect:f3 is not a virtual function
    void f4()override;//incorrect:there is no function named f4 in class B
};

4.抽象基类

纯虚函数：纯虚函数不需要定义，在声明时写上=0即可，智能出现在虚函数声明处的语句。

含有(或未经覆盖而直接继承)纯虚函数的类为抽象类，抽象基类负责定义借口，而后续其它类可以覆盖接口。Note：不能创建抽象基类的对象

如将之前的net_price()定义为虚函数

class Dis_quote :public Quote{
public:
    Dis_quote() = default;
    Dis_quote(const string& book, double p, size_t qty, double disc) :
        Quote(book, p), quanty(qty), discount(disc)
    {

    }

    double net_price(size_t)const = 0;//pure virtual
protected:
    size_t quanty = 0;
    double discount = 0.0;
};

Disc_quote discounted;//incorrect :can not define the object for abstract base class

Disc_quote 的派生类必须定义自己的net_price(），否则仍是抽象基类

现在可以重新定义Bulk_quote，让它继承Disc_quote而不是直接继承Quote

class Bulk_quote :public Disc_quote {
    Bulk_quote() = default;
    Bulk_quote(const string& book,double p,size_t qty,double disc):
        Disc_quote(book,p,qty,disc){}
    //overeide net_price() in class base
    double net_price(size_t)const override;
};

访问控制与继承

对于访问控制，记住基类的私有成员，不管派生类的继承方式是什么，都是不可见的。派生类可以改变基类中的成员的访问权限，也只限于可访问的成员。

6. 继承中的类作用域

当存在继承关系时，派生类的作用域嵌套在其基类中的作用域内，如果一个名字在派生类的作用域内是无法解析的，则编译器将继续在外层的基类作用域寻找该名字，并且是在编译时进行名字查找；当派生类

的成员名字与基类成员名字冲时，此时定义在内层作用域（派生类）的名字将隐藏定义在外层作用域（基类）的名字

#include <iostream>


struct Base {
    Base():mem(0){}
protected:
    int mem;

};
struct Derived :Base {
    Derived(int i) :mem(i) {}//用i初始化mem,
                             //Base::mem 进行默认初始化
    int get_mem() { return mem;}//返回Derived::mem
protected:
    int mem;//与基类成员名形同,会隐藏基类中的mem
};
int main()
{
    Derived d(42);
    std::cout << d.get_mem() << std::endl;//打印结果42，说明调用get_mem()
                                          //对mem的解析结果是定义在Derived中的
    system("pause");
    return 0;

}