cpp: Template Mothod Pattern

文章来源《C++新经典设计模式》 王健伟编著  清华大学出版社

 

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
// TemplateMethonPattern.h : 此文件包含 "TemplateMethonPattern" 类。Template Mothod Pattern C++ 14
// 2023年4月29日 涂聚文 Geovin Du edit.
 
#define _UNICODE
 
#pragma once
#ifndef TEMPLATEMOTHOD_H
#define TEMPLATEMOTHOD_H
 
#include <iostream>
 
 
#ifdef _DEBUG   //只在Debug（调试）模式下
#ifndef DEBUG_NEW
#define DEBUG_NEW new(_NORMAL_BLOCK,__FILE__,__LINE__) //重新定义new运算符
#define new DEBUG_NEW
#endif
#endif
 
using namespace std;
 
 
namespace TemplateMothod
{
 
    /// <summary>
    ///
    /// </summary>
    class TemplateMethonPattern
    {
 
 
 
 
    private:
        //角色属性
 
        /// <summary>
        /// 生命值
        /// </summary>
        int m_life;  
        /// <summary>
        /// 魔法值
        /// </summary>
        int m_magic;  
        /// <summary>
        /// 攻击力
        /// </summary>
        int m_attack; 
 
    public:
 
        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="life"></param>
        /// <param name="magic"></param>
        /// <param name="attack"></param>
        TemplateMethonPattern(int life, int magic, int attack) :m_life(life), m_magic(magic), m_attack(attack) {}
 
 
    public:
 
        /// <summary>
        ///
        /// </summary>
        void JNBurn();
 
    };
 
}
 
#endif
 
#define UNICODE
 
 
// TemplateMethonPattern.cpp : 此文件包含 "TemplateMethonPattern" 类。Template Mothod Pattern C++ 14
// 2023年4月29日 涂聚文 Geovin Du edit.
 
 
 
#include "TemplateMethonPattern.h"
using namespace std;
 
 
namespace TemplateMothod
{
 
 
    /// <summary>
    ///
    /// </summary>
    void TemplateMethonPattern::JNBurn() //技能“燃烧”
    {
        cout << "让所有敌人每人失去500点生命值，相关逻辑代码在这里略......" << endl;
        cout << "主角自身失去300点生命值" << endl;
        m_life -= 300;
        cout << "播放技能“燃烧”的技能特效给玩家看" << endl;
    }
 
}

　　

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
// DuFighter.h : 此文件包含 "DuFighter" 类。Template Mothod Pattern C++ 14
// 2023年4月29日 涂聚文 Geovin Du edit.
 
 
 
#pragma once
#ifndef DUFIGHTER_H
#define DUFIGHTER_H
 
#include <iostream>
 
 
#ifdef _DEBUG   //只在Debug（调试）模式下
#ifndef DEBUG_NEW
#define DEBUG_NEW new(_NORMAL_BLOCK,__FILE__,__LINE__) //重新定义new运算符
#define new DEBUG_NEW
#endif
#endif
 
 
using namespace std;
 
 
 
namespace DuTemplateMothod
{
    /// <summary>
    ///
    /// </summary>
    class DuFighter
    {
 
    public:
        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="life"></param>
        /// <param name="magic"></param>
        /// <param name="attack"></param>
        DuFighter(int life, int magic, int attack) :m_life(life), m_magic(magic), m_attack(attack) {}
        /// <summary>
        /// 做父类时析构函数应该为虚函数
        /// </summary>
        virtual ~DuFighter() {}
        /// <summary>
        /// 技能“燃烧”
        /// </summary>
        void JNBurn(); //
 
 
    private:
        /// <summary>
        /// 判断是否能使用技能“燃烧”，这是纯虚函数声明，子类中必须重新实现canUseJN
        /// </summary>
        /// <returns></returns>
        virtual bool canUseJN() = 0; //
 
    protected: //可能被子类访问的成员，用protected修饰   
 
        //角色属性
        /// <summary>
        ///  //魔法值
        /// </summary>
        int m_life; 
        /// <summary>
        /// 生命值
        /// </summary>
        int m_magic; 
        /// <summary>
        /// 攻击力
        /// </summary>
        int m_attack; 
 
 
    private:
        /// <summary>
        /// 函数体为空，表示啥也不做，如果要求必须在子类中重新实现该虚函数，则可以将该函数写成纯虚函数
        /// </summary>
        virtual void effect_enemy() {}
        /// <summary>
        ///
        /// </summary>
        virtual void effect_self() {};
 
        /// <summary>
        /// 所有主角播放的技能特效都相同，因此不用写成一个虚函数并在子类中实现技能特效的播放
        /// </summary>
        void play_effect()
        {
            cout << "播放技能“燃烧”的技能特效给玩家看" << endl;
        }
 
 
 
 
 
    };
 
}
 
#endif
// DuFighter.cpp : 此文件包含 "DuFighter" 类。Template Mothod Pattern C++ 14
// 2023年4月29日 涂聚文 Geovin Du edit.
 
#include "DuFighter.h"
 
using namespace std;
 
 
 
namespace DuTemplateMothod
{
 
 
    /// <summary>
    /// 技能“燃烧”
    /// </summary>
    void DuFighter::JNBurn()
    {
        if (canUseJN() == false) //如果不能使用该技能，则直接返回
            return;
 
        effect_enemy(); //对敌人产生的影响
        effect_self(); //对主角自身产生的影响
        play_effect(); //播放技能“燃烧”的技能特效
    }
 
}

　　

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
// DuFatherWarrior.h : 此文件包含 "DuFatherWarrior" 类。Template Mothod Pattern C++ 14
// 2023年4月29日 涂聚文 Geovin Du edit.
 
 
#pragma once
#ifndef DUFATHERWARRIOR_H
#define DUFATHERWARRIOR_H
 
 
#include <iostream>
#include "DuFighter.h"
 
 
#ifdef _DEBUG   //只在Debug（调试）模式下
#ifndef DEBUG_NEW
#define DEBUG_NEW new(_NORMAL_BLOCK,__FILE__,__LINE__) //重新定义new运算符
#define new DEBUG_NEW
#endif
#endif
 
 
using namespace std;
 
 
 
namespace DuTemplateMothod
{
 
 
    /// <summary>
    ///
    /// </summary>
    class DuFatherWarrior :public DuFighter
    {
 
 
    public:
        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="life"></param>
        /// <param name="magic"></param>
        /// <param name="attack"></param>
        DuFatherWarrior(int life, int magic, int attack) :DuFighter(life, magic, attack) {}
 
 
    private:
        /// <summary>
        /// 对敌人产生的影响
        /// </summary>
        virtual void effect_enemy()
        {
            cout << "战士主角_让所有敌人每人失去500点生命值，相关逻辑代码在这里略......" << endl;
        }
        /// <summary>
        /// 对主角自身产生的影响
        /// </summary>
        virtual void effect_self()
        {
            cout << "战士主角_自身失去300点生命值" << endl;
            m_life -= 300;
        }
 
    private:
        /// <summary>
        /// 判断是否能使用技能“燃烧”
        /// </summary>
        /// <returns></returns>
        virtual bool canUseJN()
        {
            if (m_life < 300) //生命值不够300点，不能使用技能“燃烧”
                return false;
            return true;
        }
 
 
    };
}
#endif

　　

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
// DuFatherWarrior.h : 此文件包含 "DuFatherWarrior" 类。Template Mothod Pattern C++ 14
// 2023年4月29日 涂聚文 Geovin Du edit.
#pragma once
 
#ifndef FATHERMAGE_H
#define FATHERMAGE_H
 
#include <iostream>
#include "DuFighter.h"
 
using namespace std;
 
 
 
namespace DuTemplateMothod
{
 
    /// <summary>
    ///
    /// </summary>
 
    class FatherMage :public DuFighter
    {
    public:
        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="life"></param>
        /// <param name="magic"></param>
        /// <param name="attack"></param>
        FatherMage(int life, int magic, int attack) :DuFighter(life, magic, attack) {}
 
 
 
    private:
        /// <summary>
        /// 对敌人产生的影响
        /// </summary>
        virtual void effect_enemy()
        {
            cout << "法师主角_让所有敌人每人失去650点生命值，相关逻辑代码在这里略......" << endl;
        }
        /// <summary>
        /// 对主角自身产生的影响
        /// </summary>
        virtual void effect_self()
        {
            cout << "法师主角_自身失去100点魔法值" << endl;
            m_magic -= 100;
        }
 
    private:
        /// <summary>
        /// 判断是否能使用技能“燃烧”
        /// </summary>
        /// <returns></returns>
        virtual bool canUseJN()
        {
            if (m_magic < 100) //魔法值不够100点，不能使用技能“燃烧”
                return false;
            return true;
        }
 
 
    };
 
}
 
#endif

　　

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
// GeovinDu.h : 此文件包含 "GeovinDu" 类。Template Mothod Pattern C++ 14
// 2023年4月29日 涂聚文 Geovin Du edit.
#pragma once
#ifndef GEOVINDU_H
#define GEOVINDU_H
 
using namespace std;
 
 
 
namespace DuTemplateMothod
{
 
 
 
    /// <summary>
    ///
    /// </summary>
 
    class GeovinDu
    {
 
    private:
 
    public:
        /// <summary>
        /// 模板方法模式
        /// </summary>
        void displayTemplateMothod();
 
 
    };
}
 
#endif
 
 
// GeovinDu.cpp : 此文件包含 "GeovinDu" 类。Template Mothod Pattern C++ 14
// 2023年4月29日 涂聚文 Geovin Du edit.
 
 
#include "GeovinDu.h"
#include <iostream>
#include "TemplateMethonPattern.h"
#include "DuFatherWarrior.h"
#include "DuFighter.h"
#include "FatherMage.h"
 
 
 
//#include <boost/type_index.hpp>
using namespace std;
//#pragma warning(disable : 4996)
using namespace TemplateMothod;
 
 
namespace DuTemplateMothod
{
 
 
 
    /// <summary>
    /// 模板方法模式
    /// </summary>
    void GeovinDu::displayTemplateMothod()
    {
 
 
        _CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF);//程序退出时检测内存泄漏并显示到“输出”窗口
 
        TemplateMothod::TemplateMethonPattern  mroleobj(1000, 0, 200); //创建主角
         mroleobj.JNBurn(); //主角释放“燃烧”技能
 
     
        DuTemplateMothod::DuFighter* prole_war = new DuTemplateMothod::DuFatherWarrior(1000, 0, 200); //创建战士主角，注意这是父类指针指向子类对象以利用多态特性
        prole_war->JNBurn();  //战士主角释放“燃烧”技能
 
        cout << "-------------------------" << endl; //分隔线，以更醒目的显示信息
 
        DuTemplateMothod::DuFighter* prole_mag =  new DuTemplateMothod::FatherMage(800, 200, 300); //创建法师主角，注意这是父类指针指向子类对象以利用多态特性
        prole_mag->JNBurn();  //法师主角释放“燃烧”技能
 
        //释放资源
        delete prole_war;
        delete prole_mag;
             
 
        DuTemplateMothod::DuFighter* prole_war2 = new DuTemplateMothod::DuFatherWarrior(50, 0, 200); //创建生命值只有50的战士主角
        prole_war2->JNBurn();  //该战士无法成功释放“燃烧”技能，不输出任何结果
        delete prole_war2;
    }
 
}

　　

调用：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
// DesignPatternscpp.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//
#define _UNICODE
 
 
#include <iostream>
 
#include "GeovinDu.h"
 
 
using namespace std;
using namespace DuTemplateMothod;
 
 
 
int main()
{
    std::cout << "Hello World! 涂聚文 \n";
 
    GeovinDu geovin;
    geovin.displayTemplateMothod();
 
    system("pause");
 
    return 0;
 
 
}
 
// 运行程序: Ctrl + F5 或调试 >“开始执行(不调试)”菜单
// 调试程序: F5 或调试 >“开始调试”菜单
 
// 入门使用技巧:
//   1. 使用解决方案资源管理器窗口添加/管理文件
//   2. 使用团队资源管理器窗口连接到源代码管理
//   3. 使用输出窗口查看生成输出和其他消息
//   4. 使用错误列表窗口查看错误
//   5. 转到“项目”>“添加新项”以创建新的代码文件，或转到“项目”>“添加现有项”以将现有代码文件添加到项目
//   6. 将来，若要再次打开此项目，请转到“文件”>“打开”>“项目”并选择 .sln 文件
#define UNICODE

　　

输出：

?
1
2
3
4
5
6
7
8
9
10
11
12
Hello World! 涂聚文
让所有敌人每人失去500点生命值，相关逻辑代码在这里略......
主角自身失去300点生命值
播放技能“燃烧”的技能特效给玩家看
战士主角_让所有敌人每人失去500点生命值，相关逻辑代码在这里略......
战士主角_自身失去300点生命值
播放技能“燃烧”的技能特效给玩家看
-------------------------
法师主角_让所有敌人每人失去650点生命值，相关逻辑代码在这里略......
法师主角_自身失去100点魔法值
播放技能“燃烧”的技能特效给玩家看
请按任意键继续. . .

　　

 

 

posted @   ®Geovin Du Dream Park™  阅读(19)  评论(0)  编辑  收藏  举报
相关博文：
·  cpp: Memento Pattern
·  cpp: Simple Factory Pattern
·  c/c++设计模式--模板方法模式
·  c/c++设计模式---策略模式
·  C++-高级编程秘籍（全）
阅读排行：
· 25岁的心里话
· 闲置电脑爆改个人服务器（超详细） #公网映射 #Vmware虚拟网络编辑器
· 基于 Docker 搭建 FRP 内网穿透开源项目（很简单哒）
· 零经验选手，Compose 一天开发一款小游戏！
· 一起来玩mcp_server_sqlite，让AI帮你做增删改查！！
< 2025年3月 >
日 一 二 三 四 五 六
23 24 25 26 27 28 1
2 3 4 5 6 7 8
9 10 11 12 13 14 15
16 17 18 19 20 21 22
23 24 25 26 27 28 29
30 31 1 2 3 4 5
点击右上角即可分享
微信分享提示