template<typename T, typename = void>
struct HasField_abc : std::false_type { };
template<typename T>
struct HasField_abc<T, decltype(std::declval<T>().abc, void())> : std::true_type { };

template<typename T, typename  U = HasField_abc<T>::value>
void get(T& value);

// да, я понимю что частичная специализация не применима
template<typename T, std::true_type>
void get(T& value);
{
    // поле есть
    value.abc = c_api_do_stuff();

    c_api_get(value);
}

template<typename T, std::false_type>
void get(T& value);
{
    // поля нет
    c_api_get(value);
}

K>Есть C API работу с которым хочется обернуть т.к. для использования API надо выполнить некоторые рутинные вещи. Проблема в том, параметр в виде структуры передающиеся в функцию-обёртку могут иметь, а могут не иметь некоторых полей для заполнения, следовательно, нужно выбирать алгоритмы с разными рутинами. Я осилил создание шаблона HasField для проверки наличия поля в структуре честно сперев его на SO и не разобравщись как оно работает , но не понимаю как это использовать для выбора алгоритма.

void get(S1& s) { s.abc=c_api_s1_stuff(); c_api_get(s); }
void get(S2& s) { c_api_get(s); }

K>Есть C API работу с которым хочется обернуть т.к. для использования API надо выполнить некоторые рутинные вещи. Проблема в том, параметр в виде структуры передающиеся в функцию-обёртку могут иметь, а могут не иметь некоторых полей для заполнения, следовательно, нужно выбирать алгоритмы с разными рутинами. Я осилил создание шаблона HasField для проверки наличия поля в структуре честно сперев его на SO и не разобравщись как оно работает , но не понимаю как это использовать для выбора алгоритма.

K>template<typename T, typename = void>
K>struct HasField_abc : std::false_type { };
K>template<typename T>
K>struct HasField_abc<T, decltype(std::declval<T>().abc, void())> : std::true_type { };

K>template<typename T, typename  U = HasField_abc<T>::value>
K>void get(T& value);

K>// да, я понимю что частичная специализация не применима
K>template<typename T, std::true_type>
K>void get(T& value);
K>{
K>    // поле есть
K>    value.abc = c_api_do_stuff();

K>    c_api_get(value);
K>}

K>template<typename T, std::false_type>
K>void get(T& value);
K>{
K>    // поля нет
K>    c_api_get(value);
K>}
K>

template <typename T>
inline typename std::enable_if<HasField_abc<T>::value>::type
get(T& value)
{
...
}

template <typename T>
inline std::enable_if<!HasField_abc<T>::value>::type
get(T& value)
{
}

K>Есть C API работу с которым хочется обернуть т.к. для использования API надо выполнить некоторые рутинные вещи. Проблема в том, параметр в виде структуры передающиеся в функцию-обёртку могут иметь, а могут не иметь некоторых полей для заполнения, следовательно, нужно выбирать алгоритмы с разными рутинами. Я осилил создание шаблона HasField для проверки наличия поля в структуре честно сперев его на SO и не разобравщись как оно работает , но не понимаю как это использовать для выбора алгоритма.

template <typename T, typename = size_t>
struct HasField_abc : std::false_type { };
 
template <typename T>
struct HasField_abc<T, decltype(sizeof(std::declval<T>().abc))> : std::true_type { };
 
template <typename T>
std::enable_if_t<HasField_abc<T>::value> get(T&)
{
    std::cout << "Has abc" << std::endl;
    // . . .
}
 
template <typename T>
std::enable_if_t<!HasField_abc<T>::value> get(T&)
{
    std::cout << "Has no abc" << std::endl;
    // . . .
}

template<typename T>
void get(T& value, std::true_type);
{
    // поле есть
    value.abc = c_api_do_stuff();

    c_api_get(value);
}

template<typename T>
void get(T& value, std::false_type);
{
    // поля нет
    c_api_get(value);
}

template<typename T>
void get(T& value)
{
    get(value, HasField_abc<T>{});
}

#include <stdio.h>

#define MAYSET(name) \
        template<class T> class Has_##name { \
            struct A { int name; }; \
            struct B : T,A {}; \
            template<typename C,C> struct D; \
            template<class C> static double test(D<int A::*,&C::name>*); \
            template<class C> static char test(...); \
    public: \
            enum { value = sizeof(test<B>(0))==sizeof(char) }; \
    }; \
    template<class T,class V> void mayset_##name(T *t,V v,char(*)[!Has_##name<T>::value]=0) {} \
    template<class T,class V> void mayset_##name(T *t,V v,char(*)[Has_##name<T>::value]=0) { \
        t->name=v; \
        printf("set "#name"=%d\n",(int)v); /* для проверки */ \
    }

MAYSET(x)

struct A { int x; } a[1];
struct B { int y; } b[1];

int main(int argc,char**argv) {
    mayset_x(a,10);
    mayset_x(b,20);
    return 0;
}

Для не очень свежего gcc, возможно, придется использовать std::enable_if вместо std::enable_if_t, ну или определить собственный аналог для компактности кода.

template <bool cond, typename type = void>
using enable_if_t = typename std::enable_if<cond, type>::type;