对象和类

过程性编程和面向对象编程(到时删掉吧)

• 过程性编程方法首先考虑要遵循的步骤然后考虑如何表示这些数据
• 面向对象编程从用户的角度考虑对象——描述对象所需的数据以及描述用户与数据交互所需的操作。完成对接口的描述后需要确定如何实现接口和数据存储。最后使用新的设计方案创建出程序

抽象和类

类型

• 决定数据对象需要的内存数量
• 决定如何解释内存中的位
• 决定可使用数据对象执行的操作或方法

类

• 一种将抽象转换为用户定义类型的c++工具将数据表示和操纵数据的方法组成一个整洁的包
• 类规范的组成
  • 类声明以数据成员的方式描述数据部分以成员函数(方法)的方式描述共有接口
  • 类方法定义描述如何实现类成员函数
• 通常会把接口(类定义)放在头文件并将实现(类方法的代码)放在源代码文件中
• 访问控制通过priveate,public,protected关键字来控制
• 类设计尽可能将共有接口与实现细节分开。公有接口表示设计的抽象组件。将实现细节放在一起并将它们与抽象分开进行封装
  • 数据隐藏是一种封装将实现的细节隐藏在私有部分
  • 将类函数定义和声明放在不同的文件中

类成员函数

• 类成员函数为有类声明中的原型表示的成员函数提供代码
  类成员函数定义与常规函数定义非常相似有函数头和函数体也有返回类型和参数
  • 定义成员函数时使用作用域解析运算符(::)来表示函数所属的类
  • 类方法可以访问类的private组件
• 作用域解析运算符确定了方法定义对应的类的身份
  类方法可以访问类的私有数据成员

// .h文件中
class Stock
{
    private:
        string company;
        long shares;
        double share_val;
        double total_val;
        void set_tot() { total_val = shares * share_val;}
    public:
        void acquire(const string & co, long n, double pr);
        void buy(long num, double price);
        void sell(long num, double price);
        void update(double price);
        void show();
}

// .cpp文件
void Stock::show()
{
    cout << "Company:" << company << " Shares:" << shares << endl;
}

• 其定义位于类声明中的函数都将自动成为内联函数(上面的set_tot)

类的构造函数和析构函数

声明和定义构造函数

• 构造函数不需要返回值也不需要声明void类型
• 构造函数的参数表示的不是类成员而是赋给类成员的值。因此参数名不能与类成员同名

Stock::Stock(const string & co, long n, doublt pr)
{
    ...
}
Stock::Stock(const string & company, long shares, double share_val) //不可行
{

}

使用构造函数

Stock garment = Stock("AAA", 23231, 2323.23);
Stock garment("AAA", 23231, 2323.23);

默认构造函数

• 默认构造函数是在未提供显式初始值时用来创建对象的构造函数c++不会做任何工作
• 定义默认构造函数一般是给已有的构造函数的默认参数提供默认值或通过函数重载来定义一个新的构造函数

析构函数

• 用构造函数创建对象后程序负责跟踪该对象直到其过期为止。对象过期时程序调用的特殊函数就是析构函数
• 析构函数的函数需要在类名前加上~。同样和构造函数一样没有返回值和声明类型
• 析构函数不需要传参数

~Stock();   // 析构函数原型

this指针

class Stock
{
    private:
        double total_val;
    public:
        double total() const {return total_val;}
}
const Stock & Stock::topval(const Stock & s) const
{
    if (s.total_val > total_val)
        return s;
    else
        return *this;
}

• this指针指向用来调用成员函数的对象(this被作为隐藏参数传递给方法)

对象数组

• 声明对象数组与声明标准类型数组相同

Stock stocks[4] = {
    Stock("AAA", 12.21, 12),
    Stock("BBB", 23.23, 23),
    Stock(),
    Stock("DDD", 56.56, 56)
}

类作用域

• 在类中定义的名称的作用域都为整个类
• 类作用域一位置不能从外部直接访问类的成员和公有成员函数。要调用他们需要通过对象

Stock test("AAA", 12.21, 12);
test.show();
show();         // 不可以直接这样使用

• 使符号常量的作用域为类十分有效。在声明类的时候只是描述了对象的形式并没有创建对象。在创建对象前声明的类数据成员是没有用于存储值的空间
• 方法一Months只是一个符号名称不会创建类数据成员
• 方法二Months会与其他静态变量存储在一起而不是存储在对象中。与所有Bakery对象共享

class Bakery
{
    private:
        //const int Months = 12;   不可以这样写
        enum {Months = 12};         // 方法一
        static const int Months = 12; // 方法二
        double cost[Month];
}

抽象数据类型

• 栈的特性
  • 先进后出
  • 可以创建空栈
  • 从数据项顶部添加数据(压入)
  • 从数据项顶部删除(弹出)

// stack.h
class Stack
{
    private:
        enum {MAX = 10};
        Item items[MAX];
        int top;
    public:
        Stack();
        bool isempty() const;
        bool isfull() const;
        bool push(const Item & item);
        bool pop(Item & item);
}
// stack.cpp
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;
}