@选择器在C+中的实现+； 我需要在C++中实现类似的机制，如@选择器（ObjigeTeo C）。通过谷歌搜索，我找到了。这对我没有帮助 template <class AnyClass> class ClassCallback { // pointer to member function void (AnyClass::*function)(void); // pointer to object AnyClass object; public: ClassCallback() { } ~ClassCallback() { } ClassCallback(AnyClass _object, void(AnyClass::*_function)(void)) : object( _object ), function( _function ) { }; virtual void call(){ (object->*function)(); }; }; 需要实现ObjcLead，它是Objtovior中的抽象类。如何实现ObjyLoopter………< /P> < P> ObjuleC和C++是非常不同的语言，据我所知C++没有与Objy-C的选择器类似或类似的东西。如果你解释了你正在试图解决的问题，我确信这里的人会乐意讨论从C++角度处理问题的方式。 < P>只是Objy-C消息系统中的一些精确性，以及选择器。

选择器（SEL）是一种不透明类型，但它只是类似于

char*

，只包含方法的名称（因此许多类可以共享同一个选择器）

Obj-C方法是包含以下内容的结构：

一个

SEL

字段

包含有关返回类型和参数的信息的

char*

IMP

字段

比如：

struct objc_method
{
    SEL    method_name;
    char * method_types;
    IMP    method_imp;
};
typedef objc_method Method;

---

<> >代码> IMP<代码>只是C函数指针。

< P>如果在编译C++文件之前使用自定义预处理器很满意，可以使用QT的信号和槽机制，这是一个稍微扩展的C++中消息传递系统的实现。请参阅。

您可能希望执行以下操作：

// We use something to define what "identifies" a
class selector {
private:
   std::string name;
public:
    selector(std::string const& n) : name(n) {}
    selector(const char* n) : name(n) {}
};
typedef const selector* SEL;

typedef void* (*method) (object&, ...);
struct object {
private:
   std::hash<SEL,method>* methods;
public:
   object(std::map<SEL,method>* m)  : methods(m) {};
};

selector cloneSelector = selector("clone");
typedef void* cloneImplementation(object&, ...) {
  ....
};

std::map<SEL,method> fooMethods;
fooMethods[cloneSelector]=&cloneImplementation;

class foo : public object {
public:
  foo()  : object(&fooMethods) {};
};

像这样使用它：

// We use something to define what "identifies" a
class selector {
private:
   std::string name;
public:
    selector(std::string const& n) : name(n) {}
    selector(const char* n) : name(n) {}
};
typedef const selector* SEL;

typedef void* (*method) (object&, ...);
struct object {
private:
   std::hash<SEL,method>* methods;
public:
   object(std::map<SEL,method>* m)  : methods(m) {};
};

selector cloneSelector = selector("clone");
typedef void* cloneImplementation(object&, ...) {
  ....
};

std::map<SEL,method> fooMethods;
fooMethods[cloneSelector]=&cloneImplementation;

class foo : public object {
public:
  foo()  : object(&fooMethods) {};
};

AFAIK sel_id是指向由方法名和（编码的）参数类型组成的字符串的指针

您可能希望在接口中对方法进行分组，并采用一种稍微“类似COM”的方式：

 struct interface_id {};

 class object {
 protected:
    virtual void* getVtable_(interface_id const&) = 0;
 public:
    template<class X> X* getVtable() {
        return getVtable(X::interface_id);
    }
    virtual ~object();
 };

 // Exemple interface

 struct FooInterface {
 public:
   class vtable {
     void (*fooMethod2)(void* self, int n);
     std::vector<int> (*fooMethod2)(void* self, double x);
   };
   static interface_id ID;
   static std::string NAME; // = "FooInterface"
 private:
    void* self;
    FooVtable* vtable;
 public:
    void fooMethod1(int n) {
      return vtable->fooMethod1(self,n);
    };
    void fooMethod2(double x) {
      return vtable->fooMethod2(self,double x);
    };
 };

// Exemple object

class foo_object : public bar_object {
private:
   static std::map<interface_id, void*> INTERFACES;
public:
   virtual void* getVtable_(interface_id const& id) {
     void* res = INTERFACES[&id];
     if(res!=null)
        return res;
     else
        return bar_object::getVtable(id);
   };
};

struct接口_id{}；
类对象{
受保护的：
虚拟void*getVtable_u（interface_uid const&）=0；
公众：
模板X*getVtable（）{
返回getVtable（X:：interface_id）；
}
虚拟对象（）；
};
//示例接口
结构接口{
公众：
类vtable{
void（*foodmethod2）（void*self，int n）；
标准：向量（*foodmethod2）（空*自，双x）；
};
静态接口id；
静态标准：：字符串名称；//=“FooInterface”
私人：
空虚*自我；
食物表*vtable；
公众：
void foodmethod1（int n）{
返回vtable->foodmethod1（self，n）；
};
无效方法2（双x）{
返回vtable->foodmethod2（self，double x）；
};
};
//示例对象
类foo_对象：公共bar_对象{
私人：
静态std:：map接口；
公众：
虚拟空*getVtable（接口id常量和id）{
void*res=接口[&id]；
如果（res！=null）
返回res；
其他的
返回条\对象：：getVtable（id）；
};
};

---

它给出了一个如何执行函数签名的想法。对于基于选择器的方法，您应该能够使用相同的方法（使用一些无聊的模板元编程代码…。

我在使用Cocos2d-x时遇到了类似的问题，在我的例子中，我使用了

callfunc\u选择器来获取选择器：

假设其中有一个类
Foo
和一个方法
Bar（）
，只需调用
callfunc\u选择器（Foo:：Bar）它将返回一个<代码> CCOBCKED*/COD>到方法。< /P>如果你能描述一个<代码> @选择器< /> >，那么我们C++的人可以建议你怎么做你想要的：-不，它把它变成了<代码> SEL>代码>，这不是一个对象，这是一种不透明类型。@Jonathan Grynspan
SEL
相当于
struct objc\u selector*
。我没有说
objc\u选择器
是一个对象。@Jonathan Grynspan，我说：“一个
objc\u选择器
对象。”我没有说
objc\u选择器
本身就是一个对象。：）
SEL
是一种结构，这是完全不相关的；运行时根本不使用结构内容进行动态分派。基本上，他想要在运行时发生分派的地方命名虚拟方法（如果他真的想要类似于objc的分派）。“一个
IMP
只是一个C函数指针”你说得好像这是一个大家都能理解的简单想法！应该适用于所有C/ObjC/C++开发人员，在一个完美的世界中……；）