欧美bbbwbbbw肥妇,免费乱码人妻系列日韩,一级黄片

C++17之std::visit的具體使用

 更新時間：2022年02月07日 09:47:47   作者：云洞  
本文主要介紹了C++17之std::visit的具體使用，文中通過示例代碼介紹的非常詳細，具有一定的參考價值，感興趣的小伙伴們可以參考一下

    它們必須明確地為每種可能的類型提供函數(shù)調(diào)用操作符。然后，使用相應的重載來處理當前的備選項類型。

1. 使用對象函數(shù)方式訪問

例1：

#include <iostream>
#include <variant>
#include <string>
 
struct MyVisitor
{
    void operator()(double d) const {
        std::cout << d << '\n';
    }
    void operator()(int i) const {
        std::cout << i << '\n';
    }
    void operator()(const std::string& s) const {
        std::cout << s << '\n';
}
};
int main()
{
    std::variant<int, double, std::string> var1(42), var2(3.14), var3("visit");
 
    std::visit(MyVisitor(), var1); // calls operator() for matching int type
 
    std::visit(MyVisitor(), var2); // calls operator() for matching double type
 
    std::visit(MyVisitor(), var3); // calls operator() for matching std::string type
 
    return 0;
}

結果如下：

 如果操作符()不支持所有可能的類型，或者調(diào)用不明確，則visit()調(diào)用是編譯時錯誤。還可以使用訪問者修改當前類型的值(但不能分配新類型的值)。

例2：

#include <iostream>
#include <variant>
#include <string>
 
struct Twice
{
    void operator()(double& d) const {
        d *= 2;
    }
    void operator()(int& i) const {
        i *= 2;
    }
    void operator()(std::string& s) const {
        s = s + s;
    }
};
 
int main()
{
    std::variant<int, double, std::string> var1(42), var2(3.14), var3("visit");
 
    std::visit(Twice(), var1); // calls operator() for matching int type
 
    std::visit(Twice(), var2); // calls operator() for matching double type
 
    std::visit(Twice(), var3); // calls operator() for matching std::string type
 
    std::cout << std::get<int>(var1) << std::endl;
    std::cout << std::get<double>(var2) << std::endl;
    std::cout << std::get<std::string>(var3) << std::endl;
 
    return 0;
}

結果如下：

注意，對象操作符應該為const函數(shù)，因為它們是無狀態(tài)的(它們不改變它們的行為，只改變傳遞的值，即不改變成員變量的值)。 

 2. 使用泛型Lambdas訪問

使用這個特性最簡單的方法是使用泛型lambda，它是一個函數(shù)對象，用于任意類型:

例3：

#include <iostream>
#include <variant>
#include <string>
 
auto printvariant = [](const auto& val) 
{
    std::cout << val << std::endl;
};
 
int main()
{
    std::variant<int, double, std::string> var1(42), var2(3.14), var3("visit");
 
    std::visit(printvariant, var1);
 
    std::visit(printvariant, var2);
 
    std::visit(printvariant, var3);
 
    return 0;
}

結果如下：

 這里，泛型lambda定義了一個閉包類型，其中函數(shù)調(diào)用操作符作為成員模板:

class CompilerSpecifyClosureTypeName 
{
public:
template<typename T>
auto operator() (const T& val) const 
{
    std::cout << val << '\n';
}
};

也可以使用lambda來修改當前選項的值:

例4：

#include <iostream>
#include <variant>
#include <string>
 
auto printvariant = [](const auto& val)
{
    std::cout << val << std::endl;
};
 
int main()
{
    std::variant<int, double, std::string> var1(42), var2(3.14), var3("visit");
 
    std::visit([](auto& val) {
        val = val + val;
        },
        var1);
    std::visit([](auto& val) {
        val = val + val;
        },
        var2);
    std::visit([](auto& val) {
        val = val + val;
        },
        var3);
 
    std::visit(printvariant, var1);
    std::visit(printvariant, var2);
    std::visit(printvariant, var3);
 
    return 0;
}

結果如下：

甚至可以使用編譯時if語言特性以不同的方式處理不同的備選值：

例5：

#include <iostream>
#include <variant>
#include <string>
 
auto dblvar = [](auto& val)
{
    if constexpr (std::is_convertible_v<decltype(val), std::string>)
    {
        val = val + " test";
    }
    else
    {
        val += 2;
    }
};
 
int main()
{
    std::variant<int, double, std::string> var1(42), var2(3.14), var3("visit");
 
    std::visit(dblvar, var1);
    std::visit(dblvar, var2);
    std::visit(dblvar, var3);
 
    std::cout << std::get<int>(var1) << std::endl;
    std::cout << std::get<double>(var2) << std::endl;
    std::cout << std::get<std::string>(var3) << std::endl;
 
    return 0;
}

這里，對于一個std::string類型備選項，泛型lambda的調(diào)用實例化它的泛型函數(shù)調(diào)用模板來計算:

val = val + “ test”;

而對于其他類型備選項，如int或double, lambda的調(diào)用實例化其通用函數(shù)調(diào)用模板來計算:

val += 2;

結果如下：

3. 使用重載的Lambdas來訪問

通過為函數(shù)對象和lambdas使用一個重載器，還可以定義一組lambdas，其中使用最佳匹配作為訪問者。假設，重載器定義為重載，如下所示：

template<typename... Ts>
struct overload : Ts...
{
using Ts::operator()...;
};
// base types are deduced from passed arguments:
template<typename... Ts>
overload(Ts...) -> overload<Ts...>;

可以使用重載訪問一個變量，為每個選項提供lambdas:

std::variant<int, std::string> var(42);
...
std::visit(overload{ // calls best matching lambda for current alternative
[](int i) { std::cout << "int: " << i << '\n'; },
[](const std::string& s) {
std::cout << "string: " << s << '\n'; },
},
var);

還可以使用泛型lambda。總是用最好的搭配。例如，要修改variant對象的當前類型備選項的值，可以使用重載將字符串和其他類型的值“加倍”：

auto twice = overload{
[](std::string& s) { s += s; },
[](auto& i) { i *= 2; },
};

    使用此重載，對于字符串類型備選項，將添加當前值，而對于所有其他類型，將值乘以2，這演示了variant對象的以下應用程序:

std::variant<int, std::string> var(42);
std::visit(twice, var); // value 42 becomes 84
...
var = "hi";
std::visit(twice, var); // value "hi" becomes "hihi"

例 6：

#include <iostream>
#include <variant>
#include <string>
 
template<typename... Ts>
struct overload : Ts...
{
    using Ts::operator()...;
};
 
template<typename... Ts>
overload(Ts...)->overload<Ts...>;
 
auto twice = overload{
        [](std::string& s) { s += s; },
        [](auto& i) { i *= 2; },
};
 
int main()
{
    std::variant<int, std::string> var1(42) , var3("visit");
 
    std::visit(twice, var1);
    std::visit(twice, var3);
    
    std::visit(overload{ // calls best matching lambda for current alternative
        [](int i) { std::cout << "int: " << i << '\n'; },
        [](const std::string& s) {
        std::cout << "string: " << s << '\n'; },
        },
        var1);
    
    std::visit(overload{ // calls best matching lambda for current alternative
       [](int i) { std::cout << "int: " << i << '\n'; },
       [](const std::string& s) {
       std::cout << "string: " << s << '\n'; },
        },
        var3);
    
    return 0;
}

結果如下：

 到此這篇關于C++17之std::visit的具體使用的文章就介紹到這了,更多相關C++17 std::visit內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關文章希望大家以后多多支持腳本之家！

相關文章

  • c_str()的用法詳細解析

    c_str()的用法詳細解析

    c_str（）就是把string類對象轉換成和c兼容的char *類型。這是為了與c語言兼容，在c語言中沒有string類型，故必須通過string類對象的成員函數(shù)c_str()把string 對象轉換成c中的字符串樣式
    2013-09-09
  • C++超詳細講解析構函數(shù)

    C++超詳細講解析構函數(shù)

    既然在創(chuàng)建對象時有構造函數(shù)（給成員初始化），那么在銷毀對象時應該還有一個清除成員變量數(shù)據(jù)的操作咯，析構函數(shù)與構造函數(shù)功能相反，析構函數(shù)不是完成對象的銷毀，局部對象銷毀工作是由編譯器完成的。而對象在銷毀時會自動調(diào)用析構函數(shù)，完成類的一些資源清理工作
    2022-06-06
  • c++ 類中const成員變量的賦值方法

    c++ 類中const成員變量的賦值方法

    下面小編就為大家?guī)硪黄猚++ 類中const成員變量的賦值方法。小編覺得挺不錯的，現(xiàn)在就分享給大家，也給大家做個參考。一起跟隨小編過來看看吧
    2016-12-12
  • C語言實現(xiàn)生成新春福字的示例詳解

    C語言實現(xiàn)生成新春福字的示例詳解

    這篇文章主要介紹了如何利用C語言實現(xiàn)生成各個字體的新春福字，再也不用擔心支付寶掃福找不到圖片了，感興趣的同學可以跟隨小編學習一下
    2022-01-01
  • C++中vector類的一些簡單實現(xiàn)

    C++中vector類的一些簡單實現(xiàn)

    C++中的std::vector是一個動態(tài)數(shù)組（也被稱為可變大小數(shù)組）的容器類,它是C++標準庫提供的其中一種容器類,提供了方便的操作和管理動態(tài)數(shù)組的功能,本文就給大家介紹了C++中vector類的簡單實現(xiàn)代碼,需要的朋友可以參考下
    2023-08-08
  • C語言實現(xiàn)簡易三子棋

    C語言實現(xiàn)簡易三子棋

    這篇文章主要為大家詳細介紹了C語言實現(xiàn)簡易三子棋，文中示例代碼介紹的非常詳細，具有一定的參考價值，感興趣的小伙伴們可以參考一下
    2021-07-07
  • C語言實現(xiàn)停車管理系統(tǒng)

    C語言實現(xiàn)停車管理系統(tǒng)

    這篇文章主要為大家詳細介紹了C語言實現(xiàn)停車管理系統(tǒng)，文中示例代碼介紹的非常詳細，具有一定的參考價值，感興趣的小伙伴們可以參考一下
    2022-03-03
  • C++利用代理模式實現(xiàn)遠程代理,虛擬代理和保護代理

    C++利用代理模式實現(xiàn)遠程代理,虛擬代理和保護代理

    今天給大家簡單介紹代理模式，一個很簡單的設計模式，旨在不改變原對象的情況下通過代理對象來控制對原對象的訪問。代理模式根據(jù)具體情況還可以分為遠程代理、虛擬代理、保護代理等，下面來介紹一下
    2023-04-04
  • 使用C語言解決字符串匹配問題的方法

    使用C語言解決字符串匹配問題的方法

    這篇文章主要介紹了使用C語言解決字符串匹配問題的方法,包括一道實例練習題,需要的朋友可以參考下
    2015-08-08
  • C++實現(xiàn)的大數(shù)相乘算法示例

    C++實現(xiàn)的大數(shù)相乘算法示例

    這篇文章主要介紹了C++實現(xiàn)的大數(shù)相乘算法,結合實例形式分析了C++大數(shù)相乘的概念、原理及代碼實現(xiàn)技巧,需要的朋友可以參考下
    2017-08-08

最新評論