c++ get std::vector<int> 来自 std::vector <std::tuple<int, float> &gt;

Question

i want to initialize a const std::vector<int> member variable in the initializer list of a constructor, given a std::vector<std::tuple<int, float>> constructor argument. The vector should contain all the first tuple items.

Is there a one-liner that extracts an std::vector<int> containing all the first tuple entries from an std::vector<std::tuple<int, float>> ?

Answer 1

With C++20 ranges:

struct X
{
    const std::vector<int> v;

    template <std::ranges::range R>
        requires std::convertible_to<std::ranges::range_value_t<R>, int>
    X(R r)
        : v{r.begin(), r.end()}
    {}

    X(const std::vector<std::tuple<int, float>>& vt)
        : X{vt | std::ranges::views::elements<0>}
    {}
};

With ranges-v3:

struct X
{
    const std::vector<int> v;

    X(const std::vector<std::tuple<int, float>>& vt)
        : v{vt | ranges::views::transform([] (auto t) {
                    return std::get<0>(t); })
               | ranges::to<std::vector>()}
    {}
};

And a Frankenstein's monster:

#include <ranges>
#include <range/v3/range/conversion.hpp>

struct X
{
    const std::vector<int> v;

    X(const std::vector<std::tuple<int, float>>& vt)
        : v{vt | std::ranges::views::elements<0>
               | ranges::to<std::vector>()}
    {}
};

Answer 2

Adding to @bolov's answer, let's talk about what you might have liked to do, but can't in a one-liner.

• There's the to<>() function from ranges-v3 from @bolov 's answer - it materializes a range into an actual container (a range is lazily-evaluated, and when you create it you don't actually iterate over the elements). There is no reason it shouldn't be in the standard library, if you ask me - maybe they'll add it 2023?

• You may be wondering - why do I need that to() ? Can't I just initialize a vector by a range? And the answer is - sort of, sometimes, maybe. Consider this program:

   #include <vector> #include <tuple> #include <ranges> void foo() { using pair_type = std::tuple<int, double>; std::vector<pair_type> tvec { {12, 3.4}, {56, 7.8}, { 90, 91.2} }; auto tv = std::ranges::transform_view( tvec, [](const pair_type& p) { return std::get<0>(p);} ); std::vector<std::tuple<int>> vec1 { tv.begin(), tv.end() }; std::vector<std::tuple<int>> vec2 { std::ranges::transform_view{ tvec, [](const pair_type& p) { return std::get<0>(p);} }.begin(), std::ranges::transform_view{ tvec, [](const pair_type& p) { return std::get<0>(p);} }.end() }; }

  The vec1 statement will compile just fine, but the vec2 statement will fail . This is surprising (to me anyway)!

• You may also be wondering why you even need to go through ranges at all. Why isn't there a...

   template <typename Container, typename UnaryOperation> auto transform(Container&& container, UnaryOperation op);

  which constructs the transformed container as its return value? That would allow you to write:

   std::vector<std::tuple<int>> vec3 { transform( tvec, [](const pair_type& p) { return std::get<0>(p); } ) }

  ... and have that work. Well, we just don't have functions in the standard libraries which take containers. It's either iterator pairs, which is the "classic" pre-C++20 standard library, or ranges. But there is nothing preventing you from writing that very function! It's not even that difficult, except perhaps with the care you need for the forwarding reference.

Answer 3

Not a one-liner to setup, but certainly one to use - you can write a function to do the conversion, and then the constructor can call that function when initializing the vector member, eg:

std::vector<int> convertVec(const std::vector<std::tuple<int, float>> &arg)
{
    std::vector<int> vec;
    vec.reserve(arg.size());
    std::transform(arg.begin(), arg.end(), std::back_inserter(vec),
        [](const std::tuple<int, float> &t){ return std::get<int>(t); }
    );
    return vec;
}

struct Test
{
    const std::vector<int> vec;

    Test(const std::vector<std::tuple<int, float>> &arg)
        : vec(convertVec(arg))
    {
    } 
};

Answer 4

Yes, there is a one-liner if you use this library in Github .

The code goes like this.

#include <iostream>
#include <tuple>
#include <vector>

#include <LazyExpression/LazyExpression.h>

using std::vector;
using std::tuple;
using std::ref;
using std::cout;

using LazyExpression::Expression;

int main()
{
    // Define test data
    vector<tuple<int, float>> vecTuple { {1,1.1}, {2,2.2}, {3, 3.3} };

    // Initialize int vector with the int part of the tuple (the one-liner :)
    vector<int> vecInt = Expression([](const tuple<int, float>& t) { return std::get<int>(t); }, ref(vecTuple))();

    // print the results
    for (int i : vecInt)
        cout << i << ' ';
    cout << "\n";
}
// Output:  1 2 3