C++关于switch的题目

在C++中，`switch`语句是一种控制结构，常用于基于某个表达式的值选择执行相应的代码块。它的基本语法如下：

switch(expression) {
    case value1:
        // 当expression等于value1时，执行这里的代码
        break;
    case value2:
        // 同理，当expression等于value2时，执行这里的代码
        break;
    // 可以有多个case，每个case后跟着一个值，与expression比较
    default:
        // 如果所有case都不匹配，执行default后的代码（可选）
        break; // 或者可以省略break，但通常为了防止意外的行为
}

注意几点：
1. `break`语句用于跳出当前`switch`语句，如果不写，可能会导致“fall through”现象，即连续执行多个case对应的代码块。
2. `case`后面的值必须是常量表达式，不能是变量或表达式。
3. `default`分支是可选的，如果所有case都未匹配，则会执行default下的代码。

相关问题

关于switch-case的c++题目

关于`switch-case`在C++中的应用，可以设计多种类型的题目。下面是一个示例题目的说明及相关的几个问题：

### 题目说明

编写一个程序，在用户输入一个整数时，程序会根据该整数的值分别打印出对应的月份名称。

例如：
- 输入 `3` 应该输出 “March”
- 输入 `6` 应该输出 “June”

**注意**：程序应该能够处理从 `1` 到 `12` 的所有有效输入，并适当地处理无效输入（如负数、非整数或其他超出范围的数字），在这种情况下应提示用户并请求有效的输入。

### 示例代码框架

#include <iostream>
#include <string>

int main() {
    int month;
    std::cout << "请输入一个月的编号(1-12): ";
    // 这里需要读取用户输入，并检查有效性

    switch (month) {
        case 1: std::cout << "January"; break;
        case 2: std::cout << "February"; break;
        // 类似地添加其他月份...
        default: std::cout << "Invalid input"; break;
    }

    return 0;
}

### 相关问题

1. **如何增加错误处理机制**？考虑到用户可能会输入非整数值或不在1到12之间的整数，你应该如何修改代码以捕获并处理这些情况？

2. **如何改进用户体验**？除了提供明确的错误信息外，你还可以通过什么方式让用户更容易理解他们犯了什么错误，比如在输入无效时提供更具体的帮助信息？

3. **尝试扩展功能**：如果这个程序只能识别一年中的12个月，你将如何修改它使其能够处理整个公历年，即包括闰年的情况？考虑闰年的规则是如何影响日期计算和显示的。

使用c++ 5.11完成题目

同样，我们可以使用C++11标准来实现这个双链表。这里使用智能指针来简化内存管理，并使用STL中的list容器替代自定义链表，因为它提供了一些方便的操作。以下是使用C++11完成该题目的示例：

#include <iostream>
#include <memory>
#include <list>

class ListNode {
public:
    int data;
    std::shared_ptr<ListNode> prev;
    std::shared_ptr<ListNode> next;

    ListNode(int value) : data(value), prev(nullptr), next(nullptr) {}
};

std::shared_ptr<ListNode> createListNode(int x) {
    auto node = std::make_shared<ListNode>(x);
    return node;
}

void insertLeft(std::list<std::shared_ptr<ListNode>>& list) {
    auto newNode = createListNode(list.empty() ? 0 : list.front()->data + 1);
    newNode->prev = list.begin();  // 设置前驱为链表头部
    newNode->next = list.begin();
    list.insert(newNode);
}

void insertRight(std::list<std::shared_ptr<ListNode>>& list) {
    auto newNode = createListNode(list.back()->data + 1);
    newNode->prev = list.end() - 1;  // 设置前驱为链表尾部
    newNode->next = list.end();
    list.push_back(newNode);
}

void removeNode(std::list<std::shared_ptr<ListNode>>& list, int index) {
    if (index <= 0) {
        std::cerr << "Invalid index.\n";
        return;
    }

    auto it = list.begin();
    advance(it, index - 1);  // 跳过前(index - 1)个元素
    it->next->prev = it->prev;
    it->prev->next = it->next;
}

void insertBefore(std::list<std::shared_ptr<ListNode>>& list, int index, int value) {
    if (index <= 0) {
        std::cerr << "Invalid index.\n";
        return;
    }

    auto newNode = createListNode(value);
    auto it = list.begin();
    advance(it, index - 1);  // 跳过前(index - 1)个元素
    newNode->prev = it->prev;
    newNode->next = it;
    it->prev->next = newNode;
    newNode->prev->next = it;
}

void insertAfter(std::list<std::shared_ptr<ListNode>>& list, int index, int value) {
    if (index <= 0) {
        std::cerr << "Invalid index.\n";
        return;
    }

    auto newNode = createListNode(value);
    auto it = list.begin();
    advance(it, index);  // 跳过index个元素
    newNode->prev = it;
    newNode->next = it->next;
    it->next->prev = newNode;
    it->next = newNode;
}

void printList(const std::list<std::shared_ptr<ListNode>>& list) {
    for (const auto& node : list) {
        std::cout << node->data << " ";
    }
    std::cout << "\n";
}

int main() {
    int M, command, k, x;
    scanf("%d", &M);

    std::list<std::shared_ptr<ListNode>> list;
    while (M--) {
        scanf("%d %s", &command, &x);

        switch (command) {
            case 1: // L x - 在左边插入
                insertLeft(list);
                break;
            case 2: // R x - 在右边插入
                insertRight(list);
                break;
            case 3: // D k - 删除第k个
                scanf("%d", &k);
                removeNode(list, k);
                break;
            case 4: // IL k x - 在第k个之前插入
                scanf("%d %d", &k, &x);
                insertBefore(list, k, x);
                break;
            case 5: // IR k x - 在第k个之后插入
                scanf("%d %d", &k, &x);
                insertAfter(list, k, x);
                break;
            default:
                std::cerr << "Invalid command.\n";
                break;
        }
    }

    printList(list);
    return 0;
}

这个版本使用`std::list`作为底层容器，省去了手动维护前驱和后继节点的步骤。当需要修改或添加节点时，可以直接使用list的内置操作。注意，由于C++11中`list`不是双向的，所以删除操作稍微复杂一些。