Variadic Tuple Order changes after Unpacking depending on Datatypes

Question

The code should call back a function by extracting arguments from a string. However, the order changes as follows: (Visual Studio 2013 AND 2015! express)

"1 2 3 4"  int, double, string, int ->  3 2 4 1

"1 2 3 4"  int, double, float, int ->  4 3 2 1

Edit : It works properly in gcc and is a MS Visual C++ compiler bug - Tested for VS2013 and VS2015. Does anyone knows a work around ? (Maybe using some C++14 feature? )

Edit2: I solved it adding indices to the parameters and removed the tuple too http://cpp.sh/9jc5

Here the sample:

void one(int i, double d, string s, int ii)
{
    std::cout << "function one(" << i << ", " << d << ", " << s << ", " << ii << ");\n";
}

int main()
{
    RegisterRPC<int, double, string, int>("test1", one);
    DataSource* data = new DataSource("1 2 3 4");
    functionarray["test1"](data);
}

And the complete code:

#include <stdlib.h>
#include <functional>
#include <tuple>
#include <map>
#include <iostream> 
#include <istream>
#include <sstream>
#include <string>

// ------------- UTILITY---------------
template<int...> struct index_tuple{};

template<int I, typename IndexTuple, typename... Types>
struct make_indexes_impl;

template<int I, int... Indexes, typename T, typename ... Types>
struct make_indexes_impl<I, index_tuple<Indexes...>, T, Types...>
{
    typedef typename make_indexes_impl<I + 1, index_tuple<Indexes..., I>, Types...>::type type;
};

template<int I, int... Indexes>
struct make_indexes_impl<I, index_tuple<Indexes...> >
{
    typedef index_tuple<Indexes...> type;
};

template<typename ... Types>
struct make_indexes : make_indexes_impl<0, index_tuple<>, Types...>
{};

// ----------UNPACK TUPLE AND APPLY TO FUNCTION ---------

using namespace std;

template<class Ret, class... Args, int... Indexes >
Ret apply_helper(Ret(*pf)(Args...), index_tuple< Indexes... >, tuple<Args...>&& tup)
{
    return pf(forward<Args>(get<Indexes>(tup))...);
}

template<class Ret, class ... Args>
Ret apply(Ret(*pf)(Args...), const tuple<Args...>&  tup)
{
    return apply_helper(pf, typename make_indexes<Args...>::type(), tuple<Args...>(tup));
}

template<class Ret, class ... Args>
Ret apply(Ret(*pf)(Args...), tuple<Args...>&&  tup)
{
    return apply_helper(pf, typename make_indexes<Args...>::type(), forward<tuple<Args...>>(tup));
}
// --- make tuple ---

template <typename T> T read(std::istream& is)
{
    T t; is >> t; cout << t << endl; return t;
}

template <typename... Args>
std::tuple<Args...> parse(std::istream& is)
{
    return std::make_tuple(read<Args>(is)...);
}

template <typename... Args>
std::tuple<Args...> parse(const std::string& str)
{
    std::istringstream ips(str);
    return parse<Args...>(ips);
};

// ---- RPC stuff

class DataSource
{
    std::string data;
public:
    DataSource(std::string s) { data = s; };
    template<class...Ts> std::tuple<Ts...> get() {  return parse<Ts...>(data);  };
};

std::map<std::string, std::function<void(DataSource*)> > functionarray;

template<typename... Args, class F>
void RegisterRPC(std::string name, F f) {
    functionarray[name] = [f](DataSource* data){apply(f, data->get<Args...>()); };
}

// --------------------- TEST ------------------

void one(int i, double d, string s, int ii)
{
    std::cout << "function one(" << i << ", " << d << ", " << s << ", " << ii << ");\n";
}

int main()
{
    RegisterRPC<int, double, string, int>("test1", one);
    DataSource* data=new DataSource("1 2 3 4");
    functionarray["test1"](data);
    system("pause");
    return 0;
}

// --------------------- TEST ------------------

References used

How do I expand a tuple into variadic template function's arguments?

build tuple using variadic templates

How do you expect to distinguish between duplicate type arguments using `data->get()` ? — Andrey Nasonov, Oct 02 '15 at 19:23
@AndreyNasonov: Well, I hope the compiler sorts that out automatically.. — Marco Polo, Oct 02 '15 at 19:36
No, it cannot do it. What will result the call `data->get()`? — Andrey Nasonov, Oct 02 '15 at 19:39
@AndreyNasonov so to make it safe, the get(tup) helper needs to be used somehow ? — Marco Polo, Oct 02 '15 at 20:08
You can use http://en.cppreference.com/w/cpp/utility/integer_sequence instead of writing own types and `std::get` to access tuple element by index. — Andrey Nasonov, Oct 02 '15 at 20:28
A friend of me tested in VS2015 and still got the same problem. Has the bug not been solved yet ? — Marco Polo, Oct 02 '15 at 22:24
The link is dead. Is there a moved link or an archived version? — underscore_d, May 31 '20 at 20:28

score 2 · Answer 1 · answered Oct 02 '15 at 19:27

2

Change:

template <typename... Args>
std::tuple<Args...> parse(std::istream& is)
{
    return std::make_tuple(read<Args>(is)...);
}

into:

template <typename... Args>
std::tuple<Args...> parse(std::istream& is)
{
    return std::tuple<Args...>{ read<Args>(is)... };
}

Otherwise, the order in which function read is called is unspecified.

answered Oct 02 '15 at 19:27

Piotr Skotnicki

46,953
7
118
160

Thank you for the quick answer. The output of "one(int, double, string, int)" is still function one(3, 2, 4, 1) while the order in which read is called is correctly 1 2 3 4. – Marco Polo Oct 02 '15 at 19:34
@MarcoPolo it can't be – Piotr Skotnicki Oct 02 '15 at 19:40
1

@MarcoPolo I guess what you see is [this MSVC bug](https://connect.microsoft.com/VisualStudio/feedback/details/1075443/c-order-of-evaluation-of-expressions-in-a-braced-initializer-list-is-wrong-in-the-context-of-a-constructor-call) – Piotr Skotnicki Oct 02 '15 at 19:53
@ildjarn is nothing if not persistent! – Barry Oct 02 '15 at 19:54
@PiotrSkotnicki do you know how to get a workaround for that ? Maybe using C++14 ? I confirmed VS2015 has the same bug. – Marco Polo Oct 03 '15 at 06:21

Marco Polo · Answer 2 · 2015-10-03T13:55:40.370

Here the fixed version using indices - in case somebody is interested.

http://cpp.sh/7mgo

#include <tuple>
#include <iostream> 
#include <strstream>
#include <istream>
#include <sstream>
#include <string>
#include <vector>
#include <map>
#include <functional>

// ------------- UTILITY---------------
template<int...> struct index_tuple{};

template<int I, typename IndexTuple, typename... Types>
struct make_indexes_impl;

template<int I, int... Indexes, typename T, typename ... Types>
struct make_indexes_impl<I, index_tuple<Indexes...>, T, Types...>
{
    typedef typename make_indexes_impl<I + 1, index_tuple<Indexes..., I>, Types...>::type type;
};

template<int I, int... Indexes>
struct make_indexes_impl<I, index_tuple<Indexes...> >
{
    typedef index_tuple<Indexes...> type;
};

template<typename ... Types>
struct make_indexes : make_indexes_impl<0, index_tuple<>, Types...>{};

using namespace std;

// --- process single datatype ---

struct anyT
{
    anyT(int   e) { cout << " int" << endl; }
    anyT(float e) { cout << " float" << endl; }
    anyT(string e) { cout << " string" << endl; }
    anyT(double e) { cout << " double" << endl; }
};
template <typename T> T read_from(int index, std::vector<string> &list)
{
    std::istringstream is(list[index]);
    T t;  is >> t; cout << "index " << index << " val " << t; anyT a(t); return t;
}

// ---- RPC stuff ----

std::map<std::string, std::function<void(string*)> > functionarray;

template<typename... Args, class F, int... Is>
void RegisterRPC_index(std::string name, F f, index_tuple< Is... >) {
    functionarray[name] = [f](string* data)
    {
        const int n = sizeof...(Args);
        cout << n << " args\n";

        std::vector<string> list;
        std::istringstream ips(*data);

        for (int i = 0; i < n;i++)
        {
            string s; 
            ips >> s;
            list.push_back(s);
        }

        f(read_from<Args>(Is, list)...);
    };
}

template<typename... Args, class F>
void RegisterRPC(std::string name, F f) 
{
    RegisterRPC_index<Args...>(name,f,typename make_indexes<Args...>::type());
}
// --------------------- TEST ------------------

void one(int i, double d, string s, int ii)
{
    std::cout << "function one(" << i << ", " << d << ", " << s << ", " << ii << ");\n";
}

int main()
{
    RegisterRPC<int, double, string, int>("test1", one);
    string* data=new string("1 2.2 hello3 4");
    functionarray["test1"](data);
    return 0;
}

Variadic Tuple Order changes after Unpacking depending on Datatypes

2 Answers2