C++复习之 对象和类2（7）

this 指针

• 出于效率的考虑会使用引用。

下面声明一个类方法。

const Stock & topval(const Stock &s) const;

该类方法函数隐式地访问一个对象（默认可以访问该类的私有成员），而显式地访问另一个对象，并返回一个对象的引用。括号中的const表明，该函数不会修改被显式访问的对象；而括号后的const表明，该函数不会修改被隐式访问的对象。由于该函数返回了两个const对象之一的引用，隐藏返回类型也应为const引用。

top = stock1.topval(stock2);
top = stock2.topval(stock1);

第一种隐式地访问stock1，而显式地访问stock2。

const Stock & Stock::topval(const Stock & s)const
{
    if(s.total_val>total_val)//由于topval是一个类方法，因为可以访问到类的私有数据
        return s;
    else
        return *this; //从而引出this指针
}

this是一个特殊的指针，用来调用成员函数的对象。一般来说，所有的类方法都将this指针设置为调用它的对象的地址，total_val是this->total_val的缩写。this指针指向对象，如果要表示对象本身，使用*this。
返回类型为引用表明返回的是调用对象本身而不是其副本。

class Stock
{
private:
    ...
    double total_val;
    ...
public:
    ...
    const Stock & topval(const Stock & s)const;//this指针实例
};

const Stock & Stock::topval(const Stock & s)const
{
    if (s.total_val>total_val)//由于topval是一个类方法，因为可以访问到类的私有数据
        return s;
    else
        return *this;
}

对象数组

Stock mystuff[4];

对象数组中的对象初始化时，总是调用默认构造函数，然后如果有显式地构造函数再生成临时对象来覆盖默认构造生成的对象。

const int STKS = 10;
Stock stocks[STKS]={
    Stock("Nanfi", 12.5, 20),
    Stock(),
    Stock("Monica", 130, 6.5),
};

剩余的7个元素将使用默认构造函数进行初始化。

example

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

const int STKS = 4;
int main()
{
    {
        Stock stocks[STKS] = {
            Stock("Nanfi", 12.5, 20),
            Stock("Cherry", 300, 10),
            Stock("Monica", 130, 6.5),
            Stock("Fleep", 60, 6.5)
        };
        std::cout << "Stock holdings: \n";
        int st;
        for (st = 0; st < STKS; st++)
        {
            stocks[st].show();
        }
        const Stock *top = &stocks[0];
        for (st = 1; st < STKS; st++)
        {
            top = &(top->topval(stocks[st]));
        }
        std::cout << "\nMost valuable holding:\n";
        top->show();//指针使用->，对象使用.
        system("pause");
        return 0;
    }
    std::cin.get(); 
    system("pause");
    return 0;
}

类作用域

在类中定义的名称的作用域都为整个类。
作用域为类的常量使用枚举型或使用static const int Months= 12;

抽象数据类型(abstract data type,ADT)

使用类来创建一个“栈”：

• 可创建空栈；
• 可将数据项添加到堆顶（压入）；
• 可从栈顶删除数据项（弹出）
• 可查看栈是否填满；
• 可查看栈是否为空；

可以将上述描述转换为一个类声明，其中公有成员函数提供了表示栈操作的接口，而私有数据成员负责存储栈数据。
私有部分必须表明数据存储的方式，公有部分来表示通用术语（创建栈、压入）。

//程序清单
//stack.h
#ifndef STACK_H_
#define STACK_H_

typedef unsigned long Item;

class Stack
{
private:
    enum{Max=10};
    Item item{Max};
    int top;
public:
    Stack();
    bool isempty()const;
    bool isfull()const;
    bool push(const Item & item);
    bool pop(const Item & item);
};
#endif

//stack.cpp
#include "stack.h"
Stack::Stack()
{
    top = 0;
}

bool Stack::isempty()const
{
    return top == 0;
}

bool Stack::isfull()const
{
    return top == Max;
}

bool Stack::push(const Item & item)
{
    if (top < Max)
    {
        items[top] = item;
        return true;
    }
    else
        return false;
}
bool Stack::pop( Item & item)
{
    if (top > 0)
    {
        item = items[--top];//要先--才表示数组的最上面的一个值
        return true;
    }
    else
        return false;
}

//main.cpp
#include <iostream>
#include <cctype>
#include "stack.h"

int main()
{
    using namespace std;
    Stack st;//create an empty stack
    char ch;
    unsigned long int  po;
    cout << "Please enter A to add a purchase order,\n"
        << " P to process a PO, or Q to quit.\n";
    while (cin >> ch&&toupper(ch) != 'Q')
    {
        while (cin.get() != '\n')
        {
            continue;
        }
        switch (ch)
        {
        case 'A':
        case 'a':
            cout << "Enter a PO number to add: ";
            cin >> po;
            if (st.isfull())
                cout << "stack already full\n";
            else
                st.push(po);
            break;
        case 'p':
        case 'P':
            if (st.isempty())
                cout << "stack already empty\n";
            else
            {
                st.pop(po);
                cout << "PO #" << po << " popped\n";
            }
            break;

        default:
            break;
        }
        cout << "Please enter A to add a purchase order,\n"
            << " P to process a PO, or Q to quit.\n";
    }
    cout << "Bye\n";
    system("pause");
    return 0;
}