标准库特殊设施

#include <tuple>
 
std::tuple<int, double, std::string> t(42, 3.14, "hello");
// t 是一个打包好的三元素包裹

// 方式一：直接构造（显式写类型）
std::tuple<int, double, std::string> t1(42, 3.14, "hello");
 
// 方式二：make_tuple（自动推导——最常用）
auto t2 = std::make_tuple(42, 3.14, "hello");
// t2 的类型被推导为 tuple<int, double, const char*>
 

auto t = std::make_tuple(42, 3.14, std::string("hello"));
int x = std::get<0>(t);              // x = 42
std::get<0>(t) = 100;                // 直接修改 tuple 中的 int

#include <bitset>
 
std::bitset<8> b("10100110");  // 用二进制字符串初始化 8 位
// b[0] = 0, b[1] = 1, b[2] = 1, b[3] = 0, b[4] = 0, b[5] = 1, b[6] = 0, b[7] = 1

std::bitset<8> b(0b10100110);
b <<= 3;                            // 左移 3 位，低位补 0
std::cout << b;                     // 直接输出二进制——00110000
std::cout << b.count();             // 2——只有原来的第 5、6 位还是 1

std::regex re(R"((\d+)-(\w+))");     // R"(...)" 是原始字符串——反斜杠不用转义
std::string s = "abc 123-xyz def";
 
// regex_search：子串匹配——"123-xyz" 匹配成功
std::smatch m;
bool found = std::regex_search(s, m, re);  // found=true, m[0]="123-xyz"
 
// regex_match：全串匹配——整个 s 必须完全符合模式（"abc 123-xyz def" 不符合）→ false
bool full = std::regex_match(s, re);       // full=false
 
// regex_replace：替换——把所有匹配替换成指定格式
std::string replaced = std::regex_replace(s, re, "[$1:$2]");
// "abc [123:xyz] def"

std::string text = "Alice: 1, Bob: 2, Charlie: 3";
std::regex re(R"((\w+): (\d+))");
 
for (auto it = std::sregex_iterator(text.begin(), text.end(), re);
     it != std::sregex_iterator{}; ++it) {
    std::cout << "Name: " << (*it)[1]      // 捕获组 1——名字
              << ", Num: " << (*it)[2]     // 捕获组 2——数字
              << '\n';
}
// Name: Alice, Num: 1
// Name: Bob, Num: 2
// Name: Charlie, Num: 3

#include <random>
#include <iostream>
 
// 创建长期存活的引擎；random_device 是否非确定由实现决定
std::mt19937 gen(std::random_device{}());
 
// 分布——按需创建，用完即弃，成本极低
auto dice = std::uniform_int_distribution<int>(1, 6);
auto prob = std::uniform_real_distribution<double>(0.0, 1.0);
auto height = std::normal_distribution<double>(170.0, 10.0);  // 身高：均值 170，标准差 10
auto coin = std::bernoulli_distribution(0.5);                 // 公平硬币
 
// 使用——分布对象像函数一样调用
std::cout << dice(gen);    // 1~6 均匀骰子
std::cout << prob(gen);    // [0.0, 1.0) 均匀实数
std::cout << height(gen);  // 近似正态分布的身高模拟
std::cout << coin(gen);    // true/false 各 50%

#include <iomanip>
#include <iostream>
 
std::cout << std::hex << std::showbase << 255 << '\n'; // 0xff
std::cout << std::dec << std::fixed
          << std::setprecision(2) << 3.14159 << '\n';  // 3.14
std::cout << std::setfill('0') << std::setw(6) << 42 << '\n';
// 000042；setw 只管 42，setfill 仍保留在流上

char ch;
std::cin >> std::noskipws;
while (std::cin >> ch) {
    if (ch == ' ') std::cout << "[space]";
    else std::cout << ch;
}
std::cin >> std::skipws;

#include <regex>
#include <string>
#include <tuple>
#include <vector>
#include <bitset>
#include <iostream>
 
// 用正则从配置行提取所有 "key=value" 对
auto parse_config(const std::string &line) {
    std::regex re(R"((\w+)=(\d+))");  // key=数字
    std::vector<std::tuple<std::string, int>> result;
 
    auto begin = std::sregex_iterator(line.begin(), line.end(), re);
    for (auto it = begin; it != std::sregex_iterator{}; ++it) {
        result.emplace_back(
            (*it)[1].str(),              // key —— 捕获组 1
            std::stoi((*it)[2].str())   // value —— 捕获组 2，转整数
        );
    }
    return result;
}

int main() {
    std::string config = "feature:dark_mode=1;caching=1;logging=0;debug=0";
 
    auto items = parse_config(config);
    // items = { {"dark_mode",1}, {"caching",1}, {"logging",0}, {"debug",0} }
 
    // 用 bitset 存四位标志——每一位对应一个配置开关
    std::bitset<4> flags;
    for (std::size_t i = 0; i < items.size(); ++i) {
        if (std::get<1>(items[i]) == 1)   // 如果 value=1
            flags.set(i);                  // 对应的标志位置 1
    }
    std::cout << "flags: " << flags << '\n';          // 0011
    std::cout << "count: " << flags.count() << '\n';  // 2 项开启
 
    // C++11：按编译期索引读取 tuple
    for (const auto &item : items) {
        std::cout << std::get<0>(item)
                  << " = " << std::get<1>(item) << '\n';
    }
    // dark_mode = 1
    // caching = 1
    // logging = 0
    // debug = 0
}

#include <random>
 
std::string make_random_config() {
    static std::mt19937 gen(std::random_device{}());
    std::uniform_int_distribution<int> coin(0, 1);
 
    return std::string("feature:")
        + "dark_mode=" + std::to_string(coin(gen)) + ";"
        + "caching="   + std::to_string(coin(gen)) + ";"
        + "logging="   + std::to_string(coin(gen)) + ";"
        + "debug="     + std::to_string(coin(gen));
}
 
// 生成 100 行随机配置并解析
for (int i = 0; i < 100; ++i) {
    auto items = parse_config(make_random_config());
    // ...
}