#include <iostream>
using namespace std;

struct foo
{
    void bar( void )
    {
        cout << val << endl;
    }

    int val;
};

int main()
{
    int (foo::*memvarptr) = &foo::val;
    void (foo::*memfunptr)( void ) = &foo::bar;

    foo a;
    a.*memvarptr = 123;
    (a.*memfunptr)();

    foo* p = &a;
    p->*memvarptr = 456;
    (p->*memfunptr)();
}

struct stra
{
    int a;
    struct stra *next;
};

stra * stra::*p;         // 整一个指向成员的指针：）
p = &stra::next;         // 让这个指针指向某成员：）
stra lgs1,lgs2,*pstru;

lgs1.next = &lgs2;
(lgs1.*p)->next = NULL;  // 等效于lgs2.next=NULL;
pstru = &lgs2;
pstru->*p->*p = &lgs1;   // 等效于lgs2.next=&lgs1;

说白了就是用于指向类/结构成员而用的一个东东：）

[quote]struct stra
{
    int a;
    struct stra *next;
};

stra * stra::*p;         // 整一个指向成员的指针：）
p = &stra::next;         // 让这个指针指向某成员：）
stra lgs1,lgs2,*pstru;

lgs1.next = &lgs2;
(lgs1.*p)->next = NULL;  // 等效于lgs2.next=NULL;
pstru = &lgs2;
pstru->*p->*p = &lgs1;   // 等效于lgs2.next=&lgs1;
[/quote]
最后一句MS作者手误了，应该是 pstru->*p = &lgs1;
因为 pstru->*p 的值为 NULL;

谢谢高手回复，已经明白意思了~~~~~~~~~~

[quote]#include <iostream>
using namespace std;

struct foo
{
    void bar( void )
    {
        cout << val << endl;
    }

    int val;
};

int main()
{
    int (foo::*memvarptr) = &foo::val;
    void (foo::*memfunptr)( void ) = &foo::bar;

    foo a;
    a.*memvarptr = 123;
    (a.*memfunptr)();

    foo* p = &a;
    p->*memvarptr = 456;
    (p->*memfunptr)();
}[/quote]
感觉上，这种用法像是给类/结构体的成员起了一个别名，可以通过 .* 和 ->* 来引用这个别名，不知这种用法有什么优点？

唉，晕那，是倒数第二句手误~~~~应该是指向lgs1~~~~
pstru = &lgs1;

#include <stdio.h>

class Test
{
public:
    Test(int val)
        : _nVal(val) {} 
    int PrintMsg(const char* msg)
    {
        printf("%d : %s\n", _nVal, msg);
        return 0; //success
    }
    int WriteMsg(const char* msg)
    {
        printf("%d : %s\n", _nVal, msg);
        return 0;
    }
    int _nVal;
};

typedef int (Test::*MemFunPtr)(const char*);
typedef int Test::*MemVarPrt;

MemFunPtr pmf[2] = {&Test::PrintMsg, &Test::WriteMsg};

int main()
{
    MemFunPtr memfunptr = &Test::PrintMsg;
    MemVarPrt varptr = &Test::_nVal;

    Test* obj = new Test(100);
    (obj->*memfunptr)("Linkin Park");
    printf("%d\n", obj->*varptr);

    Test t(1000);
    (t.*memfunptr)("muse");
    printf("%d\n", t.*varptr);

    delete obj;

    Test* pa = new Test(128);

    enum OPTIONS { PRINT, WRITE};
    OPTIONS option;
    //从外部读取选项
    option = PRINT;
    switch (option)
    {
        case PRINT:
            (pa->*pmf[PRINT])("Hello World");
            break;
        case WRITE:
            (pa->*pmf[WRITE])("How are u");
            break;
            //…
       default:
           break;
    }
    delete pa;
}

优点很多，比如在多线程中。

作用挺多，比如可以动态创建、消息响应啥的。

[quote]#include <stdio.h>

class Test
{
public:
    Test(int val)
        : _nVal(val) {} 
    int PrintMsg(const char* msg)
    {
        printf("%d : %s\n", _nVal, msg);
        return 0; //success
    }
    int WriteMsg(const char* msg)
    {
        printf("%d : %s\n", _nVal, msg);
        return 0;
    }
    int _nVal;
};

typedef int (Test::*MemFunPtr)(const char*);
typedef int Test::*MemVarPrt;
......[/quote]
从代码上看起来，这个好像是声明类的成员的指针，包括类的函数指针和类的数据成员指针。现在只是理解了一点皮毛，但还无法运用到实际中去，没有真正掌握其精髓。谢谢回复。

[quote]作用挺多，比如可以动态创建、消息响应啥的。[/quote]
不知这位仁兄有没有相关的详细点儿的资料可以介绍？
谢谢~~~