我们应该在何时何地使用编译时宏连接？

Question

我看过这段我认为很棒的代码，因为它使我免于重新编写 getter 成员函数。

#define GET(n_,N_)                      \
        template<typename T>            \
        const T &get##N_() const        \
        {                               \
            return n_;                  \
        }                               \

据我所知，宏在编译时“编写”代码，因此在每个类中注入函数模板，并且因为它是一个模板，它可以补偿任何类型。 所以我最终得到了这个：

class Foo
{
   int m_a;
   GET(m_a,A)
};

然后我是这样使用的：

std::cout<< foo->getA<int>() <<std::endl;

我的问题是，我们应该在何时何地使用宏模板？ 有没有办法在调用 getA 成员函数时不指定类型？这是因为它在不同的命名空间中吗？

Answer 1

正如您所观察到的，我建议将宏和模板混合使用会导致您发现两者的弱点。函数的模板返回类型永远无法推断，因此您始终必须指定它。但幸运的是，有一个解决方案，它涉及将类型拼写到您的宏中：

#define GETTABLE_ATTR(type, name) \
private:
    type name_; \
public:
    type get_##name() const \
    { \
        return name_; \
    }

使用这个宏是否是一个好主意仍然是主观的 - 请记住，您只编写一次代码，并且最好以一种既能防止编写错误又能维护代码的方式编写代码最简单的。

Answer 2

正如 c++14 所说，仍然需要涉及 c 宏。

我有两个非常常用的宏与 MTP 结合来获得一个编译时间常数，它告诉我一个方法或属性是否存在于一个类中。这只需要函数的名称，该名称不能作为模板的参数给出。所以我在一个 c 宏中准备了它，它“写入”了我的模板，然后可以在 enable_if 子句中使用。

我个人不喜欢“自动吸气剂”中的你的想法，但这只是一个品味问题。

一如既往地在编程中：如果事情有帮助，不是“未定义的行为”，在代码中有很好的记录，并且不能以更严格的方式完成，允许使用 c 宏。对我来说，c 宏是对未集成语言特性的一种“自卫”。

另一个流行的例子是枚举关联文本以进行某种反射或序列化。

捕捉方法存在的例子：

#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;\ 
}

编辑：在此处添加一些示例代码如何使用此 c-macro 内容。

 #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;
}