C++基础（五）

C++的类（继续）

上一节的补充：
在创建类对象的时候，如果在类名前加上const关键字来修饰，那么创建的对象其中的数据就是不可被修改的。

const Stock num3("abc", 123, 212);  //创建了一个const型的对象
num3.show(); //报错

对于const型的类对象，编译器无法确保调用成员函数会不会对数据成员进行修改，因此不允许这样写代码，解决的办法就是在声明与定义类成员函数的时候，也使用const关键字进行修饰。

void show() const;  //声明加上const关键字
void Stock::show() const{}  //定义函数时在括号后面加上const关键字

对于C++11及以上的编译器支持使用列表初始化方法来初始化对象：

Stock ob1{param1, param2,param3...};
Stock ob2={param1, param2, param3..};

都是允许的写法。

一、 this指针
参照书上例题，假定设计一个需要比较两个对象总价最大值的函数（total_val),并返回其中较大的一个对象值。
首先在类内部对该函数进行声明：

const Stock& topval(const Stock& s) const;

对于这段代码读起来可能比较难懂，从左开始看：
const Stock& 表示该函数（topval)的返回值类型是一个const型的Stock类的引用。
topval(const Stock &)表示的该函数传入的参数类型必须是Stock类的引用
最后一个const表示，该函数可以调用const类型的数据成员而不会对其数据进行修改。

在类外对该函数进行定义：

const Stock& Stock::topval(const Stock& s) const
{
	if (s.total_val > total_val)
	{
		return s;
	}
	else
	{
		return *this;
	}
}

this指针的用处在这里就体现出来了，对于上面代码返回值的类型，如果返回的是该对象内的值，那么this指针就会指向调用成员的对象。

num1.topval(num2);  //此时的this指针指向调用的num1对象
num2.topval(num1);  //此时的this对象指向调用的num2对象

同样的，在函数括号后面使用const关键字来修饰，就不能够通过this指针来修改对象的值。·
因为this是指针，而我们返回的不是对象的地址而是对象本身，因此这里要加上解引用符号 *。
笔记：
允许代码的时候发现了一个错误就是，调用了show（）函数在显示信息的时候，股票总价（total_val)总是显示一个奇怪的数字—9.25596e+061，无论怎么更改也不行，后来明白了我们之前写的代码中，股票总价需要通过一个内联函数计算来完成，而我们在初始化的时候并没有初始化total_val这个变量，这里对构造函数进行修改，将set_total函数在构造函数里面执行一遍就好了。

Stock::Stock(const string &co, long sh, double share_v)
{
	company = co;
	shares = sh;
	share_val = share_v;
	set_total();
}

二、对象数组
实际应用中我们通常需要创建多个对象，因此把对象集中放在一个数组里面可以更加方便进行管理。
创建对象数组时，如果对象的类使用的是默认构造函数，那么只要下面这样定义即可：

 Stock  ob_list[10];

创建了一个对象数组，里面有十个Stock类的对象。
如果我们定义了自己的构造函数，就像Stock类，就需要在创建对象时也完成初始化对象：

Stock list[2] = {
	Stock("dd",1,2),
	Stock("ss",2,3)
	// 创建了两个对象
};

通过下标加.的方式，可以访问对象里面的成员函数：

Stock list[2] = {
	Stock("dd",1,2),
	Stock("ss",2,3),

};
list[1].show();

注：这里访问的是第二个对象，因为第一个对象的下标为0
对于有多个重载构造函数的类，在列表里也可以使用不同的初始化方式。
如果创建的列表对象数多于初始化对象数，那么剩下的对象编译器将使用默认构造函数（在没有自定义构造函数的情况下，否则将报错）
十个对象，仅仅初始化两个：

Stock list[10] = {
	Stock("dd",1,2),
	Stock("ss",2,3),

};

报错：
创建一个const型指针来指向一个数组对象：

const Stock* plist = &list[1];
const Stock& plist1 = list[0];
const Stock* p = &plist->topval(list[0]);

第一行是指针，第二行时引用，第三行时创建了一个新指针来接收topval返回的新对象。
可以看出来指针和引用的区别，引用为该对象创建了另一个名字，叫做plist1，并不是单纯的浅拷贝。

Stock list[2] = {
	Stock("dd",1,2),
	Stock("ss",2,3),

};
const Stock* plist = &list[1];
Stock& plist1 = list[0];
const Stock* p = &plist->topval(list[0]);
//cout << plist;
plist1.show();
list[0].buy(100, 20);
plist1.show();
list[0].show();

通过这段代码可以验证，改变源对象的值，引用的对象值也随之改变，其实也就是两个名字都指向了同一个对象。
关于指针的一点思考：指针前面的类型前缀并不表示指针的类型，而是表示指针指向的对象的类型；类似的，定义函数的类型声明并不表示函数类型，而是表示函数返回值的类型

三、类的作用域
在类中定义的名称的作用域都为整个类，因此该名称只在该类中是已知的，在类外不可知，这样的话不同的类就算使用了相同的的类成员名称也是没有关系的。同样，想要调用类内部的资源，必须通过该类的对象来实现。
教材原话：有时候使符号常量的作用域为类很有用，因此创建一个由所有对象共享的常量是个不错的主意，但是实际上行不通：

class 类
{
private：
	const int param = 10;
	.....

原因是类只是描述了对象的形式，并没有创建对象。因此在创建对象之前，没有用于存储值的空间。下面介绍两种实现该功能的方法：
1、使用枚举来完成

class l类
{
private：
	enum{Months = 12};
	double costs[Months];
....

用这种方式声明枚举并不会创建类数据成员，所有对象中都不包含枚举。另外，Months只是一个符号名称，在作用域为整个类的代码中遇到他时，编译器将会用数值（在这里是12）来代替它。
2、使用static关键字

class 2类
{
private:
	static const int Months = 12;
......

这样就可以创建一个名为Months的常量，该常量将与其他静态变量存储在一起，而不是存储在对象里。

四、抽象数据类型
Stock类非常具体，然而实际中常常通过定义类来表示更通用的概念。创建一个stack类来说明这种思想：

#pragma once
#include<iostream>

typedef unsigned long item;  //使用typedef关键字可以提高代码可移植性


class Stack
{
private:
	enum{MAX = 10};
	item items[MAX];
	int top;
public:
	Stack();
	bool isempty() const;
	bool isfull() const;
	bool push(item& item);
	bool pop(item& item);
	void show();
};

头文件,在此基础上我又添加了一个显示函数来显示对象内容。
函数声明写在.cpp文件里：

#include "stack.h"

Stack::Stack()
{
	top=0;
}

bool Stack::isempty()const
{
	return top == 0;  //判断等式是否成立,成立返回时true，不成立返回false。
}

bool Stack::isfull()const
{
	return top == MAX; 
}

bool Stack::push(item& item)
{
	if (top < MAX)
	{
		items[top] = item;
		top++;
		/*l另外一种写法，更加简洁
		items[++top] = item;
		*/
	}
	else
		return false;
}

bool Stack::pop(item& item)
{
	if (top > 0)
	{
		item = items[--top];
	}
	else
		return false;
}

void Stack::show()
{
	std::cout << "the store is:";
	for (int i = 0; i < MAX; i++)
	{
		std::cout<<items[i];	
	}
	std::cout << '\n';
}

看了代码感觉写的还是不够全面，于是在此基础上，我自己改了改又，试了几遍觉得舒服了。把使用类的过程代码也封装成了一个函数。
首先把使用类的代码函数也封装在类成员函数声明的文件里，这样使得main函数体内尽可能地简单，最好只有调用。主要就是解决了一个循环输入问题，剩下还有很多问题.😁

Stack use_stack()
{
	Stack mystack;
	char ch;
	char temp;
	std::cout << "enter A to push to stack\n"
		<< "enter P to pop from stack, Q to quit.\n";
	while (std::cin >> ch && toupper(ch) != 'Q')
	{	
		while (std::cin.get() != '\n')
			continue; //用来处理回车键
		switch (ch)
		{
		case 'A':
			std::cout << "push a word unless Q" << std::endl;
			while (1)
			{
				std::cout << "enter a word:";
				std::cin >> temp;
				if (temp != 'Q')
				{
					if (mystack.isfull())
					{
						std::cout << "stack full" << std::endl;
						break;
					}
					else
						mystack.push(temp);
				}
				else
					break;
			}
			break;
		case 'P':
			if (mystack.isempty())
			{
				std::cout << "satck empty" << std::endl;
			}
			else
				mystack.pop(temp);
			break;
		default:
			continue;
		}

	}
	mystack.show();
	return mystack;
}

这样的话，main函数体内只要一行代码了：

int main()
{
	Stack mystack=use_stack();
......

但是得在main文件内声明一下这个函数，不然用不了。
显示效果图如下：