this指针和对象数组
(1) this指针：
每个成员函数（包括构造函数和析构函数）都有一个this指针。 this指针指向调用对象。 如果方法需要引用整个调用对象，则可以使用表达式*this。
在函数的括号后面使用const限定符将this限定为const，这样将不能使用this来修改对象的值。
//stock20.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:
//两个构造函数
Stock(); //默认构造函数
Stock(const std::string & co, long n = 0, double pr = 0.0);
~Stock(); //析构函数
void buy(long num, double price);
void sell(long num, double price);
void update(double price);
void show() const;
const Stock & topval(const Stock & s) const; //用于比较的方法的原型
}; //请注意结尾处的分号
#endif // !STOCK00_H_
//stock20.cpp -- 实施股票类
#include<iostream>
#include"stock20.h"
//构造函数定义
Stock::Stock() //默认构造函数
{
company = "no name";
shares = 0;
share_val = 0.0;
total_val = 0.0;
}
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()
{
}
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)
{
using std::cout;
if (num < 0)
{
cout << "Number of shares purchased 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() const
{
using std::cout;
using std::ios_base;
//将格式设置为#.###
ios_base::fmtflags orig = cout.setf(ios_base::fixed, ios_base::floatfield);
std::streamsize prec = cout.precision(3);
cout << "Company: " << company
<< " Shares: " << shares << '\n';
cout << " Share Price: $" << share_val;
//将格式设置为#.##
cout.precision(2);
cout << " Total Worth: $" << total_val << '\n';
//恢复原始格式
cout.setf(orig, ios_base::floatfield);
cout.precision(prec);
}
const Stock & Stock::topval(const Stock & s) const
{
if (s.total_val > total_val)
return s;
else
return *this;
}
(2) 对象数组
声明对象数组的方法与声明标准类型数组相同：
Stockmystuff[4]; //创建一个包含4个Stock对象的数组
可以用构造函数来初始化数组元素。 在这种情况下，必须为每个元素调用构造函数：
const int STKS = 4;
Stock stocks[STKS] = {
Stock("NanoSmart",12.5,20),
Stock("Boffo Objects",200,2.0),
Stock("Monolithic Obelisks",130,3.25),
Stock("Fleep Enterprises",60,6.5)
};
如果类包含多个构造函数，则可以对不同的元素使用不同的构造函数：
const int STKS = 10;
Stock stocks[STKS] = {
Stock("NanoSmart",12.5,20),
Stock(),
Stock("Monolithic Obelisks", 130,3.25)
};
上述代码使用Stock(const std::string & co, long n = 0, double pr = 0.0)初始化stock[0]和stock[2]，使用构造函数Stock()初始化stock[1]。 由于该声明只初始化了数组的部分元素，因此余下的7个元素将使用默认构造函数进行初始化。
初始化对象数组的方案是，首先使用默认构造函数来创建数组元素，然后花括号中的构造函数将创建临时对象，然后将临时对象的内容复制到相应的元素中。因此，要创建类对象数组，则这个类必须有默认构造函数。
//usestock2.cpp -- 客户程序
//和stock20.cpp一起编译
#include<iostream>
#include"stock20.h"
const int STKS = 4;
int main()
{
//创建一个含4个初始化过的对象的数组
Stock stocks[STKS] = {
Stock("NanoSmart",12.5,20),
Stock("Boffo Objects",200,2.0),
Stock("Monolithic Obelisks",130,3.25),
Stock("Fleep Enterprises",60,6.5)
};
std::cout << "Stock holdings:\n";
int st;
for (st = 0; st < STKS; st++)
stocks[st].show();
//将指针指向第一个元素
const Stock * top = &stocks[0];
for (st = 1; st < STKS; st++)
top = &top->topval(stocks[st]);
//新指针指向总价格成员最高的对象
std::cout << "\nMost valuable holding:\n";
top->show();
std::cin.get();
return 0;
}
(3) 抽象数据类型
栈：
1. 创建空栈；
2. 可将数据项添加到堆顶（压入）；
3. 可从栈顶删除数据（弹出）；
4. 可查看栈是否填满；
5. 可查看栈是否为空。
可以将上述描述转换为一个类声明，其中公有成员函数提供了表示栈操作的接口，而私有数据成员负责存储栈数据。
//stack.h -- 为抽象数据类型栈定义的类
#ifndef STACK_H_
#define STACK_H_
typedef unsigned long Item;
class Stack
{
private:
enum{MAX=10}; //类特有的常量
Item items[MAX]; //装入栈中项目
int top; //栈顶元素指针
public:
Stack();
bool isempty() const;
bool isfull() const;
//push()在栈满时返回false，否则返回true
bool push(const Item & item); //向栈中添加元素
//pop()在栈空时返回false，否则返回true
bool pop(Item & item);
};
#endif // !STACK_H_
私有部分表明，栈时使用数组实现的；而公有部分隐藏了这一点。
//stack.cpp -- 栈成员函数
#include"stack.h"
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;
}
//stacker.cpp -- 测试栈类
#include<iostream>
#include<cctype>
#include"stack.h"
int main()
{
using namespace std;
Stack st; //创建一个空栈
char ch;
unsigned long po;
cout << "Please enter A to add a purchase order,\n"
<< "P to process a PO, or Q to quit.\n";
while (cin >> ch && toupper(ch) != 'Q') //C语言toupper()函数作用是将小写字母转换为大写字母
{
while (cin.get() != '\n')
continue;
if (!isalpha(ch))
//判断字符ch是否为英文字母，若为英文字母，返回非0（小写字母为2，大写字母为1）。若不是字母，返回0。
{
cout << '\a';
continue;
}
switch (ch)
{
case 'A':
case 'a':cout << "Enter a PO number to add: ";
cin >> po;
if (st.isfull())
cout << "stack already full\n";
else
st.push(po);
break;
case 'p':
case 'P':if (st.isempty())
cout << "stack already empty\n";
else
{
st.pop(po);
cout << "PO #" << po << " popped\n";
}
break;
}
cout << "Please enter A to add a purchase order,\n"
<< "P to process a PO, or Q to quit.\n";
}
cout << "Bye\n";
cin.get();
cin.get();
return 0;
}
(4) 总结
1. 每个对象都存储自己的数据，而共享类方法。 如果mr_object时对象名，try_me()是成员函数，则可以使用成员运算符句点调用成员函数：mr_object.try_me()。在OOP中，这种函数调用被称为将try_me消息发送给mr_object对象。 在try_me()方法中引用类数据成员时，将使用mr_object对象相应的数据成员。 同样，函数调用i_object.try_me()将访问i_object对象的数据成员。
2. 如果希望成员函数对多个对象进行操作，可以将额外的对象作为参数传递给它。 如果方法需要显式地引用调用它的对象，则可以使用this指针。 由于this指针被设置为调用对象的地址，因此*this是该对象的别名。