C 与 C++：一对父子的渐行渐远

auto result = std::ranges::views::filter(numbers, [](int n) { return n > 0; })
            | std::ranges::views::transform([](int n) { return n * 2; });

// C 语言：我相信你
int* p = (int*)malloc(100);  // 可能返回 NULL
*p = 42;                      // 如果 p 是 NULL，炸了
free(p);
*p = 0;                       // Use after free，炸了

// C++ 语言：我帮你管资源
auto p = std::make_unique<int>(42);  // 自动管理内存
// 离开作用域自动释放，不用操心

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>

#define MAX_WORD_LEN 100
#define MAX_WORDS 10000

typedef struct {
    char word[MAX_WORD_LEN];
    int count;
} WordCount;

WordCount words[MAX_WORDS];
int word_count = 0;

int find_word(const char* word) {
    for (int i = 0; i < word_count; i++) {
        if (strcmp(words[i].word, word) == 0) return i;
    }
    return -1;
}

void add_word(const char* word) {
    int idx = find_word(word);
    if (idx >= 0) {
        words[idx].count++;
    } else if (word_count < MAX_WORDS) {
        strcpy(words[word_count].word, word);
        words[word_count].count = 1;
        word_count++;
    }
}

int main() {
    FILE* f = fopen("input.txt", "r");
    if (!f) { perror("fopen"); return 1; }

    char word[MAX_WORD_LEN];
    while (fscanf(f, "%99s", word) == 1) {
        // 转小写
        for (char* p = word; *p; p++) *p = tolower(*p);
        add_word(word);
    }
    fclose(f);

    for (int i = 0; i < word_count; i++) {
        printf("%s: %d\n", words[i].word, words[i].count);
    }
    return 0;
}

#include <iostream>
#include <fstream>
#include <map>
#include <string>
#include <algorithm>
#include <cctype>

int main() {
    std::ifstream file("input.txt");
    if (!file) { std::cerr << "Cannot open file\n"; return 1; }

    std::map<std::string, int> word_count;
    std::string word;

    while (file >> word) {
        // 转小写
        std::transform(word.begin(), word.end(), word.begin(),
                       [](unsigned char c) { return std::tolower(c); });
        word_count[word]++;
    }
    // file 自动关闭（RAII）

    for (const auto& [w, count] : word_count) {  // C++17 结构化绑定
        std::cout << w << ": " << count << '\n';
    }
}

// C++11 之前
std::vector<int>::iterator it = vec.begin();
for (; it != vec.end(); ++it) { ... }

// C++11 之后
for (auto& item : vec) { ... }

// C++17 结构化绑定
std::map<std::string, int> scores = {{"Alice", 90}, {"Bob", 85}};
for (const auto& [name, score] : scores) {
    std::cout << name << ": " << score << '\n';
}

// C++17 std::optional
std::optional<int> find_value(int key) {
    if (key == 42) return 100;
    return std::nullopt;  // 明确表示"没有值"，比返回 -1 安全
}

// Concepts：让模板错误信息变得人类可读
template<typename T>
concept Addable = requires(T a, T b) { a + b; };

template<Addable T>
T add(T a, T b) { return a + b; }

// Ranges：管道式数据处理
#include <ranges>
auto result = numbers 
    | std::views::filter([](int n) { return n > 0; })
    | std::views::transform([](int n) { return n * 2; });

// Coroutines：异步生成器
generator<int> fibonacci() {
    int a = 0, b = 1;
    while (true) {
        co_yield a;
        auto tmp = a;
        a = b;
        b = tmp + b;
    }
}

// C++23: std::expected 错误处理
std::expected<int, std::string> parse_int(std::string_view s) {
    if (s.empty()) return std::unexpected("empty string");
    // ...
    return 42;
}

// C++23: std::print
std::print("Hello, {}!\n", "World");  // 终于不用 cout << 了

// 可能的 C++26 模式匹配语法（提案中）
inspect (value) {
    0 => { return "zero"; }
    1 => { return "one"; }
    x if (x < 0) => { return "negative"; }
    _ => { return "other"; }
};