C++ 具有可变模板参数的Boost变量访问者

在我的一个项目中，我正在积极使用

boost:：variant

，我偶然发现了一个我自己无法解决的问题。我有一个

boost:：variant

，它可能包含原子数据类型和这些原子数据类型的STL容器

现在，我想计算前面定义的

boost:：variant

类型的实例的大小。基本上只有两种可能的功能。原子数据类型的类型仅为1，而STL容器的大小定义为其中包含的元素数

由于只有2个原子数据类型，我实现了以下代码：

#include <boost/variant.hpp>
#include <string>
#include <iostream>
#include <vector>

typedef boost::variant<int, double, std::vector<int>, std::vector<double> > TVariant;

struct sizeVisitor : boost::static_visitor<size_t> {
   size_t operator()(int&) {
    return 1;
    }
   size_t operator()(double&) {
    return 1;
    }

   size_t operator()(std::vector<int>& c) {
    return c.size();
    }

   size_t operator()(std::vector<double>& c) {
    return c.size();
    }
} ;


int main(int argc, char **args) {
    sizeVisitor visitor;
    TVariant var=5;
    std::cout << boost::apply_visitor(visitor, var) << std::endl;
    std::vector<int> vector;
    vector.push_back(6);
    vector.push_back(2);
    var=vector;
    std::cout << boost::apply_visitor(visitor, var) << std::endl;
}

#包括
#包括
#包括
#包括
typedef boost:：variant TVariant；
struct sizeVisitor:boost:：static\u visitor{
size\u t运算符（）（int&）{
返回1；
}
size\u t运算符（）（双精度&）{
返回1；
}
size\u t运算符（）（std:：vector&c）{
返回c.size（）；
}
size\u t运算符（）（std:：vector&c）{
返回c.size（）；
}
} ;
int main（int argc，char**args）{
sizeVisitor访客；
变量var=5；
std:：cout只需为
操作符（）使用两个函数模板即可：

struct sizeVisitor
：boost:：static\u访问者
{
模板
size\u t运算符（）（t常量&）{
返回1；
}
模板
size_t运算符（）（std:：vector const&v）{
返回v.size（）；
}    
};

模板偏序规则将确保调用正确的模板。
哇。这是一个非常明显的解决方案。非常感谢。我想知道对于更一般的问题是否也有解决方案，我必须将给定的
boost:：variant
的类型集划分为两个子集，例如数字和非数字。我想TD编写一个访问者，为这个属性生成一个布尔值。“Frand Simon使用Sfaya-一个过载使一个被禁用，这取决于某种类型的特性。我不知道这个概念。似乎我必须学习更多关于C++的知识。非常感谢这些深刻的见解。我将看一看。”弗兰克西蒙欣赏你即将要掉的兔子洞。into:）@frank而不是sfinae，将标记从主
（）
分派到helper方法。更少混淆，更容易读取错误。
{return helper（std:：is_numeric{}，t）；}
，其中
helper（true_type，t）
获取数字，而
helper（false_type，t）
获取其余部分。
#include <boost/variant.hpp>
#include <string>
#include <iostream>
#include <vector>

typedef boost::variant<int, double, std::vector<int>, std::vector<double> > TVariant;

struct sizeVisitor : boost::static_visitor<size_t> {
   size_t operator()(boost::variant<int,double>&) {
    return 1;
    }

   size_t operator()(boost::variant<std::vector<int>,std::vector<double>>& c) {
    return c.size();
    }

} ;


int main(int argc, char **args) {
    sizeVisitor visitor;
    TVariant var=5;
    std::cout << boost::apply_visitor(visitor, var) << std::endl;
    std::vector<int> vector;
    vector.push_back(6);
    vector.push_back(2);
    var=vector;
    std::cout << boost::apply_visitor(visitor, var) << std::endl;
}

struct sizeVisitor 
    : boost::static_visitor<size_t>
{
    template <class T>
    size_t operator()(T const&) {
        return 1;
    }

    template <class T>
    size_t operator()(std::vector<T> const& v) {
        return v.size();
    }    
};