blocks|key|151707|text|嗯，我用标准算法定期地使用指向成员函数的指针。就我而言，他们没有什么特别之处。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|151708|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Well I use pointers to member functions regularly with standard algorithms. There is nothing special about them as far as I am concerned.

blocks|key|36689|text|指向成员函数的指针对于使用for_each创建psuedo表达式非常有用。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|36690|vector<SomeClass*>+v+=+getAVector();
for_each(v.begin(),+v.end(),+mem_fun(&SomeClass::print));|code-block|syntax|javascript|36691|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Pointers to member function are great for creating psuedo lamba expressions with for_each

<pre><code>vector&lt;SomeClass*&gt; v = getAVector();
for_each(v.begin(), v.end(), mem_fun(&amp;SomeClass::print));
</code></pre>

blocks|key|121938|text|您可以使用boost::bind和获取普通函式来绑定成员变量和函数。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|121939|与他们一起工作的下一个工作将是关于通常的函数用法：|121940|标准function;|121941|using作为比较器传递的|unordered-list-item|121942|：：map/set；用作数据访问器的|121943|；|121944|121945|121946|entityMap^0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|R|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|S|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|T|8|@]|9|@]|A|$]]|$1|I|3|J|5|H|7|U|8|@]|9|@]|A|$]]|$1|K|3|L|5|H|7|V|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|W|8|@]|9|@]|A|$]]|$1|N|3|-4|5|6|7|X|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|P|$]]

You can bind member variables and functions with boost::bind and get usual functor. 
Next work with them will like on usual functions usage: 

<ul>
<li>passing as callback or signal function;</li>
<li>using in standard algorithms;</li>
<li>using as comparator in std::map/set; </li>
<li>using as data accessors; </li>
</ul>

blocks|key|121955|text|除了前面的内容之外，您还可以使用它们作为回调函数。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|121956|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

In addition to the previous, you can for example use them as callback functions.

blocks|key|36805|text|我对他们做的最酷的事，我很久以前就做过了。今天可能有更好的办法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|36806|我为网络管理工具创建了一个自生成命令行解析器.表示要管理的对象的类都有自己的子类表(名称、指针到工厂成员)、实例(id、从列表指针到实例)和命令(名称、指向成员函数的指针)。这使解析器能够处理以下内容：|36807|SET+NETWORK+ROUTE+192.168.0.0+HOPS+1|code-block|syntax|javascript|36808|或|36809|QUERY+NETWORK+NAMESERVER+servername|36810|不知道任何关于路线的信息，也不知道服务器的名称。|36811|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|R|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|S|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|T|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|U|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|V|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

The coolest thing I've done with them, I did a long time ago. There's probably a better way to do it today.

I created a self-generating command-line parser for a network management tool. The classes representing the objects to be managed each had their own tables of sub-classes (name, pointer-to-factory-member), instances (id, pointer to instance from a list), and commands (name, pointer to member function). This allowed the parser to handle things like:

<pre><code>SET NETWORK ROUTE 192.168.0.0 HOPS 1
</code></pre>

or

<pre><code>QUERY NETWORK NAMESERVER servername
</code></pre>

without knowing anything about routes, or name servers.

blocks|key|122098|text|我曾经需要将标准数据作为纯结构进行操作，以便能够在队列中存储所有条件的列表。我不得不将结构绑定到GUI和其他过滤器元素，等等，所以我想出了一个解决方案，其中使用指向成员的指针，以及指向成员函数的指针。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|122099|假设你有一个|122100|struct+Criteria
{
++++typedef+std::string+Criteria::*+DataRefType;
++++std::string+firstname;
++++std::string+lastname;
++++std::string+website;
};|code-block|syntax|javascript|122101|字段的字符串表示形式进行绑定。|122102|class+Field
{
public:
++++Field(+const+std::string&+name,
+++++++++++Criteria::DataRefType+ref+):
++++++++name_(+name+),
++++++++ref_(+ref+)
++++{}
++++std::string+getData(+const+Criteria&+criteria+)
++++{
++++++++return+criteria.*ref_;
++++}
++++std::string+name_;
private:
++++Criteria::DataRefType+ref_;
};|122103|然后，您可以随时注册要使用的所有字段:+GUI、序列化、按字段名进行比较等。|122104|class+Fields
{
public:
++++Fields()
++++{
++++++++fields_.push_back(+Field(+"First+Name",+&Criteria::firstname+)+);
++++++++fields_.push_back(+Field(+"Last+Name",+&Criteria::lastname+)+);
++++++++fields_.push_back(+Field(+"Website",+&Criteria::website+)+);
++++}
++++template+<+typename+TFunction+>
++++void+forEach(+TFunction+function+)
++++{
++++++++std::for_each(+fields_.begin(),+fields_.end(),
+++++++++++++++++++++++function+);
++++}
private:
++++std::vector<+Field+>+fields_;
};|122105|例如，通过调用fields.forEach(+serialization+);或|offset|length|style|CODE|122106|GuiWindow(+Criteria&+criteria+):
++++criteria_(+criteria+)
{
++++fields_.forEach(+std::bind1st(+
+++++++++++++++++++++++++std::mem_fun(+&GuiWindow::bindWithGui+),
+++++++++++++++++++++++++this+)+);
}
void+bindWithGui(+Field+field+)
{
++++std::cout+<<+"name+"+<<+field.name_
++++++++++++++<<+"+value+"+<<+field.getData(+criteria_+)+<<+std::endl;
};|122107|entityMap^0|0|0|0|0|0|0|0|7|W|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|11|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|12|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|13|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|14|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|15|8|@]|9|@]|A|$]]|$1|O|3|P|5|F|7|16|8|@]|9|@]|A|$G|H]]|$1|Q|3|R|5|6|7|17|8|@$S|18|T|19|U|V]]|9|@]|A|$]]|$1|W|3|X|5|F|7|1A|8|@]|9|@]|A|$G|H]]|$1|Y|3|-4|5|6|7|1B|8|@]|9|@]|A|$]]]|Z|$]]

I once was needed to operate with criteria data as pure structure to be able to store the list of all criteria in the queue. And I had to bind the structure with the GUI and other filter elements, etc. So I came up with the solution where pointers to members are used as well as pointers to member functions. 

Let's say you have an

<pre><code>struct Criteria
{
 typedef std::string Criteria::* DataRefType;
 std::string firstname;
 std::string lastname;
 std::string website;
};
</code></pre>

Than you can wrap criteria field and bind with the string representation of the field with 

<pre><code>class Field
{
public:
 Field( const std::string&amp; name,
 Criteria::DataRefType ref ):
 name_( name ),
 ref_( ref )
 {}
 std::string getData( const Criteria&amp; criteria )
 {
 return criteria.*ref_;
 }
 std::string name_;
private:
 Criteria::DataRefType ref_;
};
</code></pre>

Then you can register all the fields to use whenever you want: GUI, serialization, comparison by field names, etc.

<pre><code>class Fields
{
public:
 Fields()
 {
 fields_.push_back( Field( "First Name", &amp;Criteria::firstname ) );
 fields_.push_back( Field( "Last Name", &amp;Criteria::lastname ) );
 fields_.push_back( Field( "Website", &amp;Criteria::website ) );
 }
 template &lt; typename TFunction &gt;
 void forEach( TFunction function )
 {
 std::for_each( fields_.begin(), fields_.end(),
 function );
 }
private:
 std::vector&lt; Field &gt; fields_;
};
</code></pre>

By calling for instance <code>fields.forEach( serialization );</code> or

<pre><code>GuiWindow( Criteria&amp; criteria ):
 criteria_( criteria )
{
 fields_.forEach( std::bind1st( 
 std::mem_fun( &amp;GuiWindow::bindWithGui ),
 this ) );
}
void bindWithGui( Field field )
{
 std::cout &lt;&lt; "name " &lt;&lt; field.name_
 &lt;&lt; " value " &lt;&lt; field.getData( criteria_ ) &lt;&lt; std::endl;
};
</code></pre>

blocks|key|122130|text|我是在一个"DomainEditor“类中为我编写的这个大型应用程序编写的。数据库中的所有类型(域)表都可以由程序管理员编辑，而且由于客户端以不同的名称调用某些类型，所以我创建了一个对话框，允许您编辑它们。好吧，我不想为15%2B域类型做一个编辑器，所以我编写了一个超类，可以将每个类转换到其中，并且可以使用指针对每个域表进行简单调用。每个属性都支持所有相同的属性、描述(名称)、ID、非活动标志和所需的标志。因此，代码以宏开始设置我的调用：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|122131|#define+DomainList(Class,+Description,+First,+Next,+Item,+UpdateItem,+DeleteItem,+IsItemRequired,+MaxLength)+{+\
+++CWFLHandler+*handler+=+new+CWFLHandler;+\
+++handler->pWFL+=+new+Class;\
+++handler->LoadFirstType+=+(LoadFirst)&Class::First;\
+++handler->LoadNextType++=+(LoadNext)&Class::Next;\
+++handler->LoadType++++++=+(Load)&Class::Item;\
+++handler->UpdateType++++=+(Update)&Class::UpdateItem;\
+++handler->DeleteType++++=+(Delete)&Class::DeleteItem;\
+++handler->IsRequiredType=+(IsRequired)&Class::IsItemRequired;+\
+++handler->MAX_LENGTH++++=+MaxLength;\
+++PopulateListBox(m_Domain,+Description,+(long)handler);+}\|code-block|syntax|javascript|122132|然后，给宏打了很多电话：(这里只有一个电话)|122133|+++DomainList(CConfigWFL,+++"Application+Parameter+Types",++++++++LoadFirstParameterType,+++++++++++++++++++LoadNextParameterType,+++++++++++++++++LoadParameterTypeByTypeId,++++++++++++++++++++++++++++++++++++++++UpdateParameterType,++++++++++++++++DeleteParameterType,++++++++++++++++IsParameterTypeRequired,++++++++++++LEN_APPL_PARAMETER_DESC);|122134|然后，编辑数据的调用都很常见，我根本不需要重复任何代码.|122135|例如，要用DropDownList中的选定项填充列表(由宏填充)，代码如下所示：|122136|+if((pWFLPtr->pWFL->*pWFLPtr->LoadFirstType)(true))
++{
+++++do
+++++{
++++++++m_Grid.AddGridRow();
++++++++m_Grid.SetCheck(COLUMN_SYSTEM,+++++++++(pWFLPtr->pWFL->*pWFLPtr->IsRequiredType)(pWFLPtr->pWFL->TypeId));
++++++++m_Grid.SetCheck(COLUMN_STATUS,++++++pWFLPtr->pWFL->InactiveIndc+==+false);
++++++++m_Grid.AddTextToGrid(COLUMN_NAME,+++pWFLPtr->pWFL->TypeDesc);
++++++++m_Grid.AddTextToGrid(COLUMN_DEBUG,++pWFLPtr->pWFL->TypeId);
++++++++m_Grid.AddTextToGrid(COLUMN_ID,+++++pWFLPtr->pWFL->TypeId);
+++++}
+++++while((pWFLPtr->pWFL->*pWFLPtr->LoadNextType)());|122137|当然，所有这些都存储在对话框中的一个类中。我只是创建了类的新实例，将它们存储在ListBox的ItemData成员中。所以，当对话框关闭时，我必须清理掉所有这些。不过，我把这段代码从这条消息中删除了。|122138|将所有这些内容存储在其中的类被定义为：|122139|+++typedef+bool+(CMyWFL::*LoadFirst)(bool);
+++typedef+bool+(CMyWFL::*LoadNext)();
+++typedef+bool+(CMyWFL::*Load)(long);
+++typedef+bool+(CMyWFL::*Update)(long,+const+char*,+bool);
+++typedef+bool+(CMyWFL::*Delete)(long);
+++typedef+bool+(CMyWFL::*IsRequired)(long);

+++class+CWFLHandler+{
+++public:
++++++CWFLHandler()++{};
++++++~CWFLHandler()+{+if(pWFL)+delete+pWFL;+}

++++++CMyWFL++++*pWFL;
++++++LoadFirst+++LoadFirstType;
++++++LoadNext++++LoadNextType;
++++++Load++++++++LoadType;
++++++Update++++++UpdateType;
++++++Delete++++++DeleteType;
++++++IsRequired++IsRequiredType;
++++++int+++++++++MAX_LENGTH;
+++};
+++CWFLHandler+*pWFLPtr;|122140|所有这些工作使得能够向应用程序添加新域非常好，而将它们添加到域编辑器的工作非常少.也许还有更好的方法，我不知道。但这就是我的方式，对我来说效果很好，而且IMHO，很有创意.:)|122141|entityMap^0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|11|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|12|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|13|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|14|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|15|8|@]|9|@]|A|$]]|$1|O|3|P|5|D|7|16|8|@]|9|@]|A|$E|F]]|$1|Q|3|R|5|6|7|17|8|@]|9|@]|A|$]]|$1|S|3|T|5|6|7|18|8|@]|9|@]|A|$]]|$1|U|3|V|5|D|7|19|8|@]|9|@]|A|$E|F]]|$1|W|3|X|5|6|7|1A|8|@]|9|@]|A|$]]|$1|Y|3|-4|5|6|7|1B|8|@]|9|@]|A|$]]]|Z|$]]

I did it in a "DomainEditor" class for this huge application I wrote. All my type (domain) tables in the database could be edited by the admins of the program and since the clients called some of the types by different names than others did, I made a dialog that allowed you to edit them. Well, I didn't want to make an editor for the 15+ domain types, so I wrote a super-class that I could cast each class to, and using pointers I could make simple calls to each domain table. Each one supported all the same properties, a Description (name), an ID, an Inactive flag, and a Required flag. So, the code started with a Macro to setup my calls:

<pre><code>#define DomainList(Class, Description, First, Next, Item, UpdateItem, DeleteItem, IsItemRequired, MaxLength) { \
 CWFLHandler *handler = new CWFLHandler; \
 handler-&gt;pWFL = new Class;\
 handler-&gt;LoadFirstType = (LoadFirst)&amp;Class::First;\
 handler-&gt;LoadNextType = (LoadNext)&amp;Class::Next;\
 handler-&gt;LoadType = (Load)&amp;Class::Item;\
 handler-&gt;UpdateType = (Update)&amp;Class::UpdateItem;\
 handler-&gt;DeleteType = (Delete)&amp;Class::DeleteItem;\
 handler-&gt;IsRequiredType= (IsRequired)&amp;Class::IsItemRequired; \
 handler-&gt;MAX_LENGTH = MaxLength;\
 PopulateListBox(m_Domain, Description, (long)handler); }\
</code></pre>

Then, lots of calls to the Macro: (Here is just a single one)

<pre><code> DomainList(CConfigWFL, "Application Parameter Types", LoadFirstParameterType, LoadNextParameterType, LoadParameterTypeByTypeId, UpdateParameterType, DeleteParameterType, IsParameterTypeRequired, LEN_APPL_PARAMETER_DESC);
</code></pre>

Then, the calls to edit the data were all common, and I didn't have to duplicate any code at all...

For example, to populate the list with the selected item in the DropDownList (populated by the Macro), the code would look like this:

<pre><code> if((pWFLPtr-&gt;pWFL-&gt;*pWFLPtr-&gt;LoadFirstType)(true))
 {
 do
 {
 m_Grid.AddGridRow();
 m_Grid.SetCheck(COLUMN_SYSTEM, (pWFLPtr-&gt;pWFL-&gt;*pWFLPtr-&gt;IsRequiredType)(pWFLPtr-&gt;pWFL-&gt;TypeId));
 m_Grid.SetCheck(COLUMN_STATUS, pWFLPtr-&gt;pWFL-&gt;InactiveIndc == false);
 m_Grid.AddTextToGrid(COLUMN_NAME, pWFLPtr-&gt;pWFL-&gt;TypeDesc);
 m_Grid.AddTextToGrid(COLUMN_DEBUG, pWFLPtr-&gt;pWFL-&gt;TypeId);
 m_Grid.AddTextToGrid(COLUMN_ID, pWFLPtr-&gt;pWFL-&gt;TypeId);
 }
 while((pWFLPtr-&gt;pWFL-&gt;*pWFLPtr-&gt;LoadNextType)());
</code></pre>

Of, course, this was all stored in a class that was part of the dialog. And I simply created new instances of the class, stored them in the ListBox's ItemData member. So, I did have to clean all that up when the dialog closed.. I left that code out of this message however.

The class to store all this stuff in was defined as:

<pre><code> typedef bool (CMyWFL::*LoadFirst)(bool);
 typedef bool (CMyWFL::*LoadNext)();
 typedef bool (CMyWFL::*Load)(long);
 typedef bool (CMyWFL::*Update)(long, const char*, bool);
 typedef bool (CMyWFL::*Delete)(long);
 typedef bool (CMyWFL::*IsRequired)(long);

 class CWFLHandler {
 public:
 CWFLHandler() {};
 ~CWFLHandler() { if(pWFL) delete pWFL; }

 CMyWFL *pWFL;
 LoadFirst LoadFirstType;
 LoadNext LoadNextType;
 Load LoadType;
 Update UpdateType;
 Delete DeleteType;
 IsRequired IsRequiredType;
 int MAX_LENGTH;
 };
 CWFLHandler *pWFLPtr;
</code></pre>

All this work made it really nice to be able to add new domains to the application with very little work to add them to the domain editor... There may have been a better way, I don't know. But this is the way I went, and it worked VERY well for me, and IMHO, it was very creative... :)

blocks|key|151917|text|我使用它们作为StructSerlialiser的一部分，从SAX事件中填充XML结构，即将C%2B%2B映射到C%2B%2B数据模型。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|151918|template<class+STRUCT,+typename+FIELDTYPE>
struct+FieldBinderImpl+:+public+FieldBinder<STRUCT>
{
++++typedef+FIELDTYPE+(STRUCT::*MemberPtr);

++++FieldBinderImpl+(const+std::string&+tag,+MemberPtr+memberPtr)
++++++++:+FieldBinder+(tag)
++++++++,+memberPtr_+(memberPtr)
++++{
++++}

++++virtual+SerialiserBase*+createSerialiser+(STRUCT&+data)+const
++++{
++++++++return+new+Serialiser<FIELDTYPE>+(&(data.*memberPtr_));
++++}

private:
++++MemberPtr+memberPtr_;
};

template<class+T>
class+StructSerialiser+:+public+SerialiserData<T>
{
public:
++++typedef+std::vector<FieldBinder<T>*>+FieldBinderList;

private:
++++static+FieldBinderList+fieldBinderList_;

protected:
++++template<typename+FIELDTYPE>
++++static+void+bind+(const+std::string&+tag,+FIELDTYPE+(T::*+member))
++++{
++++++++fieldBinderList_.push_back+(new+FieldBinderImpl<T,+FIELDTYPE>+(tag,+member));
++++++++if+(tag.empty+())
++++++++++++fieldBinderList_.back+()->tags_+=+Serialiser<FIELDTYPE>::getTags+();
++++}

++++//+...
}

//+...|code-block|syntax|javascript|151919|还有用于双、字符串、向量等的序列化器。要使用它，只需将结构成员绑定到名称，例如：|151920|class+Index
{
public:
++++std::string+++++++++currency;
++++std::string+++++++++name;
};

template<>
class+Serialiser<Index>+:+public+StructSerialiser<Index>
{
public:
++++Serialiser+(Index*+data)+:+StructSerialiser<Index>+(data)+{}

++++static+void+initialise+()
++++{
++++++++bind+("currency",+&Index::currency);
++++++++bind+("name",+&Index::name);
++++}
};|151921|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

I used them as part of a StructSerlialiser to populate C++ POD structures from SAX Parser events, i.e. to map XML onto a C++ data model.

<pre><code>template&lt;class STRUCT, typename FIELDTYPE&gt;
struct FieldBinderImpl : public FieldBinder&lt;STRUCT&gt;
{
 typedef FIELDTYPE (STRUCT::*MemberPtr);

 FieldBinderImpl (const std::string&amp; tag, MemberPtr memberPtr)
 : FieldBinder (tag)
 , memberPtr_ (memberPtr)
 {
 }

 virtual SerialiserBase* createSerialiser (STRUCT&amp; data) const
 {
 return new Serialiser&lt;FIELDTYPE&gt; (&amp;(data.*memberPtr_));
 }

private:
 MemberPtr memberPtr_;
};

template&lt;class T&gt;
class StructSerialiser : public SerialiserData&lt;T&gt;
{
public:
 typedef std::vector&lt;FieldBinder&lt;T&gt;*&gt; FieldBinderList;

private:
 static FieldBinderList fieldBinderList_;

protected:
 template&lt;typename FIELDTYPE&gt;
 static void bind (const std::string&amp; tag, FIELDTYPE (T::* member))
 {
 fieldBinderList_.push_back (new FieldBinderImpl&lt;T, FIELDTYPE&gt; (tag, member));
 if (tag.empty ())
 fieldBinderList_.back ()-&gt;tags_ = Serialiser&lt;FIELDTYPE&gt;::getTags ();
 }

 // ...
}

// ...
</code></pre>

Also had Serialisers for double, strings, vectors, etc. To use it you would just bind struct members to names, e.g.:

<pre><code>class Index
{
public:
 std::string currency;
 std::string name;
};

template&lt;&gt;
class Serialiser&lt;Index&gt; : public StructSerialiser&lt;Index&gt;
{
public:
 Serialiser (Index* data) : StructSerialiser&lt;Index&gt; (data) {}

 static void initialise ()
 {
 bind ("currency", &amp;Index::currency);
 bind ("name", &amp;Index::name);
 }
};
</code></pre>

Pointer to members are not used very much but they are really powerful, how have you used them and what's the coolest things you've done?

Edit:
This is not so much to list things that are possible, for example listing boost::bind and boost::function aren't good. Instead maybe a cool usage with them? I know they're very cool in themselves but that's not what this is about.

What's the best use you've had with pointer to members and member functions?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

指向成员的指针使用得不多，但它们非常强大，您是如何使用它们的，您做过的最酷的事情是什么？编辑：--这并不是列出可能的事情，例如列出boost::bind和boost：：函数不是很好。相反，也许与他们一起使用是很酷的？我知道他们自己很酷，但这不是问题所在。

问使用指向成员和成员函数的指针有什么最佳用途？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问使用指向成员和成员函数的指针有什么最佳用途？EN