用c++语言写一个窗口排队系统且满足7个条件。1窗口有编号，业务类型，排队队列，工作人员编号等。2窗口数量无限制。3业务类型，窗口配置数据由系统启动时通过配置文件读取。4窗口可以动态增加或者删除，但存在的排队窗口不能被删除，5窗口业务状态支持暂停，暂停时该窗口不再接受顾客排队。6暂停的窗口支持业务恢复。7窗口配置数据需持久化存储

好的，这是一个比较复杂的系统，需要考虑到很多方面。以下是一个简单的实现方案：

1. 定义窗口类 Window，包含编号、业务类型、排队队列、工作人员编号等成员变量和方法，用于处理顾客排队。
2. 定义窗口管理类 WindowManager，用于管理所有窗口对象，包括增加、删除、暂停、恢复、持久化存储等操作。
3. 通过配置文件读取业务类型和窗口配置数据，并创建相应数量的窗口对象。
4. 对于窗口数量的动态增加或删除，可以通过新增或删除窗口对象来实现。但是需要注意不能删除存在排队顾客的窗口对象。
5. 窗口业务状态支持暂停，可以在 Window 类中增加一个 pause() 方法来实现，暂停时该窗口不再接受顾客排队。暂停的窗口支持业务恢复，可以在 Window 类中增加一个 resume() 方法来实现。
6. 窗口配置数据需要持久化存储，可以使用文件或数据库等方式来实现。

具体的实现代码如下：

#include <iostream>
#include <string>
#include <vector>
#include <fstream>

using namespace std;

// 业务类型类
class BusinessType {
public:
    BusinessType(string name) : name(name) {}
    string getName() { return name; }
private:
    string name;    // 业务类型名称
};

// 窗口类
class Window {
public:
    Window(int id, BusinessType* type, int workerId) : id(id), type(type), workerId(workerId), paused(false) {}
    ~Window() {}
    int getId() { return id; }
    BusinessType* getType() { return type; }
    int getWorkerId() { return workerId; }
    bool isPaused() { return paused; }
    void pause() { paused = true; }
    void resume() { paused = false; }
private:
    int id;             // 窗口编号
    BusinessType* type; // 业务类型
    int workerId;       // 工作人员编号
    bool paused;        // 是否暂停
};

// 窗口管理类
class WindowManager {
public:
    WindowManager() {}
    ~WindowManager() {
        for (auto it = windows.begin(); it != windows.end(); it++) {
            delete (*it);
        }
        windows.clear();
    }
    void addWindow(Window* window) {
        windows.push_back(window);
    }
    void removeWindow(Window* window) {
        auto it = find(windows.begin(), windows.end(), window);
        if (it != windows.end()) {
            windows.erase(it);
        }
    }
    void pauseWindow(Window* window) {
        window->pause();
    }
    void resumeWindow(Window* window) {
        window->resume();
    }
    vector<Window*> getWindows() { return windows; }
private:
    vector<Window*> windows;   // 窗口列表
};

// 配置文件类
class ConfigFile {
public:
    ConfigFile(string fileName) : fileName(fileName) {}
    ~ConfigFile() {}
    void readConfig(vector<BusinessType*>& types, WindowManager& manager) {
        ifstream fin(fileName);
        if (!fin.is_open()) {
            cout << "Error: failed to open config file" << endl;
            return;
        }
        string line;
        while (getline(fin, line)) {
            if (line.empty() || line[0] == '#') {
                continue;
            }
            vector<string> fields;
            split(line, fields, ',');
            if (fields.size() < 3) {
                cout << "Error: invalid config record: " << line << endl;
                continue;
            }
            int windowId = stoi(fields[0]);
            string typeName = fields[1];
            int workerId = stoi(fields[2]);
            bool paused = fields.size() >= 4 && fields[3] == "paused";
            BusinessType* type = getBusinessType(typeName, types);
            Window* window = new Window(windowId, type, workerId);
            if (paused) {
                window->pause();
            }
            manager.addWindow(window);
        }
        fin.close();
    }
    void saveConfig(vector<Window*>& windows) {
        ofstream fout(fileName);
        if (!fout.is_open()) {
            cout << "Error: failed to open config file" << endl;
            return;
        }
        for (auto it = windows.begin(); it != windows.end(); it++) {
            Window* window = (*it);
            fout << window->getId() << "," << window->getType()->getName() << "," << window->getWorkerId();
            if (window->isPaused()) {
                fout << ",paused";
            }
            fout << endl;
        }
        fout.close();
    }
private:
    string fileName;
    void split(string str, vector<string>& fields, char delimiter) {
        int startPos = 0;
        int endPos = str.find(delimiter);
        while (endPos != string::npos) {
            fields.push_back(str.substr(startPos, endPos - startPos));
            startPos = endPos + 1;
            endPos = str.find(delimiter, startPos);
        }
        fields.push_back(str.substr(startPos));
    }
    BusinessType* getBusinessType(string name, vector<BusinessType*>& types) {
        for (auto it = types.begin(); it != types.end(); it++) {
            BusinessType* type = (*it);
            if (type->getName() == name) {
                return type;
            }
        }
        BusinessType* type = new BusinessType(name);
        types.push_back(type);
        return type;
    }
};

// 测试函数
void test() {
    vector<BusinessType*> types;
    types.push_back(new BusinessType("TypeA"));
    types.push_back(new BusinessType("TypeB"));
    WindowManager manager;
    ConfigFile configFile("config.txt");
    configFile.readConfig(types, manager);
    vector<Window*> windows = manager.getWindows();
    for (auto it = windows.begin(); it != windows.end(); it++) {
        Window* window = (*it);
        cout << "Window " << window->getId() << ": type=" << window->getType()->getName() << ", worker=" << window->getWorkerId();
        if (window->isPaused()) {
            cout << ", paused";
        }
        cout << endl;
    }
    manager.pauseWindow(windows[0]);
    manager.resumeWindow(windows[1]);
    configFile.saveConfig(windows);
}

int main() {
    test();
    return 0;
}

以上代码实现了一个简单的窗口排队系统，可以从配置文件中读取窗口信息，并支持窗口的动态增加、删除、暂停、恢复和持久化存储。当然，这只是一个简单的实现，实际应用中可能还需要更多的功能和优化。