续上篇 工厂模式(一) 学生成绩管理设计
一个实体”根类” 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 ;
}
程序结果:
可以考虑,把这些老师,学生,课程全部集成到一个“系统类”中,统一管理,也是数据交流的重要媒介,这个系统类就是学生成绩管理系统的“服务端”了。
如果要做交互,就还需要一个字符或者图形界面——也可以抽象成一个类,作为用户,就是学生成绩管理系统的“客户端”了。
如果要做多用户,可以考虑把用户也作为工厂的一部分。