学习 C++ / 第 28.5 课

流状态与输入验证

17 分钟阅读

流状态

ios_base 类包含多个状态标志,用于表示使用流时可能发生的各种情况:

Flag含义
goodbit一切正常
badbit发生了某种致命错误(例如程序尝试读取文件末尾之后的内容)
eofbit流已到达文件末尾
failbit发生了非致命错误(例如程序要求整数,但用户输入了字母)

虽然这些标志位于 ios_base 中,但由于 ios 派生自 ios_base 且写法更简短,通常通过 ios 访问它们(例如 std::ios::failbit)。

ios 还提供了一些成员函数,方便访问这些状态:

成员函数含义
good()如果设置了 goodbit(流正常),返回 true
bad()如果设置了 badbit(发生致命错误),返回 true
eof()如果设置了 eofbit(流位于文件末尾),返回 true
fail()如果设置了 failbit(发生非致命错误),返回 true
clear()清除所有标志,将流恢复为 goodbit 状态
clear(state)清除所有标志,并设置传入的状态标志
rdstate()返回当前设置的标志
setstate(state)设置传入的状态标志

最常处理的是 failbit,用户输入无效内容时会设置它。例如,请看下面的程序:

C++
std::cout << "Enter your age: ";
int age {};
std::cin >> age;

请注意,程序要求用户输入整数。但如果用户输入“Alex”等非数字数据,cin 将无法向 age 提取内容,并会设置 failbit。

如果发生错误且流状态不是 goodbit,后续对该流的操作都会被忽略。调用 clear() 函数可以清除这种状态。

输入验证

输入验证 是检查用户输入是否满足一组条件的过程。输入验证通常分为字符串验证和数值验证。

字符串验证会将所有输入作为字符串接收,再根据格式是否正确接受或拒绝。例如,如果要求用户输入电话号码,可能希望确保输入包含十位数字。 在大多数语言(尤其 Perl、PHP 等脚本语言)中,这通过正则表达式完成。C++ 标准库也有 正则表达式库 。由于正则表达式相比手动字符串验证较慢,只有不在意编译期和运行时性能,或手动验证过于繁琐时才应使用。

数值验证通常关注用户输入的数字是否在特定范围内(例如 0 到 20)。 但与字符串验证不同,用户可能输入完全不是数字的内容,也需要处理这种情况。

为此,C++ 提供了一些有用函数,用于判断特定字符是数字还是字母。下面的函数位于 cctype 头文件中:

函数含义
std::isalnum(int)如果参数是字母或数字,返回非零值
std::isalpha(int)如果参数是字母,返回非零值
std::iscntrl(int)如果参数是控制字符,返回非零值
std::isdigit(int)如果参数是数字,返回非零值
std::isgraph(int)如果参数是可打印且不是空白字符,返回非零值
std::isprint(int)如果参数是可打印字符(包括空白字符),返回非零值
std::ispunct(int)如果参数既不是字母数字也不是空白字符,返回非零值
std::isspace(int)如果参数是空白字符,返回非零值
std::isxdigit(int)如果参数是十六进制数字(0-9、a-f、A-F),返回非零值

字符串验证

通过让用户输入姓名来做一个简单的字符串验证。验证条件是只能输入字母或空格,出现其他字符就拒绝输入。

对于长度可变的输入,验证字符串的最佳方式(使用正则表达式库除外)是逐个检查字符串中的字符,确保满足验证条件。 这正是我们要做的事情,或者更准确地说,是 std::all_of 替我们完成的事情。

C++
#include <algorithm> // std::all_of
#include <cctype> // std::isalpha, std::isspace
#include <iostream>
#include <ranges>
#include <string>
#include <string_view>

bool isValidName(std::string_view name)
{
  return std::ranges::all_of(name, [](char ch) {
    return std::isalpha(ch) || std::isspace(ch);
  });

  // C++20 之前,不使用 ranges
  // return std::all_of(name.begin(), name.end(), [](char ch) {
  //    return std::isalpha(ch) || std::isspace(ch);
  // });
}

int main()
{
  std::string name{};

  do
  {
    std::cout << "请输入你的名字: ";
    std::getline(std::cin, name); // 获取整行内容,包括空格
  } while (!isValidName(name));

  std::cout << "Hello " << name << "!\n";
}

请注意,这段代码并不完美:用户可能说自己的名字是 “asf w jweo s di we ao” 或其他乱码,甚至只输入一串空格。 可以改进验证条件,只接受至少包含一个字符且最多包含一个空格的字符串。

作者注

读者 “Waldo” 提供了使用 std::ranges 的 C++20 解决方案,解决了这些问题 此处

下面看另一个让用户输入电话号码的示例。姓名长度可变,且每个字符的验证条件相同;电话号码长度固定,但验证条件取决于字符位置。 因此我们会采用不同方法验证电话号码:编写函数,将用户输入与预定模板比较。模板规则如下:

# 匹配输入中的任意数字。
@ 匹配输入中的任意字母。
_ 匹配任意空白字符。
? 匹配任意字符。
除此之外,输入字符必须与模板完全匹配。

例如,要求函数匹配模板“(###) ###-####”,表示希望用户输入“(”字符、三个数字、“)”字符、一个空格、三个数字、一个连字符和另外四个数字。 只要有一项不匹配,就拒绝输入。

代码如下:

C++
#include <algorithm> // std::equal
#include <cctype> // std::isdigit, std::isspace, std::isalpha
#include <iostream>
#include <map>
#include <ranges>
#include <string>
#include <string_view>

bool inputMatches(std::string_view input, std::string_view pattern)
{
    if (input.length() != pattern.length())
    {
        return false;
    }

    // 此表定义可匹配用户输入范围的所有特殊符号
    // 每个符号都映射到一个函数,用于判断输入对该符号是否有效
    static const std::map<char, int (*)(int)> validators{
      { '#', &std::isdigit },
      { '_', &std::isspace },
      { '@', &std::isalpha },
      { '?', [](int) { return 1; } }
    };

    // C++20 之前,使用
    // return std::equal(input.begin(), input.end(), pattern.begin(), [](char ch, char mask) -> bool {
    // ...

    return std::ranges::equal(input, pattern, [](char ch, char mask) -> bool {
        auto found{ validators.find(mask) };
        
        if (found != validators.end())
        {
            // 在验证器中找到了模式的当前元素。调用对应的
            // 函数。
            return (*found->second)(ch);
        }

        // 在验证器中没有找到模式的当前元素。
        // 字符必须完全匹配。
        return ch == mask;
        }); // lambda 结束
}

int main()
{
    std::string phoneNumber{};

    do
    {
        std::cout << "Enter a phone number (###) ###-####: ";
        std::getline(std::cin, phoneNumber);
    } while (!inputMatches(phoneNumber, "(###) ###-####"));

    std::cout << "You entered: " << phoneNumber << '\n';
}

使用此函数可以强制用户严格匹配指定格式。 不过,这个函数仍有一些限制:如果用户输入中允许使用 #、@、_ 和 ?,它就无法正常工作,因为这些符号已有特殊含义。此外,与正则表达式不同,这里没有表示“可输入任意数量字符”的模板符号。因此,不能用这种模板确保用户输入两个由空白分隔的单词,因为单词长度是可变的。对于这类问题,通常应使用非模板方式。

数值验证

处理数值输入时,显而易见的方法是用提取运算符把输入提取到数值类型。检查 failbit 即可判断用户是否输入了数字。

试试这种方法:

C++
#include <iostream>
#include <limits>

int main()
{
    int age{};

    while (true)
    {
        std::cout << "Enter your age: ";
        std::cin >> age;

        if (std::cin.fail()) // 未发生提取
        {
            std::cin.clear(); // 将状态位重置为 goodbit,以便使用 ignore()
            std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n'); // 清除输入流中的错误输入
            continue; // 重试
        }

        if (age <= 0) // 确保 age 为正数
            continue;

        break;
    }

    std::cout << "You entered: " << age << '\n';
}

如果用户输入整数,提取就会成功。std::cin.fail() 会求值为 false,跳过条件分支;假设输入正数,就会执行 break,退出循环。

如果用户输入以字母开头的内容,提取就会失败。std::cin.fail() 会求值为 true,进入条件分支。 条件代码块末尾会执行 continue,跳回 while 循环顶部,再次要求用户输入。

但还有一种情况尚未测试:用户输入以数字开头、随后包含字母的字符串(例如“34abcd56”)。 此时开头数字(34)会提取到 age,剩余字符串(“abcd56”)留在输入流中,failbit 不会设置。 这会导致两个潜在问题:

  1. 如果希望这算有效输入,流中会残留垃圾数据。
  2. 如果不希望它有效,输入却不会被拒绝(流中仍会残留垃圾数据)。

先解决第一个问题。这很简单:

C++
#include <iostream>
#include <limits>

int main()
{
    int age{};

    while (true)
    {
        std::cout << "Enter your age: ";
        std::cin >> age;

        if (std::cin.fail()) // 未发生提取
        {
            std::cin.clear(); // 将状态位重置为 goodbit,以便使用 ignore()
            std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n'); // 清除输入流中的错误输入
            continue; // 重试
        }

        std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n'); // 清除输入流中的其他输入

        if (age <= 0) // 确保 age 为正数
            continue;

      break;
    }

    std::cout << "You entered: " << age << '\n';
}

如果不希望这种输入有效,还需要额外处理。 幸运的是,前面的解决方案已经完成了一半。 可以使用 gcount() 函数确定忽略了多少字符。 如果输入有效,gcount() 应返回 1(被丢弃的换行符)。 如果返回值大于 1,说明用户输入了未正确提取的内容,应要求重新输入。 下面是一个示例:

C++
#include <iostream>
#include <limits>

int main()
{
    int age{};

    while (true)
    {
        std::cout << "Enter your age: ";
        std::cin >> age;

        if (std::cin.fail()) // 未发生提取
        {
            std::cin.clear(); // 将状态位重置为 goodbit,以便使用 ignore()
            std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n'); // 清除输入流中的错误输入
            continue; // 重试
        }

        std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n'); // 清除输入流中的其他输入
        if (std::cin.gcount() > 1) // 如果清除了多于一个额外字符
        {
            continue; // 将此输入视为无效
        }

        if (age <= 0) // 确保 age 为正数
        {
            continue;
        }

        break;
    }

    std::cout << "You entered: " << age << '\n';
}

将数值作为字符串验证

上面的示例只是获取一个简单值,却做了很多工作!另一种处理数值输入的方法是先读入字符串,再尝试转换为数值类型。 下面的程序采用这种方法:

C++
#include <charconv> // std::from_chars
#include <iostream>
#include <limits>
#include <optional>
#include <string>
#include <string_view>

// std::optional<int> 返回 int 或空值
std::optional<int> extractAge(std::string_view age)
{
    int result{};
    const auto end{ age.data() + age.length() }; // 获取底层 C 风格字符串的末尾迭代器

    // 尝试从 age 解析 int
    // 如果发生某种错误……
    if (std::from_chars(age.data(), end, result).ec != std::errc{})
    {
        return {}; // 返回空值
    }

    if (result <= 0) // 确保 age 为正数
    {
        return {}; // 返回空值
    }

    return result; // 返回 int 值
}

int main()
{
    int age{};

    while (true)
    {
        std::cout << "Enter your age: ";
        std::string strAge{};

        // 尝试读取一行输入
        if (!std::getline(std::cin >> std::ws, strAge))
        {
            // 如果失败,清理后重试
            std::cin.clear();
            std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');    
            continue;
        }

        // 尝试提取年龄
        auto extracted{ extractAge(strAge) };

        // If we failed, try again
        if (!extracted)
            continue;

        age = *extracted; // 获取值
        break;
    }

  std::cout << "You entered: " << age << '\n';
}

这种方法比直接数值提取更省事还是更麻烦,取决于验证参数和限制。

如你所见,在 C++ 中进行输入验证需要不少工作。幸运的是,许多任务(例如将数值作为字符串验证)都可以轻松封装为函数,在各种场景中复用。

最后更新