C++类--

C++类

---

1. 类的定义

类的基本思想是数据抽象和封装。数据抽象是一种依赖于接口和实现分离的编程技术。类的接口包括用户所能执行的操作；类的实现则包括类的数据成员、负责接口实现的函数体以及定义类所需的各种私有函数。
类是一种将抽象转换为用户定义类型的C++工具，它将数据表示和操纵数据的方法组合成一个整洁的包。

一般来说，类规范由两部分组成：

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

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

通常，我们将接口（类定义）放在头文件中，并将实现（类方法的代码）放在源代码文件中。

1.1类的声明

stock类的类声明：

// stock00.h
#ifndef STOCK00_H_
#define STOCK00_H_

#include <string>

class Stock  // 类声明
{
private: // 类对象默认控制是私有的，因此不必在类声明中使用此关键字
	std::string company; // private by default
	long shares;
	double share_val;
	double total_val;
	void set_tot() { total_val = shares * share_val;}
public:
	// 默认构造函数
	Stock();
//	Stock(const std::string & co = "Error", long n = 0, double pr = 0.0);
    Stock(const std::string & co, long n, double pr);
    ~Stock();        // 析构函数
	void buy(long num, double price);
	void sell(long num, double price);
	void update(double price);
	void show();
};  // 注意末尾需添加分号

#endif

该声明让我们能够声明Stock类型的变量–称为对象或实例，如：
Stock sally；
Stock solly;

1.2 类的访问控制与封装

C++中，我们可以使用访问说明符加强类的封装，即使用关键字private、public以及protected。使用类对象的程序都可以直接访问公有部分，但只能通过公有成员函数或友元函数来访问对象的私有成员。
类设计尽可能将公有接口与实现细节分开。公有接口表示设计的抽象组件。将实现细节放在一起并将他们与抽象分开被称为封装。将数据隐藏是一种封装，将类函数定义和类声明放在不同的文件中也是一种封装。
使用class和struct都可以定义类，唯一的区别就是默认的访问权限。如果我们使用struct关键字，则定义在第一个访问说明符之前的成员是public的，相反，如果使用class关键字，则这些成员是private的。通常使用class来实现类描述，而把结构限制为只表示纯粹的数据对象。

1.3 类成员函数的实现

成员函数定义与常规函数定义非常相似，它们有函数头和函数体，也可以有返回类型和参数。但是它们还有两个特征：

• 定义成员函数时，使用作用域解析运算符(::)来标识函数所属的类；
• 类方法可以访问private组件。

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

Stock::Stock() // default constructor
{
	company = "no name";
	shares = 0;
	share_val = 0.0;
	total_val = 0.0;
}

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

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)
{
    if (num < 0)
    {
        std::cout << "Number of shares sold can't be negative. "
                  << "Transaction is aborted. \n";
    }
    else if (num > shares)
    {
        std::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()
{
    std::cout << "Company: " << company
              << " Shares: " << shares << '\n'
              << " Share Price: $" << share_val
              << " Total Worth: $" << total_val << '\n';
}

内联函数
其定义在类声明中的函数都将自动成为内联函数，因此Stock::set_tot()是一个内联函数。类声名常将短小的函数作为内联函数，set_tot()符合这样的要求。我们也可以在类声明之外定义定义成员函数，并使其成为内联函数。

class Stock  // 类声明
{
private: 
	...
	void set_tot() { total_val = shares * share_val;}
public:
	...
};  

inline void Stock::set_tot()
{
	total_val = shares * share_val;
}

1.4 类的使用

// usestock00.cpp
// compile with stock00.cpp
#include <iostream>
#include "stock00.h"

int main()
{
	Stock fluffy_the_cat;
	fluffy_the_cat.acquire("NanoSmart", 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, 40.125);
	fluffy_the_cat.show();
	fluffy_the_cat.sell(300000, 0.125);
	fluffy_the_cat.show();
	return 0;
}