Question

跟进我最近提出的一个问题，可能会有一些不必要的东西，但是示例很小，我想做什么（当然如果你能想到其他很酷的方法，请分享你的思考），是允许用户使用特定类型激活非虚拟非界面关联子方法（请，让我们专注于如何而不是为什么:)。

我的上一个错误涉及会员功能签名，而不是实际的选择，我无法确定如何允许完美转发，我已经尝试了当前的解决方案，它永远不会工作（复制），而我＆＃39 ; ve也尝试转移Args_t＆amp;＆amp;对于如何正确转移成员函数的任何建议？我怀疑激活功能的防御是错误的......

我添加了一个演示编译错误的代码，您也可以将激活的Args_t输入参数更改为Args_t＆amp;＆amp;然后转发（args）......看第二个......

感谢。

struct Type {
    enum Value {
        One,
        Two
    };
};

struct A {};
template<typename Type_t, typename R, typename... Args_t>
auto activate(R (Type_t::* f)(Args_t...), A& parent, Args_t... args) -> R // args&& won't comppile either..
{ return (static_cast<Type_t&>(parent).*f)(args...); }

template<typename Type_t, typename R, typename... Args_t>
auto activate(R (Type_t::* f)(Args_t...) const, A const& parent, Args_t... args) -> R
{ return (static_cast<Type_t const&>(parent).*f)(args...); }

struct NonCopyable { public: NonCopyable() {} private: NonCopyable(NonCopyable const& other) {} };
struct B : public A { NonCopyable& foo(NonCopyable& other, bool test) { return other; } };
struct C : public A { NonCopyable& foo(NonCopyable& other, bool test) { return other; } }; // does something else obviously...

#define FuncSelect0(type, parent, func) \
        type == Type::One? activate<B>(&B::func, parent) :  \
            activate<C>(&C::func, parent)

#define FuncSelect1(type, parent, func, arg1) \
        type == Type::One? activate<B>(&B::func, parent, arg1) :  \
            activate<C>(&C::func, parent, arg1)

#define FuncSelect2(type, parent, func, arg1, arg2) \
        type == Type::One? activate<B>(&B::func, parent, arg1, arg2) :  \
            activate<C>(&C::func, parent, arg1, arg2)

#define GET_FS(_1,_2, _3, _4, _5, NAME,...) NAME
#define FuncSelect(...) (GET_FS(__VA_ARGS__, FuncSelect2, FuncSelect1, FuncSelect0)(__VA_ARGS__))

int main() {
        NonCopyable n;
        bool t;
        A* a = new B;
        NonCopyable& c = FuncSelect(Type::One, *a, foo, n, t);
        delete a;
        return 0;
}

Answer 1

不太确定，但这是你在找什么？

更新：有了这些重载，它应该是非常通用的。

#include <iostream>
#include <utility>

struct X {};

struct A: X {
  int f(int a, int b) { return a + b; }
};

struct B: X {
  int f(int a, int b) const { return a * b; }
};

template <typename D, typename B>
const D& forward_cast(const B& b) { return (const D&)b; }
template <typename D, typename B> 
D& forward_cast(B& b) { return (D&)b; }
template <typename D, typename B>
const D&& forward_cast(const B&& b) { return (const D&&)b; }
template <typename D, typename B> 
D&& forward_cast(B&& b) { return (D&&)b; }

// I see no need to use the trailing return type syntax
template <typename T, typename TT, typename R, typename... Args, typename... Argss> inline
R activate(R (T::*pfn)(Args...), TT&& obj, Argss&&... args) {
  return (forward_cast<T>(std::forward<TT>(obj)).*pfn)(std::forward<Argss>(args)...);
}

template <typename T, typename TT, typename R, typename... Args, typename... Argss> inline
R activate(R (T::*pfn)(Args...) const, TT&& obj, Argss&&... args) {
  return (forward_cast<T>(std::forward<TT>(obj)).*pfn)(std::forward<Argss>(args)...);
}

int main() {
  A a;
  B b;
  X* p = &a;
  std::cout << activate(&A::f, *p, 1, 2) << '\n';
  p = &b;
  std::cout << activate(&B::f, *p, 1, 2) << '\n';
}

正确的成员函数

1 个答案: