C++20 访问者模式：std::variant, std::visit, if conexpr,奇异递归模板

已于 2022-12-13 10:27:39 修改
阅读量375 收藏
点赞数
文章标签： c++ c++20
于 2022-12-12 18:47:37 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wyg_031113/article/details/128291566
版权

 访问者模式原始版

#include <iostream>
#include "common/log.h"
#include <limits>
#include <vector>
#include <span>
#include <array>
#include <type_traits>
#include <cmath>
#include <memory>
using namespace AdsonLib;

//访问者模式：Element的种类固定，但是操作Element的方法经常变
//如果在Element中增加操作方法，需要经常修改Element,为此把操作
//方法封装到Visitor中，扩展Visitor方便。
struct Element;
struct ElementA;
struct ElementB;

struct Visitor {
    virtual void VisitElementA(ElementA &a) = 0;
    virtual void VisitElementB(ElementB &b) = 0;
    virtual ~Visitor(){}
};

struct Element {
    virtual void accept(Visitor &vis) = 0;
    virtual ~Element(){}
    int val = 1;
};
struct ElementA : public Element{
    virtual void accept(Visitor &vis) override {
        vis.VisitElementA(*this);
    }
};
struct ElementB  : public Element{
    virtual void accept(Visitor &vis) override {
        vis.VisitElementB(*this);
    }
};

struct VisitorA : public Visitor {
    int sum = 1;
    virtual void VisitElementA(ElementA &a) override {
        LOG(INFO) << "VisitorA vis ElementA: " << a.val;
        sum += a.val;
    }
    virtual void VisitElementB(ElementB &b) override {
        LOG(INFO) << "VisitorA vis ElementB: " << b.val;
        sum *=b.val;
    }
    int total() {
        return sum;
    }
};
struct VisitorB : public Visitor {
    int mul = 1;
    virtual void VisitElementA(ElementA &a) override {
        LOG(INFO) << "VisitorA vis ElementA: " << a.val;
        mul *= a.val;
    }
    virtual void VisitElementB(ElementB &b) override {
        LOG(INFO) << "VisitorA vis ElementB: " << b.val;
        mul += b.val;
    }
    int multi() {
        return mul;
    }
};

struct ObjectStructure{
    ObjectStructure(){
        ElementA a1;
        a1.val = 1;
        objs.push_back(std::make_shared<ElementA>(a1));
        a1.val = 2;
        objs.push_back(std::make_shared<ElementA>(a1));
        ElementB b1;
        b1.val = 3;
        objs.push_back(std::make_shared<ElementB>(b1));
        b1.val = 4;
        objs.push_back(std::make_shared<ElementB>(b1));
    }
    void calc(Visitor &vis){
        for(auto && e : objs) {
            e->accept(vis);
        }
    }
    std::vector<std::shared_ptr<Element>> objs;
};

void common_test(){
    ObjectStructure os;
    VisitorA VA;
    VisitorB VB;
    os.calc(VA);
    LOG(INFO) << "visit by VA: " << VA.total();
    os.calc(VB);
    LOG(INFO) << "visit by VB: " << VB.multi();
}
int main(int argc, char *argv[]) {
   common_test();
}

奇异模板递归，把dispatch放到父类

template<typename T>
struct Base{};

//子类传递到父类中了，父类就能用子类类型了，这就是奇异模板递归
struct Der:public Base<Der>{}; 
#include <iostream>
#include "common/log.h"
#include <limits>
#include <vector>
#include <span>
#include <array>
#include <type_traits>
#include <cmath>
#include <memory>
using namespace AdsonLib;

//访问者模式：Element的种类固定，但是操作Element的方法经常变
//如果在Element中增加操作方法，需要经常修改Element,为此把操作
//方法封装到Visitor中，扩展Visitor方便。
struct Element;
struct ElementA;
struct ElementB;

struct Visitor {
    virtual void Visit(ElementA &a) = 0;
    virtual void Visit(ElementB &b) = 0;
    virtual ~Visitor(){}
};

struct Element {
    virtual void accept(Visitor &vis)  = 0;
    virtual ~Element(){}
    int val = 1;
};
template<typename T>
struct AutoDispatchElement : public Element {
    virtual void accept(Visitor &vis) override {
        vis.Visit(static_cast<T&>(*this));
    }
};

struct ElementA : public AutoDispatchElement<ElementA>{

};
struct ElementB  : public AutoDispatchElement<ElementB>{

};

struct VisitorA : public Visitor {
    int sum = 1;
    virtual void Visit(ElementA &a) override {
        LOG(INFO) << "VisitorA vis ElementA: " << a.val;
        sum += a.val;
    }
    virtual void Visit(ElementB &b) override {
        LOG(INFO) << "VisitorA vis ElementB: " << b.val;
        sum *=b.val;
    }
    int total() {
        return sum;
    }
};
struct VisitorB : public Visitor {
    int mul = 1;
    virtual void Visit(ElementA &a) override {
        LOG(INFO) << "VisitorA vis ElementA: " << a.val;
        mul *= a.val;
    }
    virtual void Visit(ElementB &b) override {
        LOG(INFO) << "VisitorA vis ElementB: " << b.val;
        mul += b.val;
    }
    int multi() {
        return mul;
    }
};

struct ObjectStructure{
    ObjectStructure(){
        ElementA a1;
        a1.val = 1;
        objs.push_back(std::make_shared<ElementA>(a1));
        a1.val = 2;
        objs.push_back(std::make_shared<ElementA>(a1));
        ElementB b1;
        b1.val = 3;
        objs.push_back(std::make_shared<ElementB>(b1));
        b1.val = 4;
        objs.push_back(std::make_shared<ElementB>(b1));
    }
    void calc(Visitor &vis){
        for(auto && e : objs) {
            e->accept(vis);
        }
    }
    std::vector<std::shared_ptr<Element>> objs;
};

void common_test(){
    ObjectStructure os;
    VisitorA VA;
    VisitorB VB;
    os.calc(VA);
    LOG(INFO) << "visit by VA: " << VA.total();
    os.calc(VB);
    LOG(INFO) << "visit by VB: " << VB.multi();
}
int main(int argc, char *argv[]) {
   common_test();
}

std::variant, std::visit, if constexpr版访问者

#include <iostream>
#include "common/log.h"
#include <limits>
#include <vector>
#include <span>
#include <array>
#include <type_traits>
#include <cmath>
#include <memory>
#include <variant>
using namespace AdsonLib;

struct ElementA{
};
struct ElementB{};

using Element = std::variant<ElementA, ElementB>;

struct Visitor{
    void operator()(ElementA &e) {
        LOG(INFO) << "visit a";
    }
    void operator()(ElementB &e) {
        LOG(INFO) << "visit b";
    }
};

void common_test(){
    std::vector<Element> vecs;
    vecs.push_back(ElementA());
    vecs.push_back(ElementB());
    vecs.push_back(ElementA());
    vecs.push_back(ElementB());
    for(auto && e: vecs){
        std::visit([](auto &&arg){
            LOG(INFO) << "arg";
        }, e);
    }

    LOG(INFO) << "------------";
    for(auto && e: vecs){
        std::visit([](auto &&arg){
            using T = std::decay_t<decltype(arg)>;
            if constexpr(std::is_same_v<T, ElementA>){
                LOG(INFO) << "ElementA";
            } else if constexpr(std::is_same_v<T, ElementB>){
                LOG(INFO) << "ElementB";
            }
            
        }, e);
    }
    LOG(INFO) << "------------";
    for(auto && e: vecs){
        std::visit(Visitor(), e);
    }
}
int main(int argc, char *argv[]) {
   common_test();
}

wyg_031113
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C++(17)：使用visit访问variant
风静如云的博客
11-27 866
POut类实现了一组重载的操作符，用于适配variant的实际类型，操作符可以根据不同的类型具有不同的行为，而且操作符没有与variant进行强绑定。可以看到需要在函数里对variant当前的类型进行检查，然后再根据值的类型做出具体的处理。而且这样做会绑定函数的参数类型，不利于函数的复用和扩展。如果我们可以实现一组重载函数，对不同的值类型完成不同的操作，那么程序会看起更简洁一些，并且可扩展性也会越好一些。可以看到doAdd的操作实际上改变了variant的对象值。
c++ 17 ' std::variant ' for c++ 11/14/17
01-27
MPark.VariantC++17 std::variant for C++11/14/17IntroductionMPark.Variant is an implementation of C++17 std::variant for C++11/14/17.Based on Continuously tested against libc++'s std::variant test ...
C++17之std::visit
热门推荐
janeqi1987的专栏
09-05 1万+
它们必须明确地为每种可能的类型提供函数调用操作符。然后，使用相应的重载来处理当前的备选项类型。 1. 使用对象函数方式访问 例1： #include <iostream> #include <variant> #include <string> struct MyVisitor { void operator()(double d) c...
Modern C++ std::visit从实践到原理
最新发布
老宅的虚拟空间
02-24 3012
std::visit从实践到原理
C++的动态类型：variant搭配visit与any
三水有余的博客
06-21 862
C++的动态类型：variant搭配visit与any 最近在写一个程序，里面用到一个数据结构，类似于字典，但一个实例里面，不同key对应的值的类型可能不一样。例如key为{年龄,性别}。这就要求我们在声明映射map时提供的模板参数能满足不同的数据类型，目前在不改变数据结构的情况下想到的解决方案有两种：使用variant或者any。 variant variant是C++17标准的新特性。 用法 variant<int, bool, string> var;// 声明一个可以接受int、bool
C++17完整导引-组件之std::variant
西门吹雪
05-26 1846
std::variant as a “safer union”
C++访问std::variant类型数据的几种方式
AlbertS Home of Technology
06-23 2939
`std::variant`（可变体） 是 `C++17` 中引入的一个新的类模板，提供了一种存储不同类型的值的方式，类似于之前版本中的 `union`（联合体），但可以存储非 `POD` 类型和类对象，能够在运行时进行类型检查和转换，但具有更多的功能和更高的类型安全性，今天来看一下存储在`std::variant`中的数据要怎么读取...
【C++ 17 新功能 std::visit 】深入解析 C++17 中的 std::visit：从原理到实践
探索C++编程的奥秘，分享深入的技术见解和实践，旨在激发读者创造力与解决问题的思维。
09-04 1383
C++17 是一个标准化的 C++ 语言版本，该版本引入了许多新特性，旨在简化编程任务，提高代码效率，并增强类型安全。从 `std::optional`（可选值）到 `std::filesystem`（文件系统操作），这些新特性都体现了现代 C++ 的设计理念：让复杂事物变得简单，而不是简单事物变得复杂。
std::variant 与 std::visit
hang_ning的博客
03-29 4465
std::variant 简介 std::variant 是c++17 引入的一个类型，其作用类似于C语言中的Union，但是比Union 的功能强大的多。 C语言中一个联合体Union 可以储存多种类型数据，但缺点有很多。比如： 1 没有可用的方法来判断Union中真实储存的类型，获取值时也是内存拷贝的结果，可能会存在问题。这就只能靠程序员人脑保证获取的值是有意义的。 2 只能储存基础数据类型，不能储存其他结构体 使用 std::variant 声明一个variant对象很容易，我们可以利用std::v
再谈c++中的variant和visit
fpcc的专栏
12-13 1879
对STL中的std::variant以及如何更好的使用std::visit进行访问进行举例分析说明
scelta ：（实验性）用于变体和可选类型的语法糖
01-30
为访问和递归访问提供类似于“模式匹配”的语法，这对variant和optional都适用。 提供基于直观占位符的递归variant和optional类型定义。 为optional类型（包括infix语法）提供诸如map和and_then类的单子运算。 ...
cpp-variant-type:简单易用且无效的模板变体类型
06-21
简单易用且无效的模板变体类型。 基于这个stackoverflow线程： : 简单用法 -> 允许编译器隐式检测类型 Variant intVariant = 5 ; Variant boolVariant ( true ); Variant stringVariant = std::string( " Hello ...
visit:一种快速但不符合标准的访问版本
05-10
它以支持非变体参数的方式进行了概括，它们被照原样转发给访问者。 所有变量参数都将作为其当前成员（如果有）转发。 它还处理从std::variant<>继承的类型作为变体。 例子： using V = std::variant; struct S...
VariantTalk:我的演讲“ std”的示例代码和幻灯片
05-09
我的演讲“ std :: variant和模式匹配的功能”的示例代码该存储库包含我的演示文稿“ std :: variant和模式匹配的功能”中显示的示例代码。 要构建，需要C ++ 17兼容的编译器。 我已经在以下编译器上对其进行了测试...
c++20 formatting（fmt）使用方法
02-02 4031
Format是一个编程语言非常重要的一环，c++的iomanip里的各种骚操作，在长字符串使用中是一个灾难。因此在c++20中提出了新库formatting，用类似于python的语法实现了fromat。但是目前实际项目中最多到c++17，有的项目甚至在用c++11。还好，fmt库就是formatting。fmt实现了几乎所有C++20的formatting 库，只有非常细微的差别。
（原创）用c++11打造好用的variant（更新）
weixin_34044273的博客
02-21 427
　　关于variant的实现参考我前面的博文，不过这第一个版本还不够完善，主要有这几个问题： 内部的缓冲区是原始的char[]，没有考虑内存对齐； 没有visit功能。 没有考虑赋值构造函数的问题，存在隐患。 　　这次将解决以上问题，还将进一步增强variant的功能。增加的功能有： 通过索引位置获取类型。 通过类型获取索引位置。 c++11的内存对齐 　　关于内存...
C++ variant (tcy)
tcy-阿春
01-14 3954
1.1.用途： 用于存储和操作不同类型对象,是一个类型安全的联合体(union). variant实例存储某一类型的数据,可指定重复的数据类型. 1.2.注意：variant的指定类型不能是引用类型,数组类型以及void类型, 1.3.说明：默认以首个指定类型进行初始化,首个类型必须支持默认构造函数 1.4.variant<> 操作 constructors //构造函数-创建variant对象(调用底层类型构造函数) = .
std::get std::variant
02-22
std::get是C++标准库中的一个函数模板，用于从std::variant对象中获取指定类型的值。std::variant是C++17引入的一个模板类，它可以存储多个不同类型的值，但在任意给定时间只能存储其中的一个值。 使用std::get函数时，需要提供一个std::variant对象和一个索引，该索引表示要获取的值在std::variant中的位置。如果std::variant中存储的是指定类型的值，则std::get函数返回该值的引用；否则，将抛出std::bad_variant_access异常。 以下是std::get和std::variant的示例代码： ```cpp #include <iostream> #include <variant> int main() { std::variant<int, double, std::string> var; var = 42; int intValue = std::get<int>(var); std::cout << "Int value: " << intValue << std::endl; var = 3.14; double doubleValue = std::get<double>(var); std::cout << "Double value: " << doubleValue << std::endl; var = "Hello"; try { int invalidValue = std::get<int>(var); std::cout << "Int value: " << invalidValue << std::endl; } catch (const std::bad_variant_access& e) { std::cout << "Exception caught: " << e.what() << std::endl; } return 0; } ``` 输出结果： ``` Int value: 42 Double value: 3.14 Exception caught: bad_variant_access ```

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值