How to use different member variable names in a template? - c++

Question

Edit: Completely rewrote the question to address suggestions in comments
In a large project that I participate in, there are a lot of classes that wrap messages, events, etc. They do not have a common ancestor and were (and still are) written by different people in different groups.
Most of these classes (or structs) have public members indicating error codes and descriptions. However, since they are used mostly within a single group and conventions are pretty loose, some of them name the members errStr, while others use errDesc.
For example:
struct X {
// stuff here...
int errCode;
std::string errStr;
};
struct Y {
// stuff here...
int errCode;
std::string errDesc;
};
I am trying to write a function template that will accept an object and print out the value of the whatever member variable that it has.
In pseudocode:
template<typename T>
bool logError(T const& x)
{
if (x.errCode == 0)
return true;
// if (T::errStr exists)
// log(x.errStr);
// else if (T::errDesc exists)
// log(x.errDesc);
return false;
}
What complicates matters is that the compiler that we use is VS2012, which is not fully C++11 compliant.
I have been messing with std::enable_if, std::is_same, etc for a while and so far the only result is an impressive collection of different compiler errors.
I was pointed to this by #T.C.
While it turned out to work quite well, it appears clunky and I was wondering if it can be simplified, or another solution offered, using the C++11 features that VS2012 supports.
Thank you!

Answer 1

In principle you can use SFINAE to detect the relevant member, but with C++03 (your compiler's standard) this yields complex, verbose code that's easy to break by maintenance – I give a complete example at the end below. The relevant techniques are covered in umpteen places on the web. E.g. I googled "c++ detect data member SFINAE" and hey presto, some GitHub code, and other examples. The ability to find information on the web, including basic googling, is very important to a developer. So, just try it.
An IMO more practical approach – because it's much simpler code that does not introduce maintenance problems and that goes in the direction you want the code to evolve – is to simply define overloads of an accessor function, one per class, like this:
string errorMessageOf( X const& o ) { return o.errStr; }
string errorMessageOf( Y const& o ) { return o.errDsc; }
Not everything needs to be a template.
Ordinary overloads are nice.
Your desired function template is then
template< class Type >
bool logError( Type const& x )
{
if (x.errCode == 0) return true; // A really dangerous thing to do
// Especially in Windows error code 0 a.k.a. NOERROR etc. is
// sometimes returned by GetLastError for a genuine failure. You
// should better treat it as "unknown cause".
clog << errorMessageOf( x ) << endl;
return not clog.fail(); // The return value is unspecified.
}
Example of instead using C++03 SFINAE, with code that works with Visual C++ 2012, and supporting an arbitrary number of names for the error message data member:
#include <iostream>
#include <stddef.h>
#include <string>
//----------------------------------------------- Machinery:
namespace reusable {
typedef ptrdiff_t Size;
template< Size n >
struct SizeCarrier_ { char nPlusOne[n + 1]; };
template< class Type, Type >
struct TypeFrom_;
} // namespace reusable
namespace my{
using std::string;
namespace impl {
using reusable::SizeCarrier_;
using reusable::TypeFrom_;
struct ErrorMsgMemberId { enum Enum{ noSuch, errStrName, errDescName }; };
template< class Type >
class ErrorMsgMemberId_
{
private:
template< class U >
static SizeCarrier_< ErrorMsgMemberId::errStrName >
memberId( TypeFrom_<string U::*, &U::errStr>* );
template< class U >
static SizeCarrier_<ErrorMsgMemberId::errDescName>
memberId( TypeFrom_<string U::*, &U::errDesc>* );
template< class U >
static SizeCarrier_<ErrorMsgMemberId::noSuch>
memberId( ... );
public:
static ErrorMsgMemberId::Enum const value = static_cast<ErrorMsgMemberId::Enum>(
sizeof( memberId< Type >( 0 ).nPlusOne ) - 1
);
};
template< ErrorMsgMemberId::Enum kind >
struct ErrorMsgFunc_;
template<>
struct ErrorMsgFunc_< ErrorMsgMemberId::errStrName >
{
template< class Type >
string operator()( Type const& o ) const
{ return o.errStr; }
};
template<>
struct ErrorMsgFunc_< ErrorMsgMemberId::errDescName >
{
template< class Type >
string operator()( Type const& o ) const
{ return o.errDesc; }
};
} // namespace impl
template< class Type >
string errorMsgOf( Type const& o )
{
static impl::ErrorMsgMemberId::Enum const member_id =
impl::ErrorMsgMemberId_< Type >::value;
return impl::ErrorMsgFunc_< member_id >()( o );
}
} // namespace my
//----------------------------------------------- Example usage:
struct X {
// stuff here...
int errCode;
std::string errStr;
};
struct Y {
// stuff here...
int errCode;
std::string errDesc;
};
struct Z {
// stuff here...
int errCode;
};
int main()
{
X const x = { 1, "X::errStr" };
Y const y = { 2, "Y::errDesc" };
Z const z = { 3 };
using namespace std;
cout << my::errorMsgOf( x ) << endl;
cout << my::errorMsgOf( y ) << endl;
//cout << my::errorMsgOf( z ) << endl; //! Fails with 'noSuch' in message.
}