Question

我试图将类方法视为通用函数指针。从my earlier question, related to that specifically,的回答中我了解到std::function和boost::function提供了我需要的一般功能，以便创建指向各种类的指针。方法;除非我误解了。

现在我需要知道是否有任何方法可以自行复制此功能？我不能使用我的C ++ 11编译器，坚持使用C ++ 03。我也无法安装 Boost ，因为我的教师不会安装Boost来评估我的作业。

我很想回头采取不同的方法，但我在兔子洞的距离太远了。请帮帮我们：（

Answer 1

您应该能够使用TR1的功能并绑定标题：

#include <tr1/functional>
#include <string>
#include <sstream>

struct AddX {
    template <typename> struct  result { typedef std::string type; };

    std::string operator()(int a, int b) const { 
        std::ostringstream oss;
        oss << (a + b);
        return oss.str();
    }
};

int main() {
    using namespace std::tr1;

    function<std::string(int)> foo = bind(AddX(), 999, placeholders::_1);

    return foo(1).length();
}

Answer 2

您可以使用如下声明创建一个指向成员函数的预C ++ 11函数指针：

ReturnType (ClassType::*func_ptr)() = &ClassType::function;

并使用带有(instance.*func_ptr)()的类的实例来调用它。 E.g。

struct Foo {
    bool memberFunc() { return true; }
};

int main() {
    typedef bool (Foo::*member_func_t)();      // Typedef member func pointer type.
    member_func_t func_ptr = &Foo::memberFunc; // Declare function pointer.
    Foo foo;                                   // Create foo object.
    (foo.*func_ptr)();                         // Call member func using instance.
}

如果您只需要创建指向成员函数的指针，有一种方法可以重新创建您正在寻找的通用属性（I read your other question too）。如果混合使用非成员函数指针，它将无法工作。

通过使用模板和从公共非模板基类派生的包装类，您可以包含指向作为任何类类型成员的函数的成员函数指针。基类创建一个公共类型，与包装函数指针所属的类无关。如果你这样做，这可能很有用。想把包装器存放在同一个容器中。

只要函数签名始终相同（在这种情况下它固定为bool()），此示例就会起作用。

struct func_base {
    virtual ~func_base() {};
    virtual bool operator()() const = 0;
};

template <typename C>
class func_wrapper : public func_base {
public:
    typedef bool (C::*member_func_ptr_t)();
    func_wrapper(member_func_ptr_t func_ptr, C* instance_ptr)
        : m_func_ptr(func_ptr), m_instance_ptr(instance_ptr) {}
    bool operator()() const { return (m_instance_ptr->*m_func_ptr)(); }
private:
    member_func_ptr_t m_func_ptr;
    C* m_instance_ptr;
};

您还可以创建一个辅助函数来创建自动推断出成员类型的包装器。

/* This function returns a pointer to dynamically *
 * allocated memory and it is thus the callers    *
 * responsibility to deallocate the memory!!      */
template <typename C>
func_base* make_wrapper(bool (C::*func_ptr)(), C* instance_ptr) {
    return new func_wrapper<C>(func_ptr, instance_ptr);
}

现在您可以使用它，例如像这样：

struct Bar { // Define some other class with member function.
    bool memberFunc() { return false; }
};

int main() {
    Foo foo; // Create object instances.
    Bar bar; // ----------||-----------

    std::deque<func_base*> d; // Deque storing pointers to base class.

    // Push pointer to any member func.
    d.push_back(make_wrapper(&Foo::memberFunc, &foo));
    d.push_back(make_wrapper(&Bar::memberFunc, &bar));

    for (std::deque<func_base*>::iterator it = d.begin(); it != d.end(); ++it) {
        (**it)(); // Call all functions in deque.
    }

    for (std::deque<func_base*>::iterator it = d.begin(); it != d.end(); ++it) {
        delete *it; // REMEMBER to destroy wrappers pointed to!!
    }
}

这将使用C ++ 03编译器进行编译。请参阅使用gcc 4.3.2编译的 live demo 。

注意：如果您需要，可以轻松修改包装类，而不是存储实例的副本。

复制std :: function还是boost :: function？

2 个答案: