对象和类，公有类和私有类，构造函数和析构函数，const成员函数，this指针，对象数组，类作用域，抽象数据

下面是头文件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

private是类对象默认访问控制。

接下来的file1是函数的定义：

#include<iostream>//此文件是对头文件中的函数定义
#include"stock00.h"

void Stock::acquire(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();
}
void Stock::buy(long num, double price)
{
if (num < 0)
{
std::cout << "Number of shares purchased can't be negative."
<< "Transaction if aborted.\n";
}
else
{
shares += num;
share_val = price;
set_tot();
}
}
void Stock::sell(long num, double price)
{
using std::cout;
if (num < 0)
{
cout << "Number of shares sold can't be negative."
<< "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()
{
std::cout << "Company:" << company
<< " Shares: " << shares << '\n'
<< "Share price :$" << share_val
<< " Total Worth: $" << total_val << std::endl;
}

定义位于类声明中的函数都将自动成为内联函数。

类所创建的每个对象都有自己的存储空间，用于存储内部变量和类成员，但同一个类的所有对象共享一组类方法（即 函数）。

接下来的file3是对函数的调用：

#include<iostream>
#include"stock00.h"
int main()
{
Stock fluffy_the_cat;
fluffy_the_cat.acquire("NanoSmart", 20, 12.15);
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();
return 0;
}类数据隐藏并不是存储该数据的内存不可访问，而是你不知道存储该数据的地址。
类构造函数：由于类的数据是私有的，所以不可以使用普通的列表初始化方法对类对象赋初值，要使用类构造函数。若在类外定义构造函数，则要加上域作用符，例：

Stock::Stock(const string &co, long n, double pr)
{
company = co;
if (n < 0)
{
std::cerr << "Number of shares can't be negative;"
<< company << " shares set to 0.\n";
shares = 0;
}
else
shares = n;
share_val = pr;
set_tot();
}比较简单的构造函数也可以使用参数初始化表的方式来构造，例如：Stock(int h,int n):height(h), no(n){}

使用构造函数的方法有2种：1。显式调用：Stock food=Stock("World cabbage",250,1.25);  2.隐式调用：Stock garment("Furry Marson",50,2.5);
在没有构造函数的情况下，C++将调用默认的构造函数。

析构函数：在对象过期时会调用析构函数，Stock::~Stock(); 该函数没有参数。

#include<iostream>
using namespace std;
int main()
{
{
Stock hello;//假设析构函数已被认为定义，作用是输出end单词
hello.show();
}
return 0;
}如上如果main()函数中没有多一个大括号，则对象将先执行return0，再消失，也就看不懂end单词了，有括号的话，对象将在退出其定义所属的代码块时消失，调用析构函数，就可以看到end单词了。
同类对象可以用赋值运算符来赋值。

const成员函数：如果对象为const，则函数也必须为const； 但函数为const的话，对象不一定要为const。只要调用的函数不修改数据，就应该在其后面加const，如：void show()const;

this指针：const Stock &Stock::topval(const Stock &s)const//stock1对象和stock2对象在stock1中比较top_val的大小，s为stock2的引用
{
if (s.total_val > total_val)//此处total_val也可以改为this->total_val
return s;
else
return *this;//返回该对象
}this是对象的地址，*this是对象本身。