C++ day17 类（四）类作用域， ADT

爱被打了一巴掌 2023-07-15 09:03 37阅读 0赞

### 文章目录 ###

*  类作用域
 *   *  示例1 内联构造函数，还使用了默认参数
     *  定义有类作用域的符号常量（由所有对象共享）
     *   *  法1：用关键字static创建静态类成员
         *  法2：在类中声明一个匿名枚举
     *  作用域内枚举（C++11，用枚举名来限定枚举量，枚举量的作用域是类）
     *   *  类型安全：作用域内枚举不能隐式地转换为整型（常规枚举将自动转换为整型）
 *  ADT（用类表示更通用的概念）
 *   *  栈
     *   *  示例 把类设计和存储的数据类型隔离（用typedef或者类模板）
         *  容器：一种更通用的抽象，能存储多个数据项就是容器

# 类作用域 #

之前说过了**全局作用域**（文件作用域）和**局部作用域**（代码块作用域），C++还增加了一个类作用域，即类内定义的名称们，比如数据成员的名字和函数成员名，作用域为整个类。类内已知，类外不知，得用类和作用域解析运算符。

不可能从外部直接访问类的成员，就算是公有成员函数也需要用对象加成员运算符来访问。

## 示例1 内联构造函数，还使用了默认参数 ##

//stock.h
    #ifndef STOCK_H_
    #define STOCK_H_
    
    class Ik
    { 
    private:
    	int fuss;//具有类作用域 class scope
    public:
    	Ik(int f = 9){ fuss = f;}//内联构造函数，还使用了默认参数
    	void ViewIk() const;//const成员函数
    };
    
    #endif // STOCK_H_

#include <iostream>
    #include "stock.h"
    
    int main()
    { 
    	Ik * pik = new Ik;//用new创建匿名对象，用指针管理它
    	Ik ee = Ik(8);//构造函数由于和类名相同，所以在类作用域中
    	ee.ViewIk();//对象ee把名称ViewIk放在Ik scope中
        pik->ViewIk();//指向对象的指针把ViewIk放在类作用域中
    
        return 0;
    }

//Stock.cpp
    #include <iostream>
    #include "stock.h"
    
    void Ik::ViewIk() const//Ik::把ViewIk放在Ik scope中
    { 
    	std::cout << fuss << std::endl;//在类的方法定义中，类名称都在作用域内，即方法定义也是作用域的一部分
    }

我忘记了上面ViewIk函数最后的const了

输出

8
    9

## 定义有类作用域的符号常量（由所有对象共享） ##

定义有类作用域的常量的关键是：不能让每个对象都有一个该常量的副本，而是只能有一个副本，但大家共享。  
所以肯定不是：

class Stock
    { 
    	private:
    	const int SIZE = 20;
    	double costs[SIZE];
    };

因为这样就是每个对象都有一个SIZE成员，并不是所有对象共享

实际上，要做到这一点，有两种方式

### 法1：用关键字static创建静态类成员 ###

在上面的代码前面加个static，这样SIZE就成了静态的类成员，即存储期是静态的，那么就会单独存在静态变量的专用内存区域，不会存储在对象中。于是第一个对象创建后，SIZE变量就存在静态内存中了，后面再创建新对象，不会再创建SIZE变量，而是直接使用之前创建的。

class Stock
    { 
    	private:
    	static const int SIZE = 20;
    	double costs[SIZE];
    };

### 法2：在类中声明一个匿名枚举 ###

这样做的区别是：并不会创建枚举类型的类成员，只是创建了符号常量而已。

class Stock
    { 
    	private:
    	enum { SIZE = 20};
    	double costs[SIZE];
    };

其实ios\_base类的公有部分就这么做的，fixed就是ios\_base类的一个典型的枚举量。

## 作用域内枚举（C++11，用枚举名来限定枚举量，枚举量的作用域是类） ##

以前我们知道，枚举实际上是整型，编译器会用某种适合的整型来表示枚举，但是你不知道具体使用哪一种类型，因为这和编译器的实现有关。  
但是作用域内枚举的底层类型就是int，十分确定。

也可以指定底层实现类型为short，但必须是整型哈

enum class: short pizza { Small, Medium, Large};

当两个枚举定义中的枚举量发生同名冲突时，编译器会报错：

enum egg { Small, Medium, Large, Jumbo};
    enum shoe { Small, Medium, Large, Xlarge};

为了解决这个问题， C++11推出了作用域内枚举，即枚举量的作用域是类

//声明
    enum class egg { Small, Medium, Large, Jumbo};
    enum class shoe { Small, Medium, Large, Xlarge};

或者用struct

//声明
    enum struct egg { Small, Medium, Large, Jumbo};
    enum struct shoe { Small, Medium, Large, Xlarge};

用枚举名来限定枚举量

egg choice = egg::Small;
    shoe My = shoe::Medium;

### 类型安全：作用域内枚举不能隐式地转换为整型（常规枚举将自动转换为整型） ###

#include <iostream>
    
    int main()
    { 
    	enum egg_unscoped { Small, Medium, Large, Jumbo};
    	enum class egg_scoped { Small, Medium, Large, Xlarge};
    
        egg_unscoped one = Small;
        egg_scoped two = egg_scoped::Medium;
    
        int king = one;//把普通枚举量进行隐式类型转换
        //int ring = two;//报错，把作用域内枚举量进行隐式类型转换
        int three = int(egg_scoped::Medium);//显式类型转换
    
        if (king < Jumbo)
            std::cout << "Jumbo converted to int before comparison.\n";
        if (king < three)
            std::cout << "Type conversion.\n";
        if (king < egg_scoped::Medium)//报错
            std::cout << "Not allowed: < not defined for scoped enum.\n";
        return 0;
    }

# ADT（用类表示更通用的概念） #

之前一直作为示例介绍的Stock类是一个**非常具体**的类，针对实际问题。而 ADT是计算机专家们所说的一个术语，抽象数据类型，这种数据类型**高度抽象**，它**以通用的方式描述数据类型，和语言无关所以没有引入任何细节**。所以用类去实现它非常好。

## 栈 ##

### 示例 把类设计和存储的数据类型隔离（用typedef或者类模板） ###

//stack.h
    #ifndef STACK_H_
    #define STACK_H_
    typedef unsigned long Item;//这使得不用特定类型定义栈，而是通用类型Item,只要想改，直接改这里即可
    //这种把类设计和存储的数据类型隔离是非常重要的，类模板提供了更强大的方法做到这一点
    
    class Stack
    { 
    	private:
    		enum { MAX = 20};
    		Item items[MAX];//私有部分表示用数组实现栈（公有部分隐藏了这一点），也可以用其他方式比如链表
    		int top;//index for top stack item栈顶索引
    	public:
    		Stack();
    		bool isempty() const;
    		bool isfull() const;
    		bool push(const Item &item);
    		bool pop(Item & item);//把栈顶元素给item，所以要修改item，不能const
    };
    
    
    #endif // STOCK_H_

//Stack.cpp
    #include <iostream>
    #include "stack.h"
    
    Stack::Stack()
    { 
    	top  = 0;//初始化栈顶索引
    	items[MAX] = { };//初始化为0
    }
    
    bool Stack::isempty() const
    { 
    	if (top == 0)
    		return true;
    	else
    		return false;
    	//优雅简洁版
    	//return top == 0;
    }
    
    bool Stack::isfull() const
    { 
    	if (top == MAX)
    		return true;
    	else
    		return false;
    	//优雅简洁版
    	//return top == MAX;
    }
    
    bool Stack::push(const Item & item)
    { 
    	bool temp = isfull();
    	if (!temp)
    		items[top++] = item;
    
    	return temp;
    }
    
    bool Stack::pop(Item & item)
    { 
    	bool temp = isempty();
    
    	if(!temp)
    		item = items[--top];//千万别写为top--！！！！因为top是栈顶，还没存东西，是下一次要存东西的地址
    	return temp;
    }

//main.cpp
    #include <iostream>
    #include <cctype>
    #include "stack.h"
    
    int main()
    { 
    	using std::cout;
    	using std::cin;
    
    	Stack st;
    	char ch;
    	unsigned long po;
    
    	cout << "Enter A to add a purchase order,\n"
    		 << "P to process a PO, or Q to quit.\n";
    
    	while (cin >> ch && toupper(ch) != 'Q')
    		{ 
    			//处理输入缓冲
    			while (cin.get() != '\n')
    				;
    			//如果输入不是字符，则继续
    			if (!isalpha(ch))
    				{ 
    					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;
    					default:
    						cout << "Enter A or P!\n";
    						continue;
    							
    						
    							
    				}
    			cout << "Enter A to add a purchase order,\n"
    		 		 << "P to process a PO, or Q to quit.\n";
    		}
    	cout << "Bye!\n";
    
    
        return 0;
    }

输出

Enter A to add a purchase order,
    P to process a PO, or Q to quit.
    A
    Enter a PO number to add: 1234
    Enter A to add a purchase order,
    P to process a PO, or Q to quit.
    P
    PO #1234 popped!
    Enter A to add a purchase order,
    P to process a PO, or Q to quit.
    A
    Enter a PO number to add: 2345
    Enter A to add a purchase order,
    P to process a PO, or Q to quit.
    A
    Enter a PO number to add: 4567
    Enter A to add a purchase order,
    P to process a PO, or Q to quit.
    A
    Enter a PO number to add: 1289
    Enter A to add a purchase order,
    P to process a PO, or Q to quit.
    P
    PO #1289 popped!
    Enter A to add a purchase order,
    P to process a PO, or Q to quit.
    P
    PO #4567 popped!
    Enter A to add a purchase order,
    P to process a PO, or Q to quit.
    P
    PO #2345 popped!
    Enter A to add a purchase order,
    P to process a PO, or Q to quit.
    P
    Stack already empty.
    Enter A to add a purchase order,
    P to process a PO, or Q to quit.
    A
    Enter a PO number to add: 67
    Enter A to add a purchase order,
    P to process a PO, or Q to quit.
    W
    Enter A or P!
    A
    Enter a PO number to add: 234
    Enter A to add a purchase order,
    P to process a PO, or Q to quit.
    P
    PO #234 popped!
    Enter A to add a purchase order,
    P to process a PO, or Q to quit.
    P
    PO #67 popped!
    Enter A to add a purchase order,
    P to process a PO, or Q to quit.
    P
    Stack already empty.
    Enter A to add a purchase order,
    P to process a PO, or Q to quit.
    Q
    Bye!

我出现的问题有：

*  忘记在函数头写const，只在原型记得写，写方法定义时完全忘了
 *  对while循环输入始终有点犯怵，因为考虑的太多了，主要是输入的处理上，不能遗漏，不然就会有漏洞。我这次还不错，看错书上一个漏洞并处理了（即我在switch中加了default，用于处理不是A或P的字母输入）。
 *  自己写类方法时，虽然写的慢，最后也写对了，但是我发现我一是容易忘记加Stack::前缀，二是容易忘记把合适的函数的原型设置为const，三是写定义时也易忘记const。四是我的代码不够简洁优美，这大概是因为我写的少见得少，以后加强。

### 容器：一种更通用的抽象，能存储多个数据项就是容器 ###

之前看到容器，container，一直觉得很困惑，原来是一个抽象概念，只要装了多个数据项就是容器。所以数组，结构，结构数组，链表，栈，队列都是容器。