设计模式(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 ;  
}

程序结果：

C++11

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

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

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

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

“教师工厂”

“学生工厂”

“课程工厂”

全部代码如下：

猜你喜欢