第十一章

约 1730 字大约 6 分钟

2025-05-28

本章概述

C++17引入了许多重要的新特性，这些特性大大提升了代码的表达力和性能。本章将深入学习结构化绑定、stdvariant、std::optional的高级用法等核心特性。

学习目标

掌握结构化绑定的各种用法
理解std::string_view的性能优势
学会使用std::variant进行类型安全的联合体操作
深入理解std::optional的最佳实践
了解std::any的使用场景

11.1 结构化绑定 (Structured Bindings)

基本概念

结构化绑定允许我们将聚合类型（如tuple、pair、数组、结构体）的成员一次性绑定到多个变量上。

基本语法

auto [变量1, 变量2, ...] = 表达式;

使用场景

1. 解构stdtuple

// 传统方式
std::pair<int, std::string> p = {42, "hello"};
int first = p.first;
std::string second = p.second;

// 结构化绑定
auto [value, text] = std::make_pair(42, "hello");

2. 遍历map容器

std::map<std::string, int> scores = {{"Alice", 95}, {"Bob", 87}};

// 传统方式
for (const auto& item : scores) {
    std::cout << item.first << ": " << item.second << std::endl;
}

// 结构化绑定
for (const auto& [name, score] : scores) {
    std::cout << name << ": " << score << std::endl;
}

3. 函数返回多个值

std::tuple<bool, int, std::string> parseInput(const std::string& input);

auto [success, value, error] = parseInput("123");
if (success) {
    std::cout << "Parsed value: " << value << std::endl;
} else {
    std::cout << "Error: " << error << std::endl;
}

4. 解构自定义结构体

struct Point {
    double x, y;
};

Point getCenter() {
    return {3.14, 2.71};
}

auto [x, y] = getCenter();

高级用法

引用绑定

std::array<int, 3> arr = {1, 2, 3};
auto& [a, b, c] = arr;
a = 10;  // 修改原数组

const绑定

const auto [x, y] = std::make_pair(1, 2);
// x = 10;  // 编译错误，x是const

11.2 std::string_view

基本概念

std::string_view是一个轻量级的字符串视图，它不拥有字符串数据，只是提供了一个查看字符串的窗口。

性能优势

避免不必要的字符串复制
统一处理C风格字符串和std::string
常量时间的子字符串操作

基本用法

#include <string_view>

void processString(std::string_view sv) {
    std::cout << "Processing: " << sv << std::endl;
    std::cout << "Length: " << sv.length() << std::endl;
}

// 可以接受多种字符串类型
std::string str = "Hello";
const char* cstr = "World";
processString(str);    // 不会复制
processString(cstr);   // 不会复制
processString("Literal");  // 不会复制

子字符串操作

std::string_view text = "Hello, World!";
auto hello = text.substr(0, 5);     // "Hello"
auto world = text.substr(7, 5);     // "World"
// 这些操作都是O(1)时间复杂度，不涉及内存分配

注意事项

生命周期管理

std::string_view dangling() {
    std::string temp = "temporary";
    return temp;  // 危险！返回悬空引用
}

std::string_view safe() {
    static const char* permanent = "permanent";
    return permanent;  // 安全
}

与std::string的转换

std::string_view sv = "hello";
std::string str(sv);  // 显式转换为std::string

11.3 std::variant

基本概念

std::variant是一个类型安全的联合体，可以存储多种类型中的一种，并且总是知道当前存储的是哪种类型。

基本用法

#include <variant>

std::variant<int, double, std::string> value;

value = 42;           // 存储int
value = 3.14;         // 存储double
value = "hello";      // 存储string

访问variant的值

1. std::get

std::variant<int, std::string> v = 42;

try {
    int i = std::get<int>(v);        // 按类型获取
    int j = std::get<0>(v);          // 按索引获取
    std::string s = std::get<std::string>(v);  // 抛出异常
} catch (const std::bad_variant_access& e) {
    std::cout << "Wrong type access" << std::endl;
}

2. std::get_if

std::variant<int, std::string> v = "hello";

if (auto* pval = std::get_if<std::string>(&v)) {
    std::cout << "String value: " << *pval << std::endl;
} else {
    std::cout << "Not a string" << std::endl;
}

3. std::visit

std::variant<int, double, std::string> v = 3.14;

std::visit([](const auto& value) {
    std::cout << "Value: " << value << std::endl;
}, v);

// 或者使用重载的访问者
struct Visitor {
    void operator()(int i) { std::cout << "Integer: " << i << std::endl; }
    void operator()(double d) { std::cout << "Double: " << d << std::endl; }
    void operator()(const std::string& s) { std::cout << "String: " << s << std::endl; }
};

std::visit(Visitor{}, v);

实际应用示例

表达式求值器

struct Number { double value; };
struct Addition { 
    std::unique_ptr<Expression> left, right; 
};
struct Multiplication { 
    std::unique_ptr<Expression> left, right; 
};

using Expression = std::variant<Number, Addition, Multiplication>;

double evaluate(const Expression& expr) {
    return std::visit([](const auto& e) -> double {
        if constexpr (std::is_same_v<std::decay_t<decltype(e)>, Number>) {
            return e.value;
        } else if constexpr (std::is_same_v<std::decay_t<decltype(e)>, Addition>) {
            return evaluate(*e.left) + evaluate(*e.right);
        } else {
            return evaluate(*e.left) * evaluate(*e.right);
        }
    }, expr);
}

11.4 std::optional深入

高级用法

链式操作

std::optional<std::string> getName();
std::optional<int> getAge();

auto result = getName()
    .and_then([](const std::string& name) -> std::optional<std::string> {
        if (name.empty()) return std::nullopt;
        return "Hello, " + name;
    })
    .or_else([]() -> std::optional<std::string> {
        return "Hello, Anonymous";
    });

与异常处理结合

std::optional<int> safeDivide(int a, int b) {
    if (b == 0) return std::nullopt;
    return a / b;
}

auto result = safeDivide(10, 0);
int value = result.value_or(-1);  // 提供默认值

性能考虑

// 避免不必要的构造
std::optional<ExpensiveObject> createObject(bool condition) {
    if (!condition) return std::nullopt;
    return std::make_optional<ExpensiveObject>(/* args */);
}

11.5 std::any

基本概念

std::any可以存储任何可复制构造的类型的值，提供类型擦除功能。

基本用法

#include <any>

std::any value;
value = 42;
value = std::string("hello");
value = 3.14;

// 获取值
try {
    int i = std::any_cast<int>(value);  // 抛出异常
} catch (const std::bad_any_cast& e) {
    std::cout << "Wrong type" << std::endl;
}

// 安全获取
if (auto* ptr = std::any_cast<double>(&value)) {
    std::cout << "Double value: " << *ptr << std::endl;
}

使用场景

配置系统

class Config {
    std::map<std::string, std::any> settings;
    
public:
    template<typename T>
    void set(const std::string& key, const T& value) {
        settings[key] = value;
    }
    
    template<typename T>
    std::optional<T> get(const std::string& key) const {
        auto it = settings.find(key);
        if (it == settings.end()) return std::nullopt;
        
        try {
            return std::any_cast<T>(it->second);
        } catch (const std::bad_any_cast&) {
            return std::nullopt;
        }
    }
};