C++ 中的神秘数字

2025年5月21日 | 阅读 13 分钟

神秘数字游戏简介

神秘数字游戏是一个简单有趣的编程项目，玩家需要在指定的范围内猜一个随机生成的数字。在这个游戏中，程序会给玩家反馈，比如提示猜的数字是偏高还是偏低，以便玩家知道数字可能在哪里。这个过程会一直持续，直到玩家成功猜出正确的数字。

初学者编程项目应用

神秘数字游戏是一个非常棒的初学者项目，因为它以一种非常有趣且互动的方式融合了许多编程的基础知识。以下是一些应用和核心学习点：

1. 基本编程结构的学习

变量：用于存储神秘数字、玩家的猜测和尝试次数。
输入/输出：涉及使用 `std::cin` 获取用户输入，使用 `std::cout` 显示消息。
条件语句：通过 `if-else` 实现逻辑，对猜测给出反馈。

2. 掌握循环

使用 `while` 或 `do-while` 循环，可以让游戏一直运行，直到猜对为止。

3. 随机数入门

学习如何使用 `rand()` 和 `srand()` 来生成随机数，以及如何进行种子初始化。

4. 错误处理

验证用户输入是否在指定范围内。
无效输入包括非数字条目。

5. 鼓励解决问题

需要逻辑推理才能做出最佳猜测。
程序员会以一种直观的方式来设置游戏，使其提供恰当的反馈。

6. 灵活性和创造力

在引入得分、提示、难度级别和图形界面等方面，存在很大的灵活性和创造空间。

7. 建立信心

游戏的简单性意味着可以快速获得成功，从而建立编程信心。
互动式游戏通过即时反馈来奖励学生。

C++ 中的随机数生成

在游戏和模拟等编程领域，随机生成数字是一个重要的方面。在 C++ 中，生成随机数主要有两种方式：一种是旧的方式，使用 `rand()` 和 `srand()` 函数；另一种是 C++11 引入的新方式，使用 `` 库。

如何使用 `rand()` 和 `srand()` 生成随机数

`rand()` 是 C 标准库（特别是 `cstdlib`）中的一个函数，用于生成伪随机数。

rand() 的基本特性

范围：生成 0 到 `RAND_MAX`（`` 中定义的常量）之间的数字。
可重复性：如果不进行种子初始化，程序每次运行生成的数字序列都是相同的。

如何使用 `srand()` 进行种子初始化

为了使数字序列不可预测，可以使用 `srand()` 来初始化随机数生成器。

#include <iostream>
#include <cstdlib> // for rand() and srand()
#include <ctime>   // for time()

int main() {
    // Seed the random number generator with the current time
    srand(static_cast<unsigned>(time(0)));

    // Generate random numbers
    int randomNum = rand();              // Between 0 and RAND_MAX
    int randomInRange = rand() % 100;    // Between 0 and 99
    int randomCustomRange = rand() % 50 + 1; // Between 1 and 50

    std::cout << "Random number: " << randomNum << std::endl;
    std::cout << "Random number (0-99): " << randomInRange << std::endl;
    std::cout << "Random number (1-50): " << randomCustomRange << std::endl;

    return 0;
}   

输出

Random number: 308392635
Random number (0-99): 19
Random number (1-50): 31

rand() 的缺点

`rand()` 存在随机性较弱、非线程安全以及对生成数字的分布控制不精细等问题。

引入 `` 以获得更好的随机性（C++11 及更高版本）

C++11 引入了 `` 头文件，以更好地理解随机数生成的工作原理。它提供了更精细地控制随机数生成器和分布。

`` 的关键组件

引擎（Engines）：引擎生成伪随机数序列（例如 `std::mt19937`）。
分布（Distributions）：分布控制数字序列的类型和随机数的范围（例如 `std::uniform_int_distribution`）。

使用 `` 的基本示例

#include <iostream>
#include <random> // for <random>

int main() {
    // Random number generator engine (Mersenne Twister)
    std::random_device rd;               // Random seed
    std::mt19937 generator(rd());        // Pseudo-random number engine
    
    // Uniform distribution in range [1, 100]
    std::uniform_int_distribution<int> dist(1, 100);

    // Generate random numbers
    int randomNum = dist(generator);

    std::cout << "Random number (1-100): " << randomNum << std::endl;

    return 0;
}   

输出

Random number (1-100): 46

`` 的优点

更好的随机性：引擎生成的随机数质量更高。
多种引擎类型：例如，可以选择 `std::mt19937`（梅森旋转算法）或 `std::default_random_engine`。
灵活的分布
- `std::uniform_int_distribution`：整数的均匀分布。
- `std::uniform_real_distribution`：浮点数的均匀分布。
- 其他分布（例如，正态分布、二项分布）。

用户输入处理

接收任何交互式程序的响应的方式与用户输入数据的方式相同。在 C++ 中，用户输入使用 `std::cin`。由于所有输入都需要进行验证和清理，因此它保证了程序能够可靠地处理所有意外或无效的语法，这是一种传统的编程方法。

使用 `std::cin` 捕获用户输入

使用属于 `` 库的 `std::cin` 从键盘捕获标准输入。基本示例

#include <iostream>
int main() {
    int age;

    std::cout << "Enter your age: ";
    std::cin >> age;

    std::cout << "You entered: " << age << std::endl;
    return 0;
}   

输出

Enter your age: 45
You entered: 45

使用 `std::cin` 时常见的问题

类型不匹配
- 当程序期望输入数字时，输入了非数字值。
- 当 `std::cin` 进入失败状态时，它会跳过其余的输入。
额外的输入
- 由于空格或换行符等字符残留在输入缓冲区中，这可能会干扰后续的读取操作。

在交互式程序中验证和清理用户输入

输入验证确保将有效数据传递给程序，而清理则通过删除或更正无效输入来完成。这些操作包括：

1. 检查输入有效性

使用 `std::cin.fail()` 方法检测无效输入。

#include <iostream>
#include <limits> // For std::numeric_limits

int main() {
    int number;

    std::cout << "Enter an integer: ";
    std::cin >> number;

    if (std::cin.fail()) {
        std::cout << "Invalid input. Please enter a valid integer." << std::endl;
    } else {
        std::cout << "You entered: " << number << std::endl;
    }

    return 0;
}   

输出 1

Enter an integer: 10
You entered: 10

输出

Enter an integer: 1088888888888888888888
Invalid input. Please enter a valid integer.

2. 清除输入缓冲区

使用 `std::cin.clear()` 和 `std::cin.ignore()` 来清除错误状态和输入缓冲区中的多余字符。

#include <iostream>
#include <limits> // For std::numeric_limits

int main() {
    int number;

    while (true) {
        std::cout << "Enter an integer: ";
        std::cin >> number;

        if (std::cin.fail()) {
            std::cin.clear(); // Clear the error flag
            std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n'); // Discard invalid input
            std::cout << "Invalid input. Please try again." << std::endl;
        } else {
            break;
        }
    }

    std::cout << "You entered: " << number << std::endl;
    return 0;
}   

输出

Enter an integer: 8976564376
Invalid input. Please try again.
Enter an integer: 896756
You entered: 896756

3. 确保输入在有效范围内

使用循环检查输入范围的有效性。

#include <iostream>
#include<limit>
int main() {
    int number;

    while (true) {
        std::cout << "Enter a number between 1 and 100: ";
        std::cin >> number;

        if (std::cin.fail() || number < 1 || number > 100) {
            std::cin.clear(); // Clear the error flag
            std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n'); // Discard invalid input
            std::cout << "Invalid input. Please enter a number between 1 and 100." << std::endl;
        } else {
            break;
        }
    }

    std::cout << "You entered: " << number << std::endl;
    return 0;
}   

输出 1

Enter a number between 1 and 100: 54
You entered: 54

输出 2

Enter a number between 1 and 100: 945
Invalid input. Please enter a number between 1 and 100.
Enter a number between 1 and 100: 67
You entered: 67

条件语句

条件语句允许程序根据特定条件做出决策。对于数字猜测游戏，条件逻辑有助于评估用户的猜测并为他们提供适当的反馈。

使用 `if-else` 语句评估用户猜测

在神秘数字游戏中，`if-else` 语句用于将用户的猜测输入与神秘数字进行比较，并根据比较结果提供反馈。

基本示例

#include <iostream>
int main() {
    int mysteryNumber = 42; // Predefined mystery number for simplicity
    int userGuess;

    std::cout << "Guess the mystery number (1-100): ";
    std::cin >> userGuess;

    if (userGuess > mysteryNumber) {
        std::cout << "Too high! Try again." << std::endl;
    } else if (userGuess < mysteryNumber) {
        std::cout << "Too low! Try again." << std::endl;
    } else {
        std::cout << "Congratulations! You guessed the number!" << std::endl;
    }

    return 0;
}   

输出 1

Guess the mystery number (1-100): 45
Too high! Try again.

输出 2

Guess the mystery number (1-100): 9
Too low! Try again.

边界情况和无效输入

当输入不符合一般预期行为时，就称为边界情况。非数字字符和超出范围的猜测都属于无效输入的例子。

1. 边界情况：输入超出范围

检查用户猜测是否在可接受的范围内。

#include <iostream>
int main() {
    int mysteryNumber = 42;
    int userGuess;

    while (true) {
        std::cout << "Guess the mystery number (1-100): ";
        std::cin >> userGuess;

        if (userGuess < 1 || userGuess > 100) {
            std::cout << "Invalid guess. Please enter a number between 1 and 100." << std::endl;
            break;
        } else if (userGuess > mysteryNumber) {
            std::cout << "Too high! Try again." << std::endl;
            break;
        } else if (userGuess < mysteryNumber) {
            std::cout << "Too low! Try again." << std::endl;
            break;
        } else {
            std::cout << "Congratulations! You guessed the number!" << std::endl;
            break;
        }
    }

    return 0;
}   

输出 1

Guess the mystery number (1-100):10 
Too low! Try again.

输出 2

Guess the mystery number (1-100):59
Too high! Try again.

输出 3

Guess the mystery number (1-100):42
Congratulations! You guessed the number!

2. 边界情况：输入为非数字

验证输入以处理非数字类型并清除输入缓冲区。

#include <iostream>
#include <limits>

int main() {
    int mysteryNumber = 42;
    int userGuess;

    while (true) {
        std::cout << "Guess the mystery number (1-100): ";
        std::cin >> userGuess;

        if (std::cin.fail()) {
            std::cin.clear(); // Clear the error flag
            std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n'); // Discard invalid input
            std::cout << "Invalid input. Please enter a numeric value." << std::endl;
        } else if (userGuess < 1 || userGuess > 100) {
            std::cout << "Invalid guess. Please enter a number between 1 and 100." << std::endl;
        } else if (userGuess > mysteryNumber) {
            std::cout << "Too high! Try again." << std::endl;
        } else if (userGuess < mysteryNumber) {
            std::cout << "Too low! Try again." << std::endl;
        } else {
            std::cout << "Congratulations! You guessed the number!" << std::endl;
            break;
        }
    }

    return 0;
}   

输出

Guess the mystery number (1-100): 67
Too high! Try again.
Guess the mystery number (1-100): 30
Too low! Try again.
Guess the mystery number (1-100): 45
Too high! Try again.
Guess the mystery number (1-100): 40
Too low! Try again.
Guess the mystery number (1-100): 41
Too low! Try again.
Guess the mystery number (1-100): 42
Congratulations! You guessed the number!

3. 组合多个条件

您可以使用逻辑运算符（`&&`、`||`）组合条件来处理特定情况。

#include <iostream>
#include <limits> // Required for std::numeric_limits

int main() {
    int userGuess;

    while (true) {
        std::cout << "Enter a number between 1 and 100: ";
        std::cin >> userGuess;

        if (std::cin.fail() || userGuess < 1 || userGuess > 100) {
            std::cin.clear(); // Clear error flags
            std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n'); // Discard invalid input
            std::cout << "Invalid input. Please enter a number between 1 and 100." << std::endl;
        } else {
            break; // Exit loop if input is valid
        }
    }

    std::cout << "You entered: " << userGuess << std::endl;
    return 0;
}   

输出 1

Enter a number between 1 and 100: 90
You entered: 90

输出

Enter a number between 1 and 100: 150
Invalid input. Please enter a number between 1 and 100.
Enter a number between 1 and 100: 89
You entered: 89

游戏循环实现

实现游戏循环对于神秘数字游戏这样的交互式游戏至关重要。游戏循环会重复执行游戏逻辑（例如，获取用户输入并检查猜测），直到满足特定条件（例如，玩家猜对数字）。

使用循环（`while`、`do-while` 或 `for`）构建游戏逻辑

1. 使用 `while` 的游戏循环

`while` 循环可以有效地重复猜测逻辑，直到玩家猜对为止。

#include <iostream>
#include <cstdlib> // For rand() and srand()
#include <ctime>   // For time()
#include <limits>  // For std::numeric_limits

int main() {
    srand(static_cast<unsigned>(time(0))); // Seed random number generator
    int mysteryNumber = rand() % 100 + 1;  // Random number between 1 and 100
    int userGuess;

    std::cout << "Welcome to the Mystery Number Game!" << std::endl;

    bool guessedCorrectly = false;

    while (!guessedCorrectly) {
        std::cout << "Guess the mystery number (1-100): ";
        std::cin >> userGuess;

        if (std::cin.fail()) {
            std::cin.clear(); // Clear error flag
            std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n'); // Discard invalid input
            std::cout << "Invalid input. Please enter a number between 1 and 100." << std::endl;
            continue;
        }

        if (userGuess < 1 || userGuess > 100) {
            std::cout << "Out of range! Enter a number between 1 and 100." << std::endl;
        } else if (userGuess > mysteryNumber) {
            std::cout << "Too high! Try again." << std::endl;
        } else if (userGuess < mysteryNumber) {
            std::cout << "Too low! Try again." << std::endl;
        } else {
            std::cout << "Congratulations! You guessed the number!" << std::endl;
            guessedCorrectly = true;
        }
    }

    return 0;
}   

输出

Welcome to the Mystery Number Game!
Guess the mystery number (1-100): 90
Too high! Try again.
Guess the mystery number (1-100): 80
Too high! Try again.
Guess the mystery number (1-100): 70
Too low! Try again.
Guess the mystery number (1-100): 75
Congratulations! You guessed the number!

2. 使用 `do-while` 的游戏循环

`do-while` 循环保证游戏逻辑至少执行一次，这对于用户驱动的游戏非常有用。

#include <iostream>
#include <cstdlib>
#include <ctime>
#include <limits> // Include this header for std::numeric_limits

int main() {
    srand(static_cast<unsigned>(time(0))); // Seed random number generator
    int mysteryNumber = rand() % 100 + 1; // Random number between 1 and 100
    int userGuess;

    std::cout << "Welcome to the Mystery Number Game!" << std::endl;

    do {
        std::cout << "Guess the mystery number (1-100): ";
        std::cin >> userGuess;

        if (std::cin.fail()) {
            std::cin.clear(); // Clear the error flag
            std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n'); // Discard invalid input
            std::cout << "Invalid input. Please try again." << std::endl;
            continue;
        }

        if (userGuess < 1 || userGuess > 100) {
            std::cout << "Out of range! Enter a number between 1 and 100." << std::endl;
        } else if (userGuess > mysteryNumber) {
            std::cout << "Too high! Try again." << std::endl;
        } else if (userGuess < mysteryNumber) {
            std::cout << "Too low! Try again." << std::endl;
        } else {
            std::cout << "Congratulations! You guessed the number!" << std::endl;
            break; // Exit the loop upon correct guess
        }
    } while (true);

    return 0;
}   

输出

Welcome to the Mystery Number Game!
Guess the mystery number (1-100): 90
Too high! Try again.
Guess the mystery number (1-100): 80
Too high! Try again.
Guess the mystery number (1-100): 70
Too high! Try again.
Guess the mystery number (1-100): 60
Too low! Try again.
Guess the mystery number (1-100): 65
Too high! Try again.
Guess the mystery number (1-100): 63
Congratulations! You guessed the number!

3. 使用 `for` 的游戏循环

`for` 循环在猜测游戏中不太常用，但可以用来限制最大尝试次数。

#include <iostream>
#include <cstdlib>
#include <ctime>
#include <limits> // Required for std::numeric_limits

int main() {
    srand(static_cast<unsigned>(time(0))); // Seed random number generator
    int mysteryNumber = rand() % 100 + 1; // Random number between 1 and 100
    int userGuess;

    std::cout << "Welcome to the Mystery Number Game!" << std::endl;

    const int maxAttempts = 5; // Limit the number of attempts

    for (int attempts = 1; attempts <= maxAttempts; ++attempts) {
        std::cout << "Attempt " << attempts << " of " << maxAttempts << ": ";
        std::cin >> userGuess;

        if (std::cin.fail()) {
            std::cin.clear(); // Clear the error flag
            std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n'); // Discard invalid input
            std::cout << "Invalid input. Please try again." << std::endl;
            --attempts; // Retry the same attempt
            continue;
        }

        if (userGuess < 1 || userGuess > 100) {
            std::cout << "Out of range! Enter a number between 1 and 100." << std::endl;
        } else if (userGuess > mysteryNumber) {
            std::cout << "Too high! Try again." << std::endl;
        } else if (userGuess < mysteryNumber) {
            std::cout << "Too low! Try again." << std::endl;
        } else {
            std::cout << "Congratulations! You guessed the number!" << std::endl;
            break;
        }

        if (attempts == maxAttempts) {
            std::cout << "Game over! The mystery number was " << mysteryNumber << "." << std::endl;
        }
    }

    return 0;
}   

输出

Welcome to the Mystery Number Game!
Attempt 1 of 5: 1
Too low! Try again.
Attempt 2 of 5: 56
Too low! Try again.
Attempt 3 of 5: 200
Out of range! Enter a number between 1 and 100.
Attempt 4 of 5: 45
Too low! Try again.
Attempt 5 of 5: 42
Too low! Try again.
Game over! The mystery number was 84.

结论

神秘数字游戏是任何想要开始实践和概念性编程项目的初学者的绝佳入门课程。开发这个游戏涉及许多基本技能，例如：

1. 使用变量和随机数生成器

用于存储和操作变量，例如用户猜测的数字和他们试图猜测的神秘数字，以及使用 `rand()` 或 `` 生成随机数，这些都是实际应用你想法的绝佳示例。

2. 输入/输出处理

通过 `std::cin` 捕获用户输入，并通过 `std::cout` 提供有意义的反馈——这是软件交互核心的入门：用户交互。

3. 使用条件语句和循环构建游戏逻辑

实现 `if-else` 条件以及循环（`while`、`do-while` 或 `for`），展示如何创建结构化、可重用的逻辑——这是编程的核心技能。

4. 确保健壮的输入验证

用户输入验证不仅是为了确保流畅的游戏体验，而且通过考虑边界情况甚至无效输入，可以减少出错的可能性，从而体现出高质量的编程。

5. 提高解决问题的能力

这个游戏鼓励玩家和程序员——玩家通过演绎推理来思考数字，而程序员则设计从最直观到功能丰富且用户友好的体验。

6. 探索创意性增强

扩展游戏功能的途径包括添加得分、提示、难度级别以及用户重试次数限制。这些都是可以激发创造力和学习的领域，并展示软件如何随着用户期望的提高而发展。

下一主题Narayana-number-in-cpp

Python

Java

.Net Framework

AI, ML and Data Science

Cloud Technology

B.Tech and MCA

Web Technology

PHP

Software Testing

Technical Interview

Java Interview

Python

Web Interview

Database Interview

B.Tech / MCA

Important Interview

Software Testing Interview

Company Interviews

Online Compilers

Multiple Choice Questions

C++ 教程

C++ 控制语句

C++ 函数

C++ 数组

C++ 类和对象

C++ 构造函数

C++ 继承

C++ 多态

C++ 抽象

C++ 命名空间

C++ 模板

C++ 字符串

C++ 指针

信号处理

C++ 异常

C++ 文件与流

C++ STL 教程

面试题

选择题

C++ 程序

C++ STL Stack

C++ STL Bitset

C++ STL Deque

C++ STL List

C++ STL Map

C++ STL Math

C++ STL priority_queue

C++ STL Queue

C++ STL Multiset

C++ STL Multimap

C++ STL Set

C++ STD Strings

C++ STL Vector

C++ 操纵符

C++ STL Algorithms

C++ Algorithm

C++ Iterators

C++ 杂项

C++ 中的神秘数字

神秘数字游戏简介

初学者编程项目应用

1. 基本编程结构的学习

2. 掌握循环

3. 随机数入门

4. 错误处理

5. 鼓励解决问题

6. 灵活性和创造力

7. 建立信心

C++ 中的随机数生成

如何使用 `rand()` 和 `srand()` 生成随机数

如何使用 `srand()` 进行种子初始化

rand() 的缺点

引入 `` 以获得更好的随机性（C++11 及更高版本）

`` 的关键组件

使用 `` 的基本示例

`` 的优点

用户输入处理

使用 `std::cin` 捕获用户输入

使用 `std::cin` 时常见的问题

在交互式程序中验证和清理用户输入