April 20 ~ April 23

1. It's better to return a class type object using constructor to initialize a temporary class object rather than creating a temporary one in class method. Humm, this approach is very useful ! Remember to take full use of constructors !

2. Remember to return type bool value at the end of the overloading relational operations function.

3. There is no argument with overloading '~'operator function.

4月14日~4月19日，五天时间完成第十章。其中，做课后题三天。复习题10题，编程练习8题。

今天早晨终于想明白了最后一道编程题的函数指针部分，原来是要把 void visit(void(*pf)(Item &)) 放入自定义类的 public 部分作为类方法来用（之前还以为必须要放在外部...怎么都想不明白有什么用），再创建一个外部函数实现一些诸如计算之类的小功能。这道编程题算是自己最近编写得比较满意的程序。实现了自己想要实现的几个功能（定义一个类，往一个类似 stack 固定长度的空间里输入类对象，空了或满了、输入或删除对象都要实时报告内部可使用的空间个数，并且可以实现循环修改存入的数据并报告出来）。

要多回头看才能温故而知新。

不得不写一下对于《C++ Primer Pluse》第六版，修改第五版例题但是不增加解释的一点看法。从昨天到今天，让我快忍受不了了。各种把 C++11 直接放入书中，感觉并未融入教材中，还有一些改了例题不改显示输出，小问题小错误都可以理解。但是作为一本非常非常基础的 C++ 教材，面向的大都是对 C++ 甚至是编程语言都不甚了解的人。既然如此，擅自增加例题难度，修改例题（相对第五版）却不加任何注解，让我非常不解。这相当于在数学解题的时候，新版例题增加难度在解题过程中还跳步。

例题如下（分为 3 个文件，一个 header file，两个 source file）：

// stock20.h

#ifndef STOCK00_H_
#define STOCK00_H_
#include <string>

class Stock
{
private:
    std::string company;
    long shares;
    double share_val;
    double total_val;
    void set_tot() { total_val = shares * share_val; }
public:
    Stock();
    Stock(const std::string & co, long n = 0, double pr = 0.0);
    ~Stock();
    void buy(long num, double price);
    void sell(long num, double price);
    void update(double price);
    void show() const;
    const Stock & topval(const Stock & s) const;
};

#endif

// stock20.cpp

#include <iostream>
#include "stock20.h"

Stock::Stock()
{
    std::cout < < "Default constructor called\n";
    company = "no name";
    shares = 0;
    share_val = 0.0;
    total_val = 0.0;
}

Stock::Stock(const std::string & co, long n, double pr)
{
    std::cout << "Constructor using " << co << " called\n";
    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();
}

Stock::~Stock()
{
}

void Stock::buy(long num, double price)
{
    if (num < 0)
    {
        std::cout << "Number of shares purchased can't be negative."
                      << "Transaction is aborted.\n";
    }
    else
    {
        shares += num;
        share_val = price;
        set_tot();
    }
}

void Stock::sell(long num, double price)
{
    using std::cout;
    if (num < 0)
    {
        cout << "Number of shares purchased can't be negative."
                << "Transaction is aborted.\n";
    }
    else if (num > shares)
    {
        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() const
{
    using std::cout;
    using std::ios_base;

    ios_base::fmtflags orig = cout.setf(ios_base::fixed, ios_base::floatfield);
    std::streamsize prec = cout.precision(3);

    cout << "Company: " << company
            << " Shares: " << shares << '\n';
    cout << " Share Price: $" << share_val;
    cout.precision(2);
    cout << " Total Worth: $" << total_val << '\n';
    cout.setf(orig, ios_base::floatfield);
    cout.precision(prec);
}

const Stock & Stock::topval(const Stock & s) const
{
    if (s.total_val > total_val)
    {
        return s;
    }
    else
    {
        return *this;
    }
}

// usestok2.cpp
#include <iostream>
#include "stock20.h"

const int STSK = 4;

int main(void)
{
    Stock stock[STSK] =
    {
        Stock("NanoSmart", 12, 20.0),
        Stock("Boffo Object", 200, 2.0),
        Stock("Monolithic Obelisks", 130, 3.25),
        Stock("Fleep Enterprises", 60, 6.5)
    };

    std::cout << "Stock holdings:\n";
    int st;
    for (st = 0; st < STSK; ++st)
    {
        stock[st].show();
    }

    const Stock * top = &stock[0];
    for (st = 0; st < STSK; ++st)
    {
         top = &top->topval(stock[st]);
    }
    std::cout << "\nMost valuable holding:\n";
    top->show();
    return 0;
}

第五版例题这部分不是这样的，第五版直接用书中例题之前介绍的比较两对象大小的新方法：通过函数直接访问和间接访问两对象实现比较并返回较大值。

第六版的例题：注意橙色加粗部分。
const Stock * top = &stock[0];
for (st = 0; st < STSK; ++st)
{

top = &top->topval(stock[st]);

}
std::cout << "\nMost valuable holding:\n";
top->show();

第五版的例题对应部分如下：
Stock top = stock[0];
for (st = 0; st < STSK; ++st)
{

top = top.topval(stock[st]));

}
std::cout<< "\nMost valuable holding:\n";
top.show();

这样写和前文对于新比较方法的介绍做到前后呼应。让我莫名其妙的是，第六版中前面内容未做修改，但是“锦上添花”地把例题比较部分的对象改成用指针表示。自己理解不能，看了很久很久很久。我只能自己推断，然后猜是否是这样来理解。这样的感觉非常不好。

这些问题源于可爱的 this 指针。看过该书的同学应该知道 total_val 其实是 this->total_val 的缩写或速写法。在这里，充分说明“->”的含义，英文为 indirect membership operator; “.”是 direct membership operator。这里把直接访问和间接访问表现得淋漓尽致。若 s.total_val 是 s 直接访问成员 total_val，话说因为 s 是对象 stocks[1]（以第二个数组元素为例）的 reference，所以，访问对象自己的私有成员，没一点问题。但是，this 作为一个指针，特权就不够了。虽然和那些数组元素是一个 class 里的对象，但是，指针就是指针，即使该指针里储存的是指向对象的地址，想要访问指向对象的成员，只能间接。在例题中，突然标新立异用一个 top 指针指向 stock[0]，然后修改例题......看了无数遍后，我明白了作者的良苦用心。作者应该是觉得第五版用直接隐式访问对象的方式来阐明这个比较大小的新方法不够突出 this 指针的运作原理。那么，就改一改吧，用指针来指向本应直接隐式访问的对象。这下...难度提高了，也混乱了。这都不要紧，作者是否考虑在原版的基础上加一两句说明呢？不知为何，只字未提。不是自己对照第五版还不知道这题被改了。

言归正传，既然用了这种方法，那就使劲想吧。

首先是这句：top = &top->topval(stock[st])；应该这样理解 top = &(top->topval(stock[st]))；

接下来，top->topval() 理解为 topval() 间接隐式访问top对象。（为何这样隐晦？敢不敢直接点？不解...）

然后，由于 this 指针储存的是 调用成员函数的对象地址。这样看来，this 才不管是直接调用还是间接调用。只要是调用的那个对象的地址就归它储存。问题是，调用 topval() 函数的是 top 指针啊！那么 this 里储存的应该是 top 指针本身的地址啊！ 希望也像我这样理解的同学注意一下。其实，不是的...这种情况下，this = top; 即 top 指针把它储存的地址赋值给 this 指针，那个地址是对象的地址，不是top指针的地址。我一直不理解为什么是这样。这样看来，top->topval() 其实并不是 top 调用函数，而是 to p指向的对象调用函数。而 top 在这里就像是它指向对象的 alias。指针怎么可能是对象的别名？！因为...const 的原因。

简而言之，当用指针指向对象时，这时要用指针表示其指向对象调用成员函数就用“指针->成员函数”这样的句法来完成。至于为什么不用“对象 . 成员函数”这样简单的句法来完成，that's another story...

From April 9th to 13th, that's it, five days.

Struggle for the number of chapter more than ten...

From March 18th to April 7th...

It took me twenty-one days after finishing Chapter 8 (one day for translation).

1. Recursion...Recursion...Recursion...
   It makes me so confused...

2. Note the following statement :

   const double * (*ps[3])(const double *, double) = {f1, f2, f3};

   *ps[3] says ps is an array of three pointers.The rest of the declaration indicates what each pointer points to: a function with a signature of const double *, double and a return type of const double *.

3. Remember there are two syntax to understand the following statement:

   const double *(*(*pd)[3])(const double *, double) = &pa;

Go Ahead!