使用while循环推进C++交易游戏代码遇阻，求优化方案

针对你的需求，以下是一套清晰的代码结构优化方案，解决冗余判断、结构混乱的问题，同时满足交易商独立库存、世界-交易商关联、随机生成等需求：

核心优化方向 #

• 用类组合建立清晰关联：World包含多个Trader，每个Trader持有自己的Inventory
• 用构造函数替代初始化方法，符合C++面向对象设计规范
• 封装重复的用户选择逻辑为独立函数，消除冗余代码
• 采用分层循环管理游戏流程：游戏主循环 → 世界选择循环 → 交易商交互循环，避免嵌套混乱
• 通过随机数实现交易商及其库存的随机生成

具体重构步骤及代码实现 #

1. 重构类结构 #

• 让Trader类直接包含Inventory成员，每个交易商拥有独立库存
• 让World类包含Trader的列表，明确世界与交易商的所属关系
• 替换所有create_xxx方法为构造函数，确保对象初始化的完整性

2. 封装通用函数 #

• 封装promptSelection函数处理数字选择逻辑，统一输入验证，避免重复的if else
• 封装generateRandomInventory函数生成随机库存，generateRandomTraders函数为世界生成随机交易商

3. 分层流程控制 #

• 外层循环控制游戏是否退出
• 中层循环处理世界切换
• 内层循环处理当前交易商的买卖操作及交易商切换

完整优化代码 #

#include <iostream>
#include <map>
#include <vector>
#include <string>
#include <random>
#include <algorithm>
#include <limits>

using namespace std;

// 全局随机数生成器（可封装为工具类，这里简化处理）
random_device rd;
mt19937 gen(rd());

class Inventory {
private:
    map<string, int> items;

public:
    // 构造函数：直接初始化库存
    Inventory(const map<string, int>& initialItems = {}) : items(initialItems) {}

    // 生成随机库存
    static Inventory generateRandom() {
        vector<pair<string, int>> possibleItems = {
            {"疗伤药剂", 50}, {"铁剑", 150}, {"魔力水晶", 80},
            {"皮甲", 100}, {"魔法卷轴", 200}, {"金币袋", 30}
        };
        shuffle(possibleItems.begin(), possibleItems.end(), gen);
        
        map<string, int> randomItems;
        int itemCount = uniform_int_distribution<>(2, 5)(gen);
        for (int i = 0; i < itemCount; ++i) {
            randomItems.insert(possibleItems[i]);
        }
        return Inventory(randomItems);
    }

    void show(const string& currency) const {
        cout << "=== 库存 ===" << endl;
        for (const auto& item : items) {
            cout << "- " << item.first << ": " << item.second << " " << currency << endl;
        }
    }

    // 买卖操作示例（可扩展更多逻辑）
    bool buyItem(const string& itemName, int& playerGold) {
        auto it = items.find(itemName);
        if (it != items.end() && playerGold >= it->second) {
            playerGold -= it->second;
            cout << "成功购买" << itemName << "！剩余金币：" << playerGold << endl;
            // 可添加玩家库存逻辑
            return true;
        }
        cout << "无法购买该物品！" << endl;
        return false;
    }
};

class Trader {
private:
    string name;
    Inventory inventory;

public:
    Trader(const string& traderName, const Inventory& traderInventory) 
        : name(traderName), inventory(traderInventory) {}

    // 随机生成交易商
    static Trader generateRandom(const vector<string>& namePool) {
        uniform_int_distribution<> nameDist(0, namePool.size()-1);
        string randomName = namePool[nameDist(gen)];
        Inventory randomInv = Inventory::generateRandom();
        return Trader(randomName, randomInv);
    }

    const string& getName() const { return name; }
    const Inventory& getInventory() const { return inventory; }
    Inventory& getInventory() { return inventory; }
};

class World {
private:
    string name;
    string description;
    vector<Trader> traders;

public:
    World(const string& worldName, const string& worldDesc, const vector<string>& traderNamePool)
        : name(worldName), description(worldDesc) {
        // 随机生成2-4个交易商
        int traderCount = uniform_int_distribution<>(2, 4)(gen);
        for (int i = 0; i < traderCount; ++i) {
            traders.push_back(Trader::generateRandom(traderNamePool));
        }
    }

    const string& getName() const { return name; }
    const string& getDescription() const { return description; }
    const vector<Trader>& getTraders() const { return traders; }

    void greet() const {
        cout << "\n=== 欢迎来到 " << name << " ===" << endl;
        cout << description << endl;
        cout << "这里的交易商：" << endl;
        for (size_t i = 0; i < traders.size(); ++i) {
            cout << i+1 << ". " << traders[i].getName() << endl;
        }
    }
};

// 通用选择函数：处理数字输入验证
int promptSelection(const string& prompt, int minOption, int maxOption) {
    int choice;
    while (true) {
        cout << prompt << endl;
        cout << "请输入选项编号：";
        if (cin >> choice && choice >= minOption && choice <= maxOption) {
            return choice;
        }
        cin.clear();
        cin.ignore(numeric_limits<streamsize>::max(), '\n');
        cout << "无效输入，请输入" << minOption << "到" << maxOption << "之间的数字！" << endl;
    }
}

int main() {
    // 初始化玩家状态
    int playerGold = 500;
    const string currency = "金币";

    // 交易商名字池
    vector<string> traderNames = {"泽菲尔", "赛勒斯", "露娜", "伊奥斯", "凯尔", "玛拉", "贾克斯"};

    // 创建世界列表
    vector<World> worlds = {
        World("天瀑秘境", "隐藏在贡坤瀑布后的奇幻世界", traderNames),
        World("云中之城", "漂浮在贡坤云层之上的天空国度", traderNames),
        World("和之国", "隐匿在贡坤海洋深处的武士之乡", traderNames)
    };

    bool gameRunning = true;
    while (gameRunning) {
        // 世界选择
        cout << "\n===== 贡坤世界 =====" << endl;
        cout << "请选择要前往的世界：" << endl;
        for (size_t i = 0; i < worlds.size(); ++i) {
            cout << i+1 << ". " << worlds[i].getName() << endl;
        }
        int worldIdx = promptSelection("", 1, worlds.size()) - 1;
        World& currentWorld = worlds[worldIdx];
        currentWorld.greet();

        bool inWorld = true;
        while (inWorld) {
            // 交易商选择
            int traderIdx = promptSelection("\n请选择要交易的商⼈", 1, currentWorld.getTraders().size()) - 1;
            Trader& currentTrader = const_cast<Trader&>(currentWorld.getTraders()[traderIdx]);
            cout << "\n你来到了" << currentTrader.getName() << "的摊位：" << endl;
            currentTrader.getInventory().show(currency);

            bool trading = true;
            while (trading) {
                // 交易操作选择
                cout << "\n当前金币：" << playerGold << " " << currency << endl;
                int action = promptSelection(
                    "请选择操作：\n1. 购买物品\n2. 切换交易商\n3. 切换世界\n4. 退出游戏",
                    1, 4
                );

                switch (action) {
                    case 1: {
                        // 购买物品逻辑（可扩展为选择具体物品）
                        cout << "输入要购买的物品名称：";
                        string itemName;
                        cin >> itemName;
                        currentTrader.getInventory().buyItem(itemName, playerGold);
                        break;
                    }
                    case 2: trading = false; break;
                    case 3: trading = false; inWorld = false; break;
                    case 4: trading = false; inWorld = false; gameRunning = false; break;
                }
            }
        }
    }

    cout << "游戏结束，再见！" << endl;
    return 0;
}

方案优势 #

• 完全避免冗余的if else判断，通过函数封装和switch处理分支逻辑
• 类结构清晰：世界包含交易商，交易商包含库存，贴合业务逻辑
• 随机生成逻辑可扩展，方便调整交易商数量、库存物品范围
• 分层循环让游戏流程一目了然，易于维护和扩展新功能

内容的提问来源于stack exchange，提问作者Ali Jabri