C++23 std::optional 的新函式

其中，or_else() 是在沒有值的狀況下、去執行指定的函式、並回傳同樣的型別。

這樣的設計應該算是讓開發者更簡單地依序去測試各種方法，來取得最後的結果。

下面是一個例子：

#include <iostream>
#include <optional>
 
std::optional<int> getValueMethod1()
{
  return std::nullopt;
}
 
std::optional<int> getValueMethod2()
{
  return 2;
}
 
int main()
{
  int iValue = 0;
 
  std::optional<int> optVal = getValueMethod1();
  if (optVal)
  {
    iValue = *optVal;
  }
  else
  {
    optVal = getValueMethod2();
    if (optVal)
      iValue = *optVal;
  }
 
  std::cout << iValue << std::endl;
}

這邊有 getValueMethod1() 和 getValueMethod2() 兩個函式可以用來取得值，而且都有可能失敗；這邊為了測試，是讓 getValueMethod1() 固定回傳 std::nullopt。

在 main() 裡面的程式，則是希望先試試看 getValueMethod1() 是否可以成功，如果失敗的話再試試看 getValueMethod2()，然後最後的結果就是 iValue 這個變數；以上面的程式來說，最後的結果會是 2。

而這邊的程式在 C++23，就可以透過 or_else() 來做簡化，可以一行解決：

int iValue = getValueMethod1().or_else(getValueMethod2).value_or(0);

在個人來看，這樣的設計在符合使用情境的狀況下，確實是滿方便的。

相較於前面的 or_else() 是在沒有值的狀況下才會去執行，另外兩個 and_then() 和 transform() 則是只有在有值得狀況下才會去執行所傳入的可呼叫物件；而他們會去處理 std::optional 的值並回傳、同時也可以改變回傳值的型別。

兩者的差別主要應該是對於傳入的可呼叫物件的回傳值的形式有不同的要求。

給 and_then() 的函式需要回傳 std::optional，算是把整個使用 std::optional 系統串起來的感覺。

而給 transform() 的函式則是則是回傳一般的值，然後 transform() 會再包一層 std::optional；基本上算是讓本來沒有使用 std::optional 的既有函式也可以拿來用。

下面是一個例子：

#include <iostream>
#include <string>
#include <optional>
#include <algorithm>
 
std::string toLower(std::string s)
{
  std::transform(s.begin(), s.end(), s.begin(),
    [](unsigned char c) { return std::tolower(c); });
  return s;
}
 
std::optional<std::string> getTextInRange(const std::string& sText,
  std::string_view t1, std::string_view t2)
{
  size_t uPos1 = sText.find(t1);
  if (uPos1 != std::string::npos)
  {
    uPos1 += t1.size();
    size_t uPos2 = sText.find(t2, uPos1);
    if (uPos2 != std::string::npos)
      return sText.substr(uPos1, uPos2 - uPos1);
  }
  return std::nullopt;
}
 
std::optional<std::string> getQuoted(const std::string& sText)
{
  return getTextInRange(sText, "\"", "\"");
}
 
std::optional<std::string> getParentheses(const std::string& sText)
{
  return getTextInRange(sText, "(", ")");
}
 
std::optional<std::string> getText()
{
  return R"tt(test: "Hello world (Hi)")tt";
}
 
int main()
{
  auto s = getText().and_then(getQuoted).and_then(getParentheses)
            .transform(toLower);
  if (s)
    std::cout << *s << std::endl;
}

這邊就是先透過 getText() 來取得文字，並在有值的時候，依序去執行 getQuoted()、getParentheses()、toLower() 這幾個函式，最後得到的結果會是「hi」。

透過這樣的機制，就可以把許多函示串聯起來、一次處理掉，而不需要個別去檢查他們的回傳值了。

而這邊要注意的，是由於 toLower() 回傳的型別是 std::string，所以要用 transform()、不能用 and_then()。

另一方面，如果把 getQuoted() 這種回傳 std::optional<std::string> 的函式拿來搭配 transform() 的話，得到的結果則會變成 std::optional<std::optional<std::string>>、也就是多加了一層。

此外，這邊的函式也不一定都得輸入字串、回傳字串，實際上也可以把它處理成其他型別，只要全部串的起來就好。

下面就是一個空的例子：

#include <iostream>
#include <optional>
 
struct A {};
struct B {};
struct C {};
 
std::optional<C> convBC(B)
{
  return C();
}
 
std::optional<B> convAB(A)
{
  return B();
}
 
int main()
{
  std::optional<A> optA;
  std::optional<C> optC = optA.and_then(convAB).and_then(convBC);
}

不過不知道為什麼，這邊好像沒辦法處理 function overloading？這邊如果把 convBC() 和 convAB() 都改名成 conv() 的話，雖然一般使用可以靠引數型別的不同來區分，但是搭配 and_then() 就編譯不過了。