一個讓代碼可讀性暴增的現代C++特性，同事看了都說好！

作者：everystep 2024-12-12 12:00:00

來看看 C++23 帶來的三個超酷的魔法技能！就像是給你的 optional 裝備了三件神器一樣。

嘿，小伙伴們！你是否經常遇到這樣的煩惱：某個值它可能存在，也可能不存在，就像薛定諤的貓一樣？

比如說：

想找找配置文件里有沒有那個神秘的設置項
在數據庫里尋找那個可能已經"蒸發"的用戶記錄
解析用戶輸入的數據（天知道他們會輸入什么奇怪的東西！）

在 C++17 這位英雄出現之前，我們都是這樣痛苦地處理的：

// ?? 老方法1：用指針來搞定
User* findUser(const string& name) {
    // 找到了就返回指針，找不到就返回 nullptr
    // 但是等等...這個指針誰來刪啊？記不住刪除的話就內存泄漏啦！??
}

// ?? 老方法2：用 pair 大法
pair<User, bool> findUser(const string& name) {
    // 返回一個值和一個標志位
    // 但是...就算沒找到也要構造一個 User 對象，這不是白白浪費資源嘛！??
}

但是！現在有了 std::optional，一切都變得簡單優雅了！

就像給代碼加了魔法一樣，再也不用為這些煩惱而頭疼了！

一、實戰示例

1. 和數據庫玩捉迷藏

#include <optional>
#include <string>

// 用戶類 - 簡單但夠用 ??
class User {
    std::string name;
    int age;
public:
    User(std::string n, int a) : name(n), age(a) {}
    void sayHi() { std::cout << "我是" << name << "，" << age << "歲~" << std::endl; }
};

// 尋找用戶 - 返回 optional ??
std::optional<User> findUser(const std::string& name) {
    if (name == "張三") {
        return User("張三", 25);  // 找到啦! ?
    }
    return std::nullopt;  // 沒找到... ??
}

int main() {
    // 方法1: 直接判斷 - 簡單粗暴 ??
    if (auto user = findUser("張三")) {
        user->sayHi();  // 張三出現啦!
    }
    
    // 方法2: value_or - 永遠有備胎 ??♂? 
    auto user = findUser("李四").value_or(User("替補", 18));
}

看，使用 std::optional 讓我們的代碼變得多么優雅！再也不用寫那些煩人的空指針檢查了。就像是給代碼裝上了自動駕駛系統，不管找沒找到用戶，都能優雅地處理！

小貼士：

value_or() 就像是你的救生圈，隨時準備救場
用 if (user) 判斷比 if (user != nullopt) 更簡潔優雅
記住，這不是指針，是更智能的存在！就像是給數據穿上了防彈衣 ???

2. 配置小助手：端口號探險記

// 我們的端口號偵探 ??
std::optional<int> parsePort(const std::string& config) {
    // 先看看是不是都是數字 ??
    if (!std::all_of(config.begin(), config.end(), ::isdigit)) {
        return std::nullopt;  // 發現不是數字的字符，任務失敗！??♂?
    }
    
    // 轉換成數字（這里一定成功，因為已經檢查過了）
    int port = std::stoi(config);
    
    // 端口號體檢時間！確保它身體健康 ??
    if (port > 0 && port < 65536) {
        return port;  // 這個端口號合格，準許通過！?
    }
    
    return std::nullopt;  // 抱歉，這個端口號不合格 ??
}

void startServer() {
    // 如果 8080 端口不行，就啟用我們的替補選手 80 端口！??♂?
    auto port = parsePort("8080")
        .value_or(80);  // 永遠要有 Plan B！
    
    std::cout << "火箭發射！?? 服務器已啟動在端口: " << port << std::endl;
}

看，我們的端口號探險家變得更加穩健了！通過提前檢查輸入字符串，我們優雅地避開了異常處理，代碼更加清晰易讀。就像是給我們的小助手配備了 X 光視覺，能提前發現潛在的問題！???

小提示：

使用 std::all_of 優雅地檢查輸入的有效性，比 try-catch 更加直觀
value_or() 依然是我們的安全網，在解析失敗時提供默認值
范圍檢查確保端口號在合理區間內，保證服務器的安全運行 ???

3. 鏈式調用的魔法 ? (C++23)

// ?? 我們的主角們
std::optional<User> findUser(const std::string& name);          // 尋人啟事
std::optional<std::string> getUserEmail(const User& user);      // 獲取郵箱大師
std::optional<bool> sendEmail(const std::string& email);        // 郵件快遞員

void notifyUser(const std::string& username) {
    // ?? 見證魔法的時刻！就像雜技演員的完美配合
    auto result = findUser(username)                // 第一位演員：找到用戶
        .and_then(getUserEmail)                     // 第二位演員：獲取郵箱
        .and_then(sendEmail)                        // 第三位演員：發送郵件
        .value_or(false);                          // ?? 觀眾不滿意就返回 false
        
    if (result) {
        std::cout << "Ta-da! ?? 郵件成功送達！" << std::endl;
    } else {
        std::cout << "哎呀，表演失敗了... ??" << std::endl;
    }
}

小提示：

and_then 就像魔術師的接力棒，一個動作完成后才會傳給下一個
任何一個環節失敗，整個魔術表演就會停止
value_or 就像是我們的保底計劃，魔術失敗也不會讓觀眾失望！

二、使用小貼士

(1) 選擇 value_or() 做你的安全網

value() 就像個炸彈，一不小心就會爆炸（拋異常）
value_or() 則像個可靠的好朋友，永遠給你準備好 Plan B

(2) 條件判斷玩法 - 簡單又帥氣！

// 像變魔術一樣優雅 ?
if (auto user = findUser("張三")) {
    // 哇！張三出現了！直接用 *user 打招呼
    // 再也不用寫又臭又長的判空檢查啦～
}

(3) optional 是個神奇的盒子，不是指針！

不用擔心內存泄漏，它會自己收拾好一切
值就住在盒子里，不用到處跑來跑去
就像哆啦A夢的口袋，想要的時候就能拿出來！

三、高級特性詳解

1. optional 的百變造型秀

// 來看看 optional 的各種裝扮！
std::optional<int> op1;               // 空空如也的 optional ??
std::optional<int> op2(std::nullopt); // 明確說"我是空的"的 optional ??♂?
std::optional<int> op3(42);           // 裝著數字42的 optional ??
std::optional<int> op4 = 42;          // 同上，但寫法更時髦 ?
std::optional<int> op5(op3);          // 復制一個一模一樣的 optional ??

// 最潮的創建方式 - make_optional
auto op6 = std::make_optional(42);    // 讓編譯器自己猜類型，懶人必備！??

小貼士：

就像變形金剛一樣，optional 有多種形態可以變換！
std::nullopt 就像是 optional 的休假狀態 ???
make_optional 就像是個智能助手，幫你省去寫類型的麻煩 ??

2. optional 值的獲取大法

std::optional<std::string> getMessage() {
    return "你好呀~";  // 返回一個可愛的問候 ??
}

void demo() {
    auto msg = getMessage();
    
    // 1. value() 大法 - 勇者無畏版 ??
    // 警告：這招威力巨大，失手可能會炸！??
    try {
        std::string str = msg.value();
    } catch(const std::bad_optional_access& e) {
        // 哎呀，炸了... ??
        std::cout << "啊！value() 炸了，快來救火！" << std::endl;
    }
    
    // 2. 星號(*) 和箭頭(->) 大法 - 忍者偷襲版 ??
    // 溫馨提示：使用前請確認目標已經存在，否則...??
    if (msg) {  // 先用探測術確認一下
        std::cout << *msg << std::endl;         // 解封印！
        std::cout << msg->length() << std::endl; // 使用飛鏢攻擊！
    }
    
    // 3. value_or() 大法 - 穩妥派必備 ???
    // 這招最安全，就算失敗也有替補方案！
    std::string str = msg.value_or("我是替補選手~");  // 永遠不會空手而歸！
}

武功秘籍：

value() 就像是一招絕技，威力巨大但風險也高 ??
星號解引用就像是忍者的飛鏢，要確保目標存在才能使用 ??
value_or() 則是最穩妥的功夫，隨時準備好了 Plan B ???

記住：真正的高手都喜歡用 value_or()，因為他們知道，留得青山在，不怕沒柴燒！??

3. C++23 的魔法三劍客

來看看 C++23 帶來的三個超酷的魔法技能！就像是給你的 optional 裝備了三件神器一樣~

// 首先，我們需要兩個可靠的小幫手 ??
std::optional<int> safe_divide(int a, int b) {
    if (b == 0) return std::nullopt;  // 除以0？不存在的！??♂?
    return a / b;
}

std::optional<std::string> number_to_string(int n) {
    return std::to_string(n);  // 數字變字符串，變變變！?
}

void monadic_demo() {
    // ?? 第一招：transform - 數值煉金術！
    auto result1 = safe_divide(10, 2)
        .transform([](int n) { return n * 2; });  
    // 安全除法后再翻倍，就像給數字開掛一樣！結果是 optional<int>(10)
    
    // ?? 第二招：and_then - 完美接力賽！
    auto result2 = safe_divide(10, 2)
        .and_then([](int n) { 
            return number_to_string(n); 
        });  
    // 像接力跑一樣，先除法，成功了就轉字符串，結果是 optional<string>("5")
    
    // ?? 第三招：or_else - 神奇替補隊員！
    auto result3 = safe_divide(10, 0)
        .or_else([]() { 
            return std::optional<int>(0); 
        });  
    // 哎呀，除以0失敗了？沒關系！替補選手0上場！結果是 optional<int>(0)
}

魔法使用指南：

transform 就像是煉金術，能把值變成另一種值，但保持 optional 的外殼不變
and_then 就像是接力跑選手，上一棒成功才會接力給下一棒
or_else 就像是你的替補選手，主力隊員受傷了它立馬頂上！

有了這三個法術，處理可選值簡直就像變魔術一樣簡單！再也不用寫那些煩人的 if 判斷啦~

四、optional 的內部秘密 - 性能大揭秘

想知道 optional 是怎么把魔法實現的嗎？讓我們一起來揭開它的面紗！

template<typename T>
class optional {
    bool has_value_;        // 1個字節的魔法開關 ???
    alignas(T) char data_[sizeof(T)];  // 數據的秘密基地 ??
    // ... 其他神秘咒語 ...
};

optional 的空間管理藝術

想象一下，optional 就像是一個精心設計的迷你公寓：

(1) 超級節省的空間布局

只比原始類型多用了一個字節（就是那個魔法開關）
就像在你的房間里加了個小小的電燈開關一樣簡單！

(2) 完美的內存對齊

數據存儲空間會自動對齊，就像把家具完美擺放在格子里
比如 optional<int> 通常占用 8 字節（4字節int + 1字節標志 + 3字節對齊填充）

(3) 極速性能表現

沒有動態內存分配，所有數據都乖乖待在棧上
就像所有東西都放在手邊，想拿就拿，超級方便！

小彩蛋：對于可以簡單拷貝的類型（trivially copyable）， optional 還會開啟特殊加速模式，就像給你的代碼裝上了小型火箭推進器！

五、優秀實踐錦囊

來看看使用 optional 的幾個武林秘籍，讓你的代碼更上一層樓！

1. 跟"魔法值"說拜拜


// ?? 這樣寫就像給代碼下咒語，誰知道 -1 是什么意思？
int findIndex() { 
    return -1;  // 這個魔法值會讓后人摸不著頭腦！
}

// ? 這樣寫就像水晶球一樣透明，一看就懂！
std::optional<size_t> findIndex() {
    // 找到了就返回索引，找不到就優雅地返回 nullopt
    // 再也不用解釋那個神秘的 -1 是什么意思啦！
}

2. 結構化綁定：完美搭檔

// 就像功夫片里的雙節棍，一出手就知有沒有！
if (auto [value, success] = getValue(); success) {
    // value 在這里已經準備就緒，可以大顯身手了！
    // 多優雅啊，不用再寫又臭又長的判斷了 ??
}

3. 遠離套娃陷阱

// ?? 這樣寫就像俄羅斯套娃，讓人頭暈眼花
std::optional<std::optional<int>> nested;  // 套娃警告！??

// ?? 這樣寫就清爽多了，簡單直接！
std::optional<int> better;  // 干凈利落，一目了然！

小貼士：

optional 就像是一個魔法盒子，但不要把盒子套盒子哦！
結構化綁定就是你的好幫手，讓代碼更清晰易讀
記住：簡單就是美，過度包裝反而會把事情搞復雜！

有了這些秘籍，你的代碼一定會變得更加優雅漂亮！讓我們一起告別那些神秘兮兮的魔法值，擁抱現代 C++ 的美好吧！

現在，告別那些又臭又長的返回值檢查吧！讓 std::optional 來拯救你的代碼！

責任編輯：趙寧寧來源： everystep

代碼 C++