Valid for C++17.

What you want might get quite hard and I do not think there is a generic solution apart form using macros.

The first part is actually easy, you can use std::tie and simply return tuples.

auto listFields(Foo& foo) {
    return std::tie( foo.id, foo.name, foo.length); 
}

I am generally against using template functions and full specialization together. Overloads can do most of the job already. Is there a reason for using them?

Thanks to auto return type and class template argument deduction, there is no need to write any types. I do not think there is a better solution, in C++ it is not possible to return multiple object through the return statement.

Now, about calling those library functions.

If doForVars is the only one you need to call, then the cleanest solution is probably based on this answer:

template<typename T>
void call_doForVars(T& obj){
    std::apply([](auto &&... args) { doForVars(args...); }, listFields(obj));
}

int main(){
    Foo foo{1,"Quimby",176.5};
    call_doForVars(foo);
}

On the other hand, if you have more library functions, you hit a snag that it is AFAIK impossible to pass template function around and you need to pass it into an inner function because the arguments are one of the few places a parameter pack can be expanded. The lambda kinda bypasses this because it can create a function inside an expression.

My best advice so far in this case is to just wrap the previous solution into a macro. You only need to do it once for each library function. (You can do it for listFields too, it will be cleaner).

EDIT

I did find a solution for the generic case after all:

template<typename...Args>
using fnc_t = void(*)(Args&... args);

auto listFields(Foo& foo) {
    return std::tie( foo.id, foo.name, foo.length); 
}
template<typename...Args>
void call(fnc_t<Args...> f, const std::tuple<Args&...>& t){
    std::apply(f, t);
}

int main(){
    Foo foo{1,"Quimby",176.5};
    call(doForVars, listFields(foo));
}

Was not that hard in the end, it only works with functions for now though. One downside is that you have to call listFields in every call, which might be handy if your tuples come from other sources too. But if they don't, we can go one step further and get:

template<typename T>
struct helper{
using fnc_t = void;
};
template<typename...Args>
struct helper<std::tuple<Args&...>>{
using fnc_t = void(*)(Args&... args);
};
template<typename T>
using fnc_t2 = typename helper<decltype(listFields(std::declval<T&>()))>::fnc_t;

template<typename T>
void call2(fnc_t2<T> f, T& obj){
    std::apply(f, listFields(obj));
}
int main(){
    Foo foo{1,"Quimby",176.5};
    call2(doForVars, foo);
}

It's more mouthful, but call2 can be hidden anyway and call2(doForVars, foo); is really nice result. :)

Here is a live demo.

You can't return multiple types from a function, even if it's a variadic template. However, you can return a tuple containing all the types that are members of a particular class. Also there seems to be no reason to write a template specialization for each of your Foo, Bar, etc. Instead, you can just add a function to the overload set for every type:

std::tuple<int, std::string, double> listFields(Foo& foo)
{
    return {foo.id, foo.name, foo.length};
}

std::tuple<int, double, double> listFields(Bar& bar)
{
    return {bar.id, bar.someProperty, bar.someOther};
}

Now since doForVars is a variadic template, you need to unpack the tuple returned form listFields, for which you can use std::apply like this:

template<typename T>
void doSomething(T& t) {
    // ...
    std::apply([](auto &&... args) { doForVars(args...); }, listFields(t)); 
}

Here's a demo

As a workaround, you can use std::tuples, as follows

#include <iostream>
#include <string>
#include <tuple>
using namespace std::string_literals;

struct A{
    int int_a;
    double double_a;

    std::tuple<int&, double&> tuplize(){
        return {int_a, double_a};
    }

};

struct B{
    std::string str_b;
    bool bool_b;

    std::tuple<std::string&, bool&> tuplize(){
        return {str_b, bool_b};
    }
};

template <class ... Args>
void do_for_vars(Args& ... args){
    ((std::cout << args << ", "), ...);
    std::cout << "\n";
}
template <class ... Args>
void helper(std::tuple<Args...> t){
    std::apply(do_for_vars<Args...>, t);
}

int main(){
    A a{1, 1.4};
    B b{"str"s, true};
    helper(a.tuplize());
    helper(b.tuplize());

}