一、类的概念
类是一种将抽象转换为用户定义类型的C++工具，它将数据和数据处理组合成一个整体。
比如股票类，首先要考虑如何表示股票。可以将某人持有的股票当成一个基本单元，数据包括他持有股票的数量，哪个公司的股票，还有最初购买的价格和购买的时间，股票的处理有增持，卖出，更新价格等。
类一般由类声明和类方法定义两部分组成，
类声明：以数据成员的方式描述部分，以成员函数的方式描述公有接口；
类方法定义：描述如何实现类成员函数。
可以这么说，类声明就是画个饼，类方法就是去实现这个饼。
二、类的声明
一般将类声明放在头文件中，就是.h文件，将类的实现放在源文件中，就是.cpp文件。
下面是stock类的类声明
#ifndef STOCK_H
#define STOCK_H
#include <string>
using namespace std;
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();
};
#endif // STOCK_Hstock是这个类的类型名，我们可以声明stock类型的变量，也称为对象或实例，每个对象都表示一支股票，可以通过下面的声明创建两个stock对象
stock wang;
stock li; private和public关键字是C++中新出现的，它们用来描述对类成员的访问权限。private表示类的私有部分，public表示类的公有部分。使用类对象的程序可以直接访问类的公有部分；但类的私有部分只能通过类的成员函数来访问。
三、实现类的成员函数
类成员函数的定义与常规函数的定义非常类似，有函数头、函数体，也可以有返回类型和参数。区别在于，定义类的成员函数需要使用类的作用域解析运算符::来标示函数所属的类，类的成员函数可以访问类的私有成员数据。
void stock::update(double price)这表示update()函数是stock类的成员函数。
类的成员函数，也就是类的实现代码如下
#include "stock.h"
#include <iostream>
using namespace std;
//acquire()函数管理对某个公司股票首次购买，公司名称，购买数量，每股单价
void stock::acquire(const string& co, long n, double pr)
{
company = co;
if(n<0)
{
cout << "number of shares can't be nagative; ";
cout << company << " shares set to 0.\n";
shares = 0;
}
else
{
shares = n;
}
share_val = pr;
set_tot();
}
//增持股票，增持的数量，和当时的价格
void stock::buy(long num, double price)
{
if(num < 0)
{
cout << "number of shares purchased can't be nagative; ";
cout << " Transaction is aborted.\n";
}
else
{
shares += num;
share_val = price;
set_tot();
}
}
//减持股票，减持的数量，和当时的价格
void stock::sell(long num, double price)
{
if(num < 0)
{
cout << "number of shares sold can't be nagative; ";
cout << " 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()
{
cout << "Company: " << company << " Shares: " << shares << endl;
cout << "Share price: " << share_val << " Total Worth: " << total_val << endl;
}公有属性的函数没什么好说的，看代码和注释就看的明白。里面有个特别一点的函数set_tot()函数，是计算股票总资产的，这个函数是类的私有成员函数，代码中每个公有成员函数都有使用它，方法都是一样的，就没必要写重复的代码，这样既减少了重复代码，有节省了空间。
三、将类应用于对象
经过头文件和源文件的编写，stock类已经创建好了，可以开始使用了，先创建两个类对象，kate与joe.
stock kate, joe;如何使用对象的成员函数
kate.show();
joe.show();第一句调用kate对象的show()成员函数，这意味着此时的shares代表的是kate.shares,此时的share_val 代表的是kate.share_val 。第二句同理。
所创建的每个新对象都有自己的存储空间，用于存储其内部变量和类成员，但是同一个类的所有对象共享同一组类方法，也就是共用同一套类成员函数。kate和joe都是stock对象，kate.shares占一块内存，joe.shares占另外一块内存，它们是不一样的东西。
四、使用类
C++的目标是让使用类与使用基本的类型尽可能相同。要创建类对象，可以声明类变量，也可以使用new为类对象分配存储空间，可以将对象作为函数的参数和返回值，也可以将一个对象赋值给另一个对象。
下面是类的使用代码示例，创建一个stock对象 dreamer
#include <iostream>
#include "stock.h"
using namespace std;
int main()
{
stock dreamer;
dreamer.acquire("hengda", 20, 12.50); //dreamer以每股12.5元的价格买了20股恒大的股票
dreamer.show();
dreamer.buy(15, 18.25);//dreamer又以18.25元的价格增持了15股恒大的股票
dreamer.show();
dreamer.sell(400,20);//dreamer想以20元的价格卖掉400股，好像在做梦，都没有那么多股票
dreamer.show();
dreamer.buy(20000, 20);//dreamer突然有很多钱了，以每股20元的价格，一下子买了20000股恒大的股票
dreamer.show();
dreamer.sell(20000, 0.15);//完蛋了，恒大破产了，股票跌到1毛五，赶紧抛吧
dreamer.show(); //变成穷光蛋了吧
return 0;
}输出结果
Company: hengda Shares: 20
Share price: 12.5 Total Worth: 250
Company: hengda Shares: 35
Share price: 18.25 Total Worth: 638.75
you can't sell more than you have! transaction is aborted.
Company: hengda Shares: 35
Share price: 18.25 Total Worth: 638.75
Company: hengda Shares: 20035
Share price: 20 Total Worth: 400700
Company: hengda Shares: 35
Share price: 0.15 Total Worth: 5.25
六、类的构造函数
其实上面创建的stock类还不完善，还需要为它添加构造函数与析构函数，为什么？
C++的目标是让使用类跟使用基本类型一样简单，但是到目前为止，我们还不能像初始化int变量那样初始化stock对象，也就是说常规的初始化语法不适用于stock类。
如int变量和结构体变量都可以这样初始化
int year = 2023; //int变量初始化
struct thing
{
char* pn;
int m;
};
thing amabob = {"wodget", -23};//结构体变量初始化类对象可不能这么初始化
stock dreamer = {"hengda", 250, 2.5};类对象不能这么初始化，是因为数据部分的访问是私有的，这意味着程序不能直接访问数据成员。程序只能通过成员函数来访问数据成员，因此需要设计合适的成员函数，才能将对象初始化，这个合适的函数就是构造函数。
构造函数就是用于构造新对象，将值赋给它们的数据成员。
构造函数没有返回值，构造函数的名字与类名字一样；
还是延续前面的stock类，为其创建一个构造函数，需要为stock对象提供3个值，因此为构造函数提供3个参数，如果指向设置company成员，将其他的值设为0
stock::stock(const string& co, long n, double pr)
{
company = co;
if(n<0)
{
cout << "number of shares can't be nagative; ";
cout << company << " shares set to 0.\n";
shares = 0;
}
else
{
shares = n;
}
share_val = pr;
set_tot();
}这个构造函数的代码与acquire()函数的代码相同，区别在于，程序声明对象的时候会自动调用构造函数。这个自动调用也不是那么的自动，还是要做一些工作。可以显式调用也可以隐式调用
显式调用构造函数
#include <iostream>
#include "stock.h"
using namespace std;
int main()
{
stock dreamer = stock("apple",10, 12); //显式调用构造函数，将dreamer对象初始化
dreamer.show();
return 0;
}输出结果
Company: apple Shares: 10
Share price: 12 Total Worth: 120隐式调用构造函数，就是在对象后面直接把参数贴上去
#include <iostream>
#include "stock.h"
using namespace std;
int main()
{
stock dreamer("apple",10, 12); //隐式调用构造函数，将dreamer对象初始化
dreamer.show();
return 0;
}输出结果是一样的 。
如果程序没有写构造函数，C++的编译器会提供一个默认的构造函数,里面没有初始的数据。
stock::stock() {}当且仅当程序没有写任何构造函数，编译器才会提供一个默认构造函数，否则，就得自己写一个默认构造函数。
定义了常规构造函数和默认构造函数之后，声明一个类对象之后，如果没有调用常规构造函数，程序或自动调用默认构造函数
#include <iostream>
#include "stock.h"
using namespace std;
int main()
{
stock dreamer; //程序调用默认构造函数
dreamer.show();
return 0;
}
输出结果
Company: no name Shares: 0
Share price: 0 Total Worth: 0七、类的析构函数
用构造函数创建对象后，程序负责跟踪该对象，直到过期。对象过期时，程序将自动调用一个特殊的成员函数，这个函数就是析构函数，析构函数完成清理工作，如果构造函数使用new来分配内存，那么析构函数将使用delete释放内存。
西沟函数长这个样子
~stock();由于析构函数不用承担任何重要的工作，里面可以不放代码
stock::~stock()
{
}如果你想看看西沟函数是否运行，可以在析构函数里面放一个打印语句
stock::stock()
{
cout << "using ~stock().\n"
}
七、const成员函数
八、this指针
九、创建对象数组
十、类的作用域
