【无标题】

1. #include <iostream>
2. #include <cstring>
3. #include <cstdlib>
4. #include <unistd.h>
5. #include <sstream>
6. #include <vector>
7. #include <memory>
9. using namespace std;
11. // 前向声明武器类
12. class Weapon;
14. // 英雄基类
15. class Hero {
16. private:
17.     int hp;        // 生命值
18.     int atk;       // 攻击力
19.     int def;       // 防御力
20.     int spd;       // 速度
21.     string profession; // 职业类型
23. public:
24.     // 构造函数（默认职业为战士）
25.     Hero(int h = 0, int a = 0, int d = 0, int s = 0, string p = "Warrior")
26.         : hp(h), atk(a), def(d), spd(s), profession(p) {}
28.     // 属性设置方法
29.     void setAtk(int a) { atk = a; }
30.     void setDef(int d) { def = d; }
31.     void setSpd(int s) { spd = s; }
32.     void setHp(int h) { hp = h; }
33.     void setProfession(string p) { profession = p; }
35.     // 属性获取方法
36.     int getAtk() { return atk; }
37.     int getDef() { return def; }
38.     int getSpd() { return spd; }
39.     int getHp() { return hp; }
40.     string getProfession() const { return profession; }
42.     // 装备武器方法（通过多态调用不同武器的属性加成）
43.     void equipWeapon(Weapon* w);
44. };
46. // 武器基类（抽象类）
47. class Weapon {
48. private:
49.     int atk; // 基础攻击力
51. public:
52.     // 构造函数（默认攻击力为1）
53.     Weapon(int atk = 1) : atk(atk) {}
55.     // 属性设置方法
56.     void setAtk(int a) { atk = a; }
57.     int getAtk() { return atk; }
59.     // 基础属性加成方法（所有武器都增加攻击力）
60.     virtual void getAttr(Hero& hero) {
61.         int new_atk = hero.getAtk() + atk;
62.         hero.setAtk(new_atk);
63.     }
65.     // 纯虚函数，用于获取武器类型
66.     virtual string getType() = 0;
67.     virtual ~Weapon() {} // 虚析构函数
68. };
70. // 长剑类（继承自武器）
71. class Sword : public Weapon {
72. private:
73.     int hp; // 额外生命加成
75. public:
76.     // 构造函数
77.     Sword(int atk = 1, int hp = 1) : Weapon(atk), hp(hp) {}
79.     // 设置/获取额外生命值
80.     void setHp(int h) { hp = h; }
81.     int getHp() { return hp; }
83.     // 重写属性加成方法（攻击+生命）
84.     virtual void getAttr(Hero& hero) {
85.         Weapon::getAttr(hero); // 调用基类攻击加成
86.         int new_hp = hero.getHp() + hp;
87.         hero.setHp(new_hp);
88.     }
90.     // 重写获取武器类型
91.     string getType() override { return "Sword"; }
92. };
94. // 匕首类（继承自武器）
95. class Blade : public Weapon {
96. private:
97.     int spd; // 额外速度加成
99. public:
100.     // 构造函数
101.     Blade(int atk = 1, int spd = 1) : Weapon(atk), spd(spd) {}
103.     // 设置/获取额外速度值
104.     void setSpd(int s) { spd = s; }
105.     int getSpd() { return spd; }
107.     // 重写属性加成方法（攻击+速度）
108.     virtual void getAttr(Hero& hero) {
109.         Weapon::getAttr(hero); // 调用基类攻击加成
110.         int new_spd = hero.getSpd() + spd;
111.         hero.setSpd(new_spd);
112.     }
114.     // 重写获取武器类型
115.     string getType() override { return "Blade"; }
116. };
118. // 英雄装备武器的具体实现
119. void Hero::equipWeapon(Weapon* w) {
120.     w->getAttr(*this); // 多态调用对应武器的属性加成
121. }
123. // 怪物类
124. class Monster {
125. private:
126.     int hp;        // 怪物生命值
127.     int atk;       // 怪物攻击力
128.     int level;     // 怪物等级
130. public:
131.     // 构造函数
132.     Monster(int h = 50, int a = 10, int l = 1) : hp(h), atk(a), level(l) {}
134.     // 受到伤害方法
135.     void takeDamage(int damage) {
136.         hp -= damage;
137.         if (hp < 0) hp = 0; // 确保生命值不为负
138.     }
140.     // 判断是否死亡
141.     bool isDead() const { return hp <= 0; }
143.     // 根据英雄职业掉落武器
144.     Weapon* dropWeapon(const Hero& hero) {
145.         if (!isDead()) return nullptr; // 未死亡不掉落
147.         int baseAtk = 5 + level * 2; // 基础攻击力计算
148.         
149.         // 根据英雄职业掉落不同武器
150.         if (hero.getProfession() == "Warrior") {
151.             return new Sword(baseAtk, 10 + level * 3); // 战士掉落长剑
152.         } else { // 默认假设为刺客
153.             return new Blade(baseAtk, 5 + level * 2);  // 刺客掉落匕首
154.         }
155.     }
156. };
158. int main(int argc, const char​**​ argv) {
159.     // 创建英雄实例
160.     Hero warrior(100, 15, 10, 5, "Warrior");   // 战士：高血量高防御
161.     Hero assassin(80, 20, 5, 15, "Assassin"); // 刺客：高攻速低血量
163.     // 创建怪物实例
164.     Monster goblin(50, 8, 1);   // 绿色史莱姆（弱小怪物）
165.     Monster orc(100, 15, 2);    // 兽人（较强怪物）
167.     // 战斗过程
168.     goblin.takeDamage(warrior.getAtk()); // 战士攻击哥布林
169.     orc.takeDamage(assassin.getAtk());   // 刺客攻击兽人
171.     // 掉落武器处理
172.     if (goblin.isDead()) {
173.         Weapon* weapon = goblin.dropWeapon(warrior);
174.         cout << "哥布林掉落了 " << weapon->getType() << endl;
175.         warrior.equipWeapon(weapon); // 战士装备武器
176.         delete weapon; // 释放内存
177.     }
179.     if (orc.isDead()) {
180.         Weapon* weapon = orc.dropWeapon(assassin);
181.         cout << "兽人掉落了 " << weapon->getType() << endl;
182.         assassin.equipWeapon(weapon); // 刺客装备武器
183.         delete weapon;
184.     }
186.     // 显示最终属性
187.     cout << "
188. 战士属性 - 攻击力:" << warrior.getAtk()
189.          << " 生命值:" << warrior.getHp() << endl;
190.     cout << "刺客属性 - 攻击力:" << assassin.getAtk()
191.          << " 速度:" << assassin.getSpd() << endl;
193.     return 0;
194. }

复制代码

1. #include <iostream>
2. #include <cstring>
3. #include <cstdlib>
4. #include <unistd.h>
5. #include <sstream>
6. #include <vector>
7. #include <memory>
9. using namespace std;
11. // 双向链表模板类定义
12. template <typename T>
13. class list {
14. public:
15.     // 链表节点结构体
16.     struct Node {
17.         T val;        // 节点存储的值
18.         Node* next;   // 指向下一个节点的指针
19.         Node* prev;   // 指向前一个节点的指针
20.         
21.         // 构造函数
22.         Node(const T& value) : val(value), next(ptr), prev(ptr) {}
23.     };
25.     // 默认构造函数
26.     list() : head(ptr), tail(ptr) {}
28.     // 拷贝构造函数（注意：当前实现为浅拷贝，未处理深拷贝）
29.     list(const list& other) : head(ptr), tail(ptr) {
30.         Node* current = other.head;
31.         while (current != ptr) {
32.             push_back(current->val); // 逐个复制节点值
33.             current = current->next;
34.         }
35.     }
37.     // 析构函数（释放所有节点内存）
38.     ~list() {
39.         Node* current = head;
40.         while (current != ptr) {
41.             Node* next = current->next; // 保存下一个节点指针
42.             delete current;             // 释放当前节点
43.             current = next;             // 移动到下一个节点
44.         }
45.     }
47.     // 在链表尾部添加元素
48.     void push_back(const T& value) {
49.         Node* newNode = new Node(value); // 创建新节点
50.         if (tail == ptr) {           // 链表为空的情况
51.             head = tail = newNode;
52.         } else {                         // 链表非空的情况
53.             tail->next = newNode;        // 原尾节点指向新节点
54.             newNode->prev = tail;        // 新节点指向前原尾节点
55.             tail = newNode;              // 更新尾节点
56.         }
57.     }
59.     // 重载[]运算符（非const版本）
60.     T& operator[](size_t index) {
61.         Node* current = head;
62.         size_t i = 0;
63.         // 遍历链表直到找到指定索引或末尾
64.         while (current != ptr && i < index) {
65.             current = current->next;
66.             i++;
67.         }
68.         if (current == ptr) {
69.             throw std::out_of_range("Index out of range"); // 越界检查
70.         }
71.         return current->val; // 返回找到的节点值（可修改）
72.     }
74.     // 重载[]运算符（const版本）
75.     const T& operator[](size_t index) const {
76.         Node* current = head;
77.         size_t i = 0;
78.         // 遍历链表直到找到指定索引或末尾
79.         while (current != ptr && i < index) {
80.             current = current->next;
81.             i++;
82.         }
83.         if (current == ptr) {
84.             throw std::out_of_range("Index out of range"); // 越界检查
85.         }
86.         return current->val; // 返回找到的节点值（不可修改）
87.     }
89.     // 重载输出运算符（友元函数）
90.     friend std::ostream& operator<<(std::ostream& os, const list& lst) {
91.         Node* current = lst.head;
92.         os << "[";
93.         // 遍历链表输出元素
94.         while (current !=ptr) {
95.             os << current->val;
96.             if (current->next != ptr) {
97.                 os << ", "; // 添加分隔符（非最后一个元素）
98.             }
99.             current = current->next;
100.         }
101.         os << "]"; // 结束列表符号
102.         return os;
103.     }
105. private:
106.     Node* head; // 链表头指针
107.     Node* tail; // 链表尾指针
108. };
110. int main(int argc, const char​**​ argv) {
111.     list<int> myList; // 创建整型链表实例
112.    
113.     // 向链表添加元素
114.     myList.push_back(1);
115.     myList.push_back(2);
116.     myList.push_back(3);
117.    
118.     // 输出链表内容
119.     std::cout << "List: " << myList << std::endl;
120.    
121.     // 访问指定索引元素
122.     std::cout << "Element at index 1: " << myList[1] << std::endl;
123.    
124.     return 0;
125. }

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。