C++ C++；变型通用转换器

在过去的三天里，我一直在尝试如何实现一种通用的方法来获取boost:：variant的值，但这相当困难

以下是我可以想出的解决方案，它根本不是通用的：

#include <iostream>
#include "boost\variant\variant.hpp"

using MyVariant = boost::variant<int, std::string>;

class VariantConverter : public boost::static_visitor<>
{
private:
    mutable int _int;
    mutable std::string _string;

    static VariantConverter apply(MyVariant& v) 
    {
        VariantConverter res;

        v.apply_visitor(res);

        return res; // copy will be elided, right?
    }

public:
    void operator()(int& i) const
    {
        _int = i;
    }

    void operator() (std::string& s) const
    {
        _string = s;
    }

    static int to_int(MyVariant v) 
    {
        return apply(v).from_int();
    }

    static std::string to_string(MyVariant v) 
    {
        return apply(v).from_string();
    }

    int from_int() 
    { 
        return _int; 
    };

    std::string from_string() 
    { 
        return _string; 
    };
};

int main()
{
    using namespace std;

    MyVariant v = 23;

    int i = VariantConverter::to_int(v);

    cout << i << endl;

    v = "Michael Jordan";

    std::string s = VariantConverter::to_string(v);

    cout << s.c_str() << endl;

    cin.get();

    return 0;
}

我在试图查找接受std:：string的运算符（）时遇到一个编译器错误

在我看来，apply_visitor正在尝试为MyVariant可以采用的每种类型调用运算符（）。是这样吗？如果是，为什么？我怎样才能避免这种行为

---

干杯

您可以通过告诉

converterpoint

如何处理

std:：string

来避免错误消息。您可能知道

i

不能是

std:：string

，但期望编译器知道这一点是不合理的（如果是真的，为什么要使用变体？）

apply\u visitor

将只调用正确的

操作符（）

方法，但它在运行时决定，编译器需要覆盖生成代码的所有可能性。

MyVariant iv=10；
MyVariant iv = 10;    
int i = boost::get<int>(iv);

int i=boost:：get（iv）；

variant在调用时不会“调用”接口的每个运算符（），但它必须能够。这就是重点。变量可以保存任何模板类型，因此如果要在其上定义操作，必须在某个位置指定该操作对每个类型的含义

ConverterToInt : basic_visitor<int> {
public:
    int operator() (int i) { return i; };
};

ConverterToInt cti;

MyVariant i = 10;

i.apply_visitor(cti);

MyVariant iv = 10;    
int i = boost::get<int>(iv);