C++ 类和对象（3）

        类和结构体是比较相似，而传统的C的结构体中都是一些数据的类型，类除了有数据之外还有函数。所以可以把类想象成一个具有既有数据又有函数的复合数据类型。

        类是一种将抽象转换为用户定义类型的C++工具，它将数据表示和操纵数据的方法组合成一个整洁的包。

        以股票为例：

股票中的数据类型有：股票的价格，股票的公司，所持股票的量等等。

可执行的操作限制为：获得股票，增持，卖出股票，更新股票价格，显示所持股票的信息。

        存储下面的信息：

• 公司名称；
• 所持股票的数量；
• 每股的价格；
• 股票总价；

        然后定义类。一般来说，类规范由两个部分组成。

• 类声明：以数据成员的方式描述数据部分，以成员函数（被称为方法）的方式描述公有接口。
• 类方法定义：描述如何实现类成员函数。

        简单来说，类声明提供了类的蓝图，而方法定义则提供了细节。

一般来说把类的定义放在.h文件中，类的成员函数的实现放入.c文件中

        凡是出现在private中出现的标识无论是函数还是数据的某个变量某个类型，都只能通过public中的方法间接地去访问它。

       

stock00.cpp

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

void Stock::acquire(const std::string &co,long n,double pr)
{
    company = co;
    if(n<0)
    {
        std::cout<<"Numer of shares can't be negative;"<<company
        <<"shares set to be 0."<<std::endl;
    }
    else 
    {
        shares = n;
    }
        share_val = pr;
        set_tot();
}
void Stock::buy(long num,double price)
{
    if(num<0)
    {
        std::cout<<"Numer of shares can't be negative,Transaction is aborted"
        <<std::endl;
    }
    else
    {
        shares += num;
        share_val = price;
        set_tot();
    }
}
void Stock::sell(long num,double price)
{
    if(num<0)
    {
        std::cout<<"Numer of shares can't be negative,Transaction is aborted"
        <<std::endl;
    }
    else if(num >shares)
    {
        std::cout<<"You can't sell more than you have!Trancsaction is aborted"
        <<std::endl;
    }
    else
    {
        shares -= num;
        share_val=price;
        set_tot();
    }
}
void Stock::update(double price)
{
    share_val = price;
    set_tot();
}
void Stock::show()
{
    std::cout<<"Company:"<<company<<std::endl;
    std::cout<<"Shares:"<<shares<<std::endl;
    std::cout<<"Share price"<<share_val<<std::endl;
    std::cout<<"Total worth:"<<total_val<<std::endl;
}

        Stock是类，而fluffy_the_cat就是类的对象。其中 fluffy_the_cat 就像是 int i 中的 i 。类的成员函数可以通过对象来调用。类似于用结构体的对象来访问结构体中的成员。

        要使用新类型，最关键的是要了解成员函数的功能，而不必考虑其实现细节。就像std空间，我们只需要知道如何使用cin，cout之类的功能，而不用去了解为什么。一般把这种方法称为“客服/服务器模型”。

        客服/服务器模型

        OOP程序员（面向对象的程序员）经常依照 客服/服务器模型 来讨论程序设计。客服是使用类的程序。类声明（包括类方法）构成了服务器，它是程序可以使用的资源。客户只能通过以公有方式（public）定义的接口使用服务器。所以客户只需要了解该接口。设计服务器的人的责任是确保服务器根据该接口可靠并准确的执行。服务器设计人员只能修改类的设计的实现细节，而不能修改接口。

        指定类设计的第一步是提供类声明。类声明类似于结构声明，可以包括数据成员和函数成员。声明有私有部分，在其中声明的成员只能通过成员函数进行访问；声明还有公有部分，在其中声明的成员可以被使用类的对象的程序直接访问。通常，数据成员被放在私有部分中，成员函数被放在公有部分中，因此典型的类声明格式如下：

class className
{
    private:
        data member declarations    //数据成员声明
    public:
        member function prototypes  //成员函数原型
};

        除非函数很短可以直接在函数定义的时候写出来，变成内联函数，否则尽量单独提供函数类的声明以及类的成员函数定义。例如set_tot()：

private:
                std::string company;
                long shares;
                double share_val;
                double total_val;
                void set_tot(){total_val = shares * share_val;}

 stock00.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:
                void acquire(const std::string &co,long n,double pr);
                void buy(long num,double price);
                void sell(long num,double price);
                void update(double price);
                void show();
};

#endif

 usestock00.cpp

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

int main()
{
    Stock fluffy_the_cat;
    fluffy_the_cat.acquire("PTU",20,12.50);
    fluffy_the_cat.show();

    fluffy_the_cat.buy(15,18.125);
    fluffy_the_cat.show();

    fluffy_the_cat.sell(400,20.00);
    fluffy_the_cat.show();

    fluffy_the_cat.buy(300000,123.123);
    fluffy_the_cat.show();

    fluffy_the_cat.sell(300000,0.123);
    fluffy_the_cat.show();

    return 0;
}

要注意的是，只能在某些特定的环境中，如类方法的代码中，可以省略的类名和::作用域解析符。

假设Bozo有一个名为Retort()的成员函数，该函数返回char指针，则其函数头如下：

char * Bozo::Retort()

此时，Retort()不仅是一个char*类型的函数，而是一个属于Bozo类的char*函数。该函数全名（限定名）为Bozo::Retort()。而Retort()是限定名的缩写。

另一种描述这种情况的方式是，名称Retort的作用域为整个类，因此在类声明和类方法之外使用该名称时，需要使用作用域解析运算符进行限定。

        要创建对象，只需要将类名视为类型名既可：

Bozo bozetta;

        因为类是用于定义的类型，所以这样是可行的。

        类成员函数（方法）可以通过类对象来调用。

cout<<bozetta.retort();

        将调用Retort()成员函数，每当其中的代码引用某个数据成员时，该函数都将使用bozetta对象中相应成员的值。