What is a safe way to increase int in expanding a variational pattern?

Question

I am trying to implement a C ++ 11 wrapper around an SQL library written in C. The C library has separate functions for retrieving different types of data from an SQL statement that requires a column index. A simple approach is prototyped below, but has a critical drawback: it relies on the order of the arguments, which is unsafe (it may also have compiler errors, did not check it).

Question: What is a platform-independent way to safely increase a variable in expanding a variational pattern?

template< typename... ColumnTypes > void SQLStatement::execute( std::function< void( ColumnTypes... ) > rowCallback ){ while( this->nextRow() ){ int column = 0; rowCallback( this->getColumn< ColumnTypes >( column++ )... ); // unreliable increment ^ } } template< typename T > T SQLStatement::getColumn( const int columnIdx ){} template<> inline int SQLStatement::getColumn< int >( const int columnIdx ){ return sql_library_column_int( this->nativeHandle, columnIdx ); } // Other getColumn specializations here... 

Answer 1

While the mfontanini solution works, and that’s good because it does the calculation of the index of the incremental column at compile time, I find it useful to indicate that there is also a direct answer to the question of how to increase int in the extension of the variational package, (Unfortunately It does not work on GCC due to an error, see Disclaimer at the end.)

The answer is based on the fact that, although the argument estimates in the function call are not affected, the argument estimates in the list initialization are not:

(§8.5.4 / 4) In a list of initializers, linked to initialization, initializer offers, including all that result from decomposing packages (14.5.3), are evaluated in the order in which they appear. That is, each calculation of the values ​​and the side effect associated with the given initializer clause are sequenced before each calculation of the value and the side effect associated with any initializer clause that follows it in the comma-separated list of initializers.
[Note. This ranking ordering is performed independently of the initialization semantics; for example, it is used when elements of an initializer list are interpreted as arguments to a constructor call, although there is usually no sequence restriction on call arguments. - final note]

Therefore, if you convert a function call to something based on a list of parentheses, you get the desired effect:

 rowCallback(std::tuple<ColumnTypes...> { getColumn<ColumnTypes>(column++)... }); 

This initializes a std::tuple using list initialization (note the curly braces { ... } ), so the side effect of column++ will be executed in order from left to right.

If written as above, this means that you need to modify rowCallback() so that it accepts std::tuple instead of the argument list. If you don't like this, you can create a separate call_on_tuple(fun,tup) template function that calls any fun function for the arguments that result from the tuple tup . I somehow described how to do it here , or if you like, you can use rlxutil::call_on_tuple from my GitHub repository .

Your execute function is as follows:

 template <typename... ColumnTypes> void execute(function<void(ColumnTypes...)> rowCallback) { using std::tuple; using rlxutil::call_on_tuple; int column = 0; call_on_tuple(rowCallback, tuple<ColumnTypes...> { getColumn<ColumnTypes>(column++)... }); } 

Warning. This does not work with GCC. I believe this is due to the error message: http://gcc.gnu.org/bugzilla/show_bug.cgi?id=51253 .

Answer 2

It seems to work. You just need to adapt a couple of things:

 #include <functional> #include <iostream> #include <cstddef> void foo(int a, float b, int c) { std::cout << a << ", " << b << ", " << c << std::endl; } template<typename T> T getColumn(int index) { return T(index); } template<size_t... indexes> struct index_tuple {}; template<size_t head, size_t... indexes> struct index_tuple<head, indexes...> { typedef typename index_tuple<head-1, head-1, indexes...>::type type; }; template<size_t... indexes> struct index_tuple<0, indexes...> { typedef index_tuple<indexes...> type; }; template<typename... Args> struct make_index_tuple { typedef typename index_tuple<sizeof...(Args)>::type type; }; template<typename... ColumnTypes, size_t... indexes> void execute(const std::function<void(ColumnTypes...)> &callback, index_tuple<indexes...>) { // this should be done for every row in your query result callback(getColumn<ColumnTypes>(indexes)...); } template<typename... ColumnTypes> void execute(const std::function<void(ColumnTypes...)> &callback) { execute( callback, typename make_index_tuple<ColumnTypes...>::type() ); } int main() { std::function<void(int, float, int)> fun(foo); execute(fun); } 

Demo is here . Note that the foo function is only used to show that indexes are correctly incremented, like return T(index); in getColumn .