Специализированная функция, если аргумент имеет переменную-член

Я бы использовал SFINAE для этого. Во-первых, давайте определим две функции, которые возвращают error строку для сообщения:

namespace detail
{
// for messages with "details" member:
template<typename MsgType>
std::string makeMsgString(const MsgType& msg, decltype(MsgType::details)*)
{
return "Error: " + msg.error + ", details: " + msg.details;
}

// for messages without "details" member:
template<typename MsgType>
std::string makeMsgString(const MsgType& msg, ...)
{
return "Error: " + msg.error + ", no details";
}
}

Теперь эти функции можно использовать так:

struct NonSpecificMsg { std::string error; };
struct SpecificMsg { std::string error, details; };

template<typename MsgType>
void reportErr(const MsgType& msg)
{
std::cout << detail::makeMsgString(msg, nullptr) << "\n";
}

int main()
{
reportErr(NonSpecificMsg { "some error" }); // 1
reportErr(SpecificMsg { "some other error", "some details" }); // 2
return 0;
}

Что здесь происходит?

Звоните 1): NonSpecificMsg не имеет details член, поэтому первая перегрузка не существует. поскольку MsgType::details не существует, decltype(MsgType::details)* не является допустимым типом. SFINAE игнорирует это определение, а не выдает ошибку во время компиляции.
Там только перегрузка 2), к которой нет доступа details член.

Звоните 2): SpecificMsg имеет detailsпоэтому обе перегрузки учитываются компилятором. Однако перегрузки переменной функции (вторая) всегда имеют более низкий приоритет, чем любая другая соответствующая перегрузка, поэтому выбирается первая.

Редактировать: это решение C ++ 11. К несчастью, decltype был введен в GCC 4.8.

Изменить 2: Оказывается, что decltype Можно использоваться с GCC 4.6 (он был представлен в версии 4.3). Версия 4.8.1 изменила семантику, но в случае с OP предыдущие версии будут работать — см. Страница состояния C ++ в GCC

Примечание. Это ответ C ++ 17, написанный до того, как OP определил их версию gcc / c ++. Я позволил это там, надеюсь, помочь другим.

Вы можете пометить типы сообщений и проверить их во время компиляции:

#include <iostream>
#include <type_traits>
#include <string>

struct HasErrorMember { std::string error = "error"; };
struct HasDetailsMember { std::string details = "details"; };

template<class MSG>
void reportErr(const MSG& msg)
{
if constexpr (std::is_base_of_v<HasErrorMember, MSG>)   std::cout << "ERROR: " << msg.error;
if constexpr (std::is_base_of_v<HasDetailsMember, MSG>) std::cout << ", details: " << msg.details;
std::cout << "\n";
}

struct MsgSimple : HasErrorMember
{};

struct MsgDetails : HasErrorMember, HasDetailsMember
{};

int main()
{
MsgSimple  ms;
MsgDetails md;
std::cout << "error only:\n";
reportErr(ms);
std::cout << "error + details:\n";
reportErr(md);
}

В соответствии с вашими потребностями этот тег может включать самих участников или может быть пустым, возлагая ответственность за обеспечение членства<-> соответствие тега разработчику.

живое демо

Только с C ++ 03 черты более многословны, чем с C ++ 11 (как std::is_detected), вы можете сделать что-то вроде:

#define DEFINE_HAS_SIGNATURE(traitsName, funcName, signature)               \
template <typename U>                                                   \
class traitsName                                                        \
{                                                                       \
private:                                                                \
template<typename T, T> struct helper;                              \
template<typename T>                                                \
static char check(helper<signature, funcName>*);                    \
template<typename T> static int check(...);                         \
public:                                                                 \
static                                                              \
const bool value = sizeof(check<U>(0)) == sizeof(char);             \
}

затем

// Would be in std in C++11
template <bool, typename T = void> struct enable_if
{
typedef T type;
};

template <typename T> struct enable_if<false, T>
{
};

а потом

DEFINE_HAS_SIGNATURE(has_details, &T::details, std::string (T::*));

template <typename MSG>
typename enable_if<!has_details<MSG>>::type
reportErr(const MSG& msg)
{
std::cout << "ERROR: " << msg.error << std::endl;
}

template <typename MSG>
typename enable_if<has_details<MSG>>::type
void reportErr(const MSG& msg)
{
std::cout << "ERROR: " << msg.error;
std::cout << ", details: " << msg.details << std::endl;
}

демонстрация