根据自身对面向对象方法与系统设计的理解，参照《重构-改善既有代码的设计》书中关于不良设计（违反SOLID）、不良代码（代码坏味道bad smells）的判别标准进行重构switch (x) { case 1: l.addBook(); break; case 2: l.deleteBook(); break; case 3: l.addreader(); break; case 4: l.deleteBook(); break; case 5: l.brrowBook(); break; case 6: l.returnBook(); break; case 7: l.showInfo(); break; case 8: l.look(); case 9: l.show(); break; case 10: l.filemanage(); break; case 11: l.open(); break; case 0: exit(1); break;

上述代码可以使用多态和策略模式进行重构，以遵循SOLID原则。首先，我们可以定义一个名为`LibraryAction`的抽象基类，它有一个名为`doAction`的虚函数，表示执行某个操作。然后，我们可以定义一组派生类，每个类都实现了`doAction`函数以执行不同的操作。最后，我们可以使用一个名为`ActionContext`的类来调用所选操作。

以下是示例代码：

#include <iostream>
#include <memory>
#include <map>

class Library;

class LibraryAction {
public:
    virtual ~LibraryAction() {}
    virtual void doAction(Library& l) = 0;
};

class AddBookAction : public LibraryAction {
public:
    void doAction(Library& l) override {
        l.addBook();
    }
};

class DeleteBookAction : public LibraryAction {
public:
    void doAction(Library& l) override {
        l.deleteBook();
    }
};

class AddReaderAction : public LibraryAction {
public:
    void doAction(Library& l) override {
        l.addreader();
    }
};

class BorrowBookAction : public LibraryAction {
public:
    void doAction(Library& l) override {
        l.brrowBook();
    }
};

class ReturnBookAction : public LibraryAction {
public:
    void doAction(Library& l) override {
        l.returnBook();
    }
};

class ShowInfoAction : public LibraryAction {
public:
    void doAction(Library& l) override {
        l.showInfo();
    }
};

class LookAction : public LibraryAction {
public:
    void doAction(Library& l) override {
        l.look();
    }
};

class ShowAction : public LibraryAction {
public:
    void doAction(Library& l) override {
        l.show();
    }
};

class FileManageAction : public LibraryAction {
public:
    void doAction(Library& l) override {
        l.filemanage();
    }
};

class OpenAction : public LibraryAction {
public:
    void doAction(Library& l) override {
        l.open();
    }
};

class ExitAction : public LibraryAction {
public:
    void doAction(Library& l) override {
        std::exit(1);
    }
};

class Library {
public:
    void addBook() {
        // 实现添加图书的逻辑
        std::cout << "Add Book" << std::endl;
    }

    void deleteBook() {
        // 实现删除图书的逻辑
        std::cout << "Delete Book" << std::endl;
    }

    void addreader() {
        // 实现添加读者的逻辑
        std::cout << "Add Reader" << std::endl;
    }

    void brrowBook() {
        // 实现借阅图书的逻辑
        std::cout << "Borrow Book" << std::endl;
    }

    void returnBook() {
        // 实现归还图书的逻辑
        std::cout << "Return Book" << std::endl;
    }

    void showInfo() {
        // 实现显示信息的逻辑
        std::cout << "Show Info" << std::endl;
    }

    void look() {
        // 实现查找图书的逻辑
        std::cout << "Look" << std::endl;
    }

    void show() {
        // 实现显示图书的逻辑
        std::cout << "Show" << std::endl;
    }

    void filemanage() {
        // 实现文件管理的逻辑
        std::cout << "File Manage" << std::endl;
    }

    void open() {
        // 实现打开文件的逻辑
        std::cout << "Open" << std::endl;
    }
};

class ActionContext {
public:
    void addAction(int key, std::unique_ptr<LibraryAction> action) {
        m_actions[key] = std::move(action);
    }

    void executeAction(int key, Library& l) {
        auto it = m_actions.find(key);
        if (it != m_actions.end()) {
            it->second->doAction(l);
        }
    }

private:
    std::map<int, std::unique_ptr<LibraryAction>> m_actions;
};

int main() {
    Library l;
    ActionContext context;

    context.addAction(1, std::make_unique<AddBookAction>());
    context.addAction(2, std::make_unique<DeleteBookAction>());
    context.addAction(3, std::make_unique<AddReaderAction>());
    context.addAction(4, std::make_unique<DeleteBookAction>());
    context.addAction(5, std::make_unique<BorrowBookAction>());
    context.addAction(6, std::make_unique<ReturnBookAction>());
    context.addAction(7, std::make_unique<ShowInfoAction>());
    context.addAction(8, std::make_unique<LookAction>());
    context.addAction(9, std::make_unique<ShowAction>());
    context.addAction(10, std::make_unique<FileManageAction>());
    context.addAction(11, std::make_unique<OpenAction>());
    context.addAction(0, std::make_unique<ExitAction>());

    int x;
    while (true) {
        std::cin >> x;
        context.executeAction(x, l);
    }

    return 0;
}

在上述重构后的代码中，我们创建了一个名为`ActionContext`的类，它充当了一个上下文环境，可以根据用户输入的选择执行相应的操作。在`ActionContext`中，我们使用了一个`map`来存储每个操作对应的对象，使用`unique_ptr`来确保操作对象的唯一性。在`executeAction`函数中，我们使用用户输入的键来查找相应的操作对象，并调用其`doAction`函数来执行相应的操作。这种方式避免了使用大量的`switch`语句，也更符合开放封闭原则，使得我们可以轻松地添加或删除操作。