Where and When should we use compile time macro concatenation? - c++

Question

I've seen this bit of code which I thought was great because it saved me from re-writing getter member functions.
#define GET(n_,N_) \
template<typename T> \
const T &get##N_() const \
{ \
return n_; \
} \
From what I know, Macros "write" code at compile time, therefore injecting the function template inside each class and because it's a template, it can compensate for any type.
So I ended up with this:
class Foo
{
int m_a;
GET(m_a,A)
};
then I used like this:
std::cout<< foo->getA<int>() <<std::endl;
My question is, WHEN and WHERE should we use macro templates?
And is there a way to NOT to specify the type when you are calling the getA member function? Is this because it's in a different namespace?

Answer 1

I'm going to suggest that mixing macros and templates will cause you to wind up with the weak points of both, as you've observed. The template return type of a function can never be inferred so you would always have to specify it. BUT luckily there's a solution, and it involves spelling the type into your macro:
#define GETTABLE_ATTR(type, name) \
private:
type name_; \
public:
type get_##name() const \
{ \
return name_; \
}
Whether using this macro is a good idea is still subjective - remember that you only write code once, and you're best served by writing it in the way that will both prevent mistakes as you write it AND will make maintaining the code easiest.

Answer 2

As also speaking for c++14 there are still needs for having c macros involved.
I have two really often used macros in combination with MTP to get a a compile time constant which tells me if a method or attribute is existing in a class. This simply needs the name of the function which can not be given as parameter to a template. So I prepared that inside a c macro which "writes" my template which then can be used inside enable_if clause.
I personally dislike your idea from "automated getters", but this is only a question of taste.
As always in programming: If the thing helps, is not "undefined behaviour", is well documented in the code and could NOT be done with a more strait forward way the use of c macros is allowed. For me c macros are a kind of "self-defence" for not integrated language features.
Another popular example is enumeration with associated text for some kind of reflection or for serialisation.
The example to catch the existence of a method:
#define DECLARE_HAS_METHOD_FULL_SIGNATURE(NAME) \
template<typename, typename T>\
struct has_method_full_signature_ ## NAME {\
static_assert(\
std::integral_constant<T, false>::value,\
"Second template parameter needs to be of function type.");\
};\
\
\
template<typename C, typename Ret, typename... Args>\
struct has_method_full_signature_ ## NAME <C, Ret(Args...)> {\
template<typename T>\
static constexpr auto check(T*)\
-> typename\
std::is_same<\
decltype( std::declval<T>(). NAME ( std::declval<Args>()... ) ),\
Ret \
>::type; \
\
template<typename>\
static constexpr std::false_type check(...);\
\
using type = decltype(check<C>(0)); \
static constexpr bool value = type::value;\
}
EDIT: add some example code how to use this c-macro stuff here.
#include <utility>
#include <iostream>
#include "component/mytypes_traits.h"
DECLARE_HAS_METHOD_PARMS_ONLY(funny);
DECLARE_HAS_METHOD_FULL_SIGNATURE(f1);
DECLARE_HAS_METHOD_FULL_SIGNATURE(f2);
DECLARE_HAS_METHOD_FULL_SIGNATURE(f3);
class A { public: void funny() {} };
class B { public: void dummy() {} };
class C
{
public:
int f1(int) { return 1;}
float f2(int,int) {return 2.0;}
int f3() { return 1;}
};
int main()
{
std::cout << has_method_parms_only_funny<A>::value << std::endl;
std::cout << has_method_parms_only_funny<B>::value << std::endl;
std::cout << "--" << std::endl;
std::cout << has_method_full_signature_f1< C, int()>::value << std::endl;
std::cout << has_method_full_signature_f1< C, int(int)>::value << std::endl;
std::cout << has_method_full_signature_f1< C, int(int,int)>::value << std::endl;
std::cout << "--" << std::endl;
std::cout << has_method_full_signature_f2< C, float()>::value << std::endl;
std::cout << has_method_full_signature_f2< C, float(int)>::value << std::endl;
std::cout << has_method_full_signature_f2< C, float(int,int)>::value << std::endl;
std::cout << "--" << std::endl;
std::cout << has_method_full_signature_f3< C, int()>::value << std::endl;
std::cout << has_method_full_signature_f3< C, int(int)>::value << std::endl;
std::cout << has_method_full_signature_f3< C, int(int,int)>::value << std::endl;
std::cout << "--" << std::endl;
}