c++类golang 隐士继承的实现

#include <string.h>
#include <algorithm>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#include <thread>
#include <atomic>
#include <functional>
#include <typeinfo>
#include <pthread.h>

using namespace std;

#define HAS_MEMBER(member) \
template<typename T, typename ... Args> \
struct has_member_##member {            \
 private:                      \
    template<typename U>                         \
    static auto Check(int)-> decltype(declval<U>().member(declval<Args>()...), true_type()); \
    template<typename U>                           \
    static false_type Check(...);        \
 public:                          \
    constexpr static bool value = is_same<true_type, decltype(Check<T>(0))>::value;          \
};

HAS_MEMBER(run);

class crazyDog {
public:
    [[noreturn]] void spark() {
        while (true) {
            cout << "汪汪" << endl;
            std::this_thread::yield();
        }
    }
};

class car {
public:
    [[noreturn]] void run() {
        while (true) {
            cout << "呜呜呜" << endl;
            std::this_thread::yield();
        }
    }
};

template<typename R, typename Obj, typename ...Args>
auto getRunCallBack(shared_ptr<Obj> obj, R(Obj::*fun)(Args&&...), Args&& ... args)
-> typename conditional<
        is_same<
                true_type ,
                typename conditional<has_member_run<Obj, Args...>::value, true_type, false_type>::type
        >::value,
        function<R(Args...)>,
        void
>::type {
    return [other=obj, f = fun](Args&& ... args1) {
        return ((*other).*f)(forward<Args>(args1)...);
    };
}

auto getObj() {
    //shared_ptr<crazyDog> sc = make_shared<crazyDog>();
    shared_ptr<car> sc = make_shared<car>();
    //void(car::*p)() = &car::run;
    return getRunCallBack(sc, &car::run);
}



int main() {
    auto runCallback = getObj();
    runCallback();
}