C++, cast un vecteur <type_spécifique> en vecteur <boost :: variant>

Question

J'ai une signature de fonction, qui prend un vector<specific_type> comme argument et appelle une autre fonction qui a vector<boost::variant<specific_type, ...>> comme argument. Un simple transfert de l'argument ne fonctionne pas. J'ai trouvé que le remballage était la seule solution, mais ce n'est probablement pas la solution la plus performante. Est-ce qu'un simple casting est possible?

exemple minimal:

#include "boost/variant.hpp" 

#include <string> 
#include <vector> 

typedef boost::variant<int, std::string> test_t; 

void inner(std::vector<test_t> a) {} 

void outer(std::vector<int> a) { 
    // the following does not work: 
    //inner(a); 
    //inner((std::vector<test_t>) a); 
    //inner(const_cast<std::vector<test_t>>(a)); 
    //inner(reinterpret_cast<std::vector<test_t>>(a)); 
    //inner(static_cast<std::vector<test_t>>(a)); 
    //inner(dynamic_cast<std::vector<test_t>>(a)); 

    // only "valid" solution 
    std::vector<test_t> b; 
    for (const int i : a) { 
     b.push_back(i); 
    } 
    inner(b); 
} 

int main() 
{ 
    std::vector<int> a = { 1, 4, 2 }; 
    outer(a); 
} 

Answer 1

est un simple casting en quelque sorte possible?

Nope. Il n'y a pas de telle distribution.

cela est probablement pas la solution la plus performante

correcte, nous pouvons faire un peu mieux en utilisant le vector range constructor:

template< class InputIt > 
vector(InputIt first, InputIt last, 
     const Allocator& alloc = Allocator()); 

que nous utiliserions comme:

void outer(std::vector<int> const& a) { 
    inner({a.begin(), a.end()}); 
}