设计模式(2) 抽象工厂(一) 学生成绩管理系统设计

续上篇 工厂模式(一) 学生成绩管理设计

一个实体"根类" Entity , 派生出三种类——老师，学生，课程

一个接口工厂，派生出三种工厂，分别 Create 老师，学生，课程

可以考虑，不同学院之间的老师，学生，课程是不同的，例如计算机学院和经济管理学院的教师（假设无重叠），学生，课程（课程大多是不同的）。

现在，我想要产生老师的工厂，可以产生不同学院的老师，例如——这个特制工厂，可以产生计算机学院的老师，也可以产生经济管理学院的老师。

所以，在接口工厂中，需要对接口进行分类——产生计算机学院的，产生经济管理学院的，产生...... 学院的

// 计算机学院的实体
virtual Entity* Computer_Create_Entity ( const int NO , const string& name ) = 0 ;
// 经济管理学院的实体
virtual Entity* Economic_Create_Entity ( const int NO , const string& name ) = 0 ;

在实现的各类工厂中，就要实现接口工厂的分类

“教师工厂”

class Teacher_Factory : public Factory {
public:
	Entity* Computer_Create_Entity ( const int NO , 
				const string& name ) override {
		Entity* One = new Teacher ( NO , name , "计算机学院" ) ;
		Litter.emplace_back ( One ) ;    
		return One ;
	}
	Entity* Economic_Create_Entity ( const int NO , 
				const string& name ) override {
		Entity* One = new Teacher ( NO , name , "经济管理学院") ;
		Litter.emplace_back ( One ) ;    // 因为要返回, 暂不直接 emplace_back 构造
		return One ;
	}
} ;

“学生工厂”

class Student_Factory : public Factory {
public:
	Entity* Computer_Create_Entity ( const int NO , 
				const string& name ) override {
		Entity* One = new Student ( NO , name , "计算机学院" ) ;
		Litter.emplace_back ( One ) ;    
		return One ;
	}
	Entity* Economic_Create_Entity ( const int NO , 
				const string& name ) override {
		Entity* One = new Student ( NO , name , "经济管理学院") ;
		Litter.emplace_back ( One ) ;    
		return One ;
	}
} ;

“课程工厂”

class Course_Factory : public Factory {
public:
	Entity* Computer_Create_Entity ( const int NO , 
				const string& name ) override {
		Entity* One = new Course ( NO , name , "计算机学院" ) ;
		Litter.emplace_back ( One ) ;    
		return One ;
	}
	Entity* Economic_Create_Entity ( const int NO , 
				const string& name ) override {
		Entity* One = new Course ( NO , name , "经济管理学院" ) ;
		Litter.emplace_back ( One ) ;    
		return One ;
	}
} ;

再给每个 Entity 加上一个 const char* institution （或者 string）,以表征属性

全部代码如下：

#include <bits/stdc++.h>
#define rep( i , j , n ) for ( int i = int(j) ; i < int(n) ; ++i )
#define dew( i , j , n ) for ( int i = int(n-1) ; i > int(j) ; --i )
#define _PATH __FILE__ , __LINE__
typedef std::pair < int , int > P ;
using std::cin ;
using std::cout ;
using std::endl ;
using std::string ;
// 声明一个 enum class
enum class Product {
	Student , Teacher , Course 
} ;
enum class Institution {
	Computer , Economic , Mathmathics
} ;

class Entity {
protected:
	int NO ;
public:
	string name ;
	const char* institution ;
	explicit Entity ( const int _NO , const string& _name 
				, const char* _institution ) 
		: NO ( _NO ) 
		, name ( std::move ( _name ) ) 
		, institution ( _institution )
	{}
	virtual ~Entity () = default ;
	virtual void display () const = 0 ;
} ;

class Teacher : public Entity {
private:
	double salary ;
public:
	explicit Teacher ( const int _NO , const string& _name 
				, const char* _institution ) 
		: Entity ( _NO , _name , _institution ) 
		, salary ( 10000 ) 
	{}
	void display () const override {
		cout << endl << institution << "\t教师工号  :  " << NO << "\t" << name ;
		cout << "\t\t薪水  :  " << salary << endl ;
	}
} ;

class Student : public Entity {
public:
	explicit Student ( const int _NO , const string& _name 
				, const char* _institution ) 
		: Entity ( _NO , _name , _institution ) 
	{}
	void display () const override {
		cout << endl << institution << "\t学生学号  :  " << NO << "\t" << name << endl ;
	}
} ;

class Course : public Entity {
public:
	explicit Course ( const int _NO , const string& _name 
				, const char* _institution ) 
		: Entity ( _NO , _name , _institution ) 
	{}
	void display () const override {
		cout << endl << institution << "\t课程编号  :  " << NO << "\t" << name << endl ;
	}
} ;

class Factory {
protected:
	// 一个静态的垃圾收集器, 收集由该工厂的子类产生的 Entity* 指针
	static std::vector< Entity* > Litter ;
private:
	// 这个函数用 atexit 登记, main 函数结束之后启动 // 设置为私有, 只能接口释放
	static void End_OK () {
		for ( auto &it : Litter ) 
			if ( it != nullptr ) 
				delete it ;
		Litter.shrink_to_fit () ;   // 清空容器
	}
public:
	Factory () {
		// 设置一个 once_flag, 只登记一次
		static std::once_flag flag ;   
		std::call_once ( flag , [&] () { atexit ( End_OK ) ; } ) ;
	}
	virtual ~Factory () = default ;
	// 计算机学院的实体
	virtual Entity* Computer_Create_Entity ( const int NO , const string& name ) = 0 ;
	// 经济管理学院的实体
	virtual Entity* Economic_Create_Entity ( const int NO , const string& name ) = 0 ;
} ;
// 静态变量的类外声明
std::vector< Entity* > Factory::Litter ;


class Teacher_Factory : public Factory {
public:
	Entity* Computer_Create_Entity ( const int NO , 
				const string& name ) override {
		Entity* One = new Teacher ( NO , name , "计算机学院" ) ;
		Litter.emplace_back ( One ) ;    // 垃圾收集器收集
		return One ;
	}
	Entity* Economic_Create_Entity ( const int NO , 
				const string& name ) override {
		Entity* One = new Teacher ( NO , name , "经济管理学院") ;
		Litter.emplace_back ( One ) ;    // 垃圾收集器收集  // 因为要返回, 暂不直接 emplace_back 构造
		return One ;
	}
} ;

class Student_Factory : public Factory {
public:
	Entity* Computer_Create_Entity ( const int NO , 
				const string& name ) override {
		Entity* One = new Student ( NO , name , "计算机学院" ) ;
		Litter.emplace_back ( One ) ;    // 垃圾收集器收集
		return One ;
	}
	Entity* Economic_Create_Entity ( const int NO , 
				const string& name ) override {
		Entity* One = new Student ( NO , name , "经济管理学院") ;
		Litter.emplace_back ( One ) ;    // 垃圾收集器收集
		return One ;
	}
} ;

class Course_Factory : public Factory {
public:
	Entity* Computer_Create_Entity ( const int NO , 
				const string& name ) override {
		Entity* One = new Course ( NO , name , "计算机学院" ) ;
		Litter.emplace_back ( One ) ;    // 垃圾收集器收集
		return One ;
	}
	Entity* Economic_Create_Entity ( const int NO , 
				const string& name ) override {
		Entity* One = new Course ( NO , name , "经济管理学院" ) ;
		Litter.emplace_back ( One ) ;    // 垃圾收集器收集
		return One ;
	}
} ;

int main () {
	Factory* A = new Teacher_Factory () ;
	Factory* B = new Student_Factory () ;
	Factory* C = new Course_Factory () ;

	cout << endl << "以下是计算机学院的师生课程情况" << endl ;
	Entity* E = A->Computer_Create_Entity ( 1000001 , "张" ) ; 
	Entity* F = B->Computer_Create_Entity ( 2000001 , "杨" ) ; 
	Entity* G = C->Computer_Create_Entity ( 3000001 , "数据结构" ) ; 
	E->display () ;
	F->display () ;
	G->display () ;

    cout << endl << "以下是经济管理学院的师生课程情况" << endl ;
	Entity* H = A->Economic_Create_Entity ( 1000002 , "谭" ) ; 
	Entity* I = B->Economic_Create_Entity ( 2000002 , "丁" ) ; 
	Entity* J = C->Economic_Create_Entity ( 3000002 , "资本论" ) ; 
	H->display () ;
	I->display () ;
	J->display () ;
    
	delete A , delete B , delete C ;
	A = B = C = nullptr ;
	return 0 ;
}

程序结果：

可以考虑，把这些老师，学生，课程全部集成到一个“系统类”中，统一管理，也是数据交流的重要媒介，这个系统类就是学生成绩管理系统的“服务端”了。

如果要做交互，就还需要一个字符或者图形界面——也可以抽象成一个类，作为用户，就是学生成绩管理系统的“客户端”了。

如果要做多用户，可以考虑把用户也作为工厂的一部分。