标签: pointer-to-member

问题如下:考虑这段代码:

#include <iostream>


class aClass
{
public:
    void aTest(int a, int b)
    {
        printf("%d + %d = %d", a, b, a + b);
    }
};

void function1(void (*function)(int, int))
{
    function(1, 1);
}

void test(int a,int b)
{
    printf("%d - %d = %d", a , b , a - b);
}

int main (int argc, const char* argv[])
{
    aClass a();

    function1(&test);
    function1(&aClass::aTest); // <-- How should I point to a's aClass::test function?

    return 0;
}

我如何使用a's aClass::test …

C++很酷的一点是,它允许您创建指向成员类型的变量.最常见的用例似乎是获取指向方法的指针:

struct foo
{
    int x() { return 5; }
};

int (foo::*ptr)() = &foo::x;
foo myFoo;
cout << (myFoo.*ptr)() << '\n'; // prints "5"

然而,乱搞,我意识到他们也可以指向成员变量:

struct foo
{
    int y;
};

int foo::*ptr = &foo::y;
foo myFoo;
myFoo.*ptr = 5;
cout << myFoo.y << '\n'; // prints "5"

这很漂亮.它引导我进一步实验:如果你能得到指向结构子成员的指针怎么办？

struct foo
{
    int y;
};

struct bar
{
    foo aFoo;
};

int bar::*foo::*ptr;

这实际上编译.

但是,我不知道如何分配任何有用的东西.以下都不起作用:

int bar::*foo::*ptr = &bar::foo::y; // no member named "foo" in "bar"
int …

是的,我已经看到了这个问题,而这个FAQ(错误的链接) 这个常见问题,但我还是不明白->*,并.*用C++的意思.
这些页面提供了有关运算符的信息(例如重载),但似乎并不能很好地解释它们是什么.

什么是->*和.*C++,你什么时候需要使用它们->和.？相比？

我正在阅读C++项目的代码,它包含以下形式的代码:

namespace ns {
    class A {};
    class B {};
}

struct C {
    typedef ns::A* ns::B::* type;
};

有人可以解释这条typedef线的含义吗？type似乎是某种指针的成员的ns::B指向ns::A,但我不知道.

类A和B实际代码不是空的,但我认为这与此无关.这是一个实例.

在C++中,我可以在函数指针和函数引用之间进行选择(或者为了完整性,甚至是函数值):

void call_function_pointer (void (*function)()) {
    (*function) ();
}
void call_function_reference (void (&function)()) {
    function ();
}
void call_function_value (void function()) {
    function ();
}

然而,当谈到方法时,我似乎没有在指针和引用之间做出这种选择.

template <class T> void call_method_pointer (T* object, void (T::*method)()) {
    (object->*method) ();
}
// the following code creates a compile error
template <class T> void call_method_reference (T& object, void (T::&method)()) {
    object.method ();
}

这使我假设C++中不存在方法引用.真的吗？如果是,他们不存在的原因是什么？

我找到了有趣的东西.错误消息说明了一切.在获取非静态成员函数的地址时不允许使用括号的原因是什么？我在gcc 4.3.4上编译了它.

#include <iostream>

class myfoo{
    public:
     int foo(int number){
         return (number*10);
     }
};

int main (int argc, char * const argv[]) {

    int (myfoo::*fPtr)(int) = NULL;

    fPtr = &(myfoo::foo);  // main.cpp:14

    return 0;

}

错误:main.cpp:14:错误:ISO C++禁止获取非限定或带括号的非静态成员函数的地址,以形成指向成员函数的指针.说'&myfoo :: foo'

您好我有这个代码与编译器错误(错误来自Microsoft Visual Studio 2008):

class B
{
protected:
int b;
};

class A : public B
{
public:
void foo(){ &B::b; }//  error C2248: 'B::b' : cannot access protected member declared in class 'B'
};

虽然此代码没有错误:

class B
{
protected:
int b;
};

class A : public B
{
public:
void foo(){ &(B::b); }
};

基于我对运算符优先级的了解,这两个片段在我看来是等价的,因为::具有比&更高的优先级(例如参见"联合攻击战斗机车辆C++编码系统开发和编码标准"第137页的表2)演示计划" http://www2.research.att.com/~bs/JSF-AV-rules.pdf)

但它们是不同的...我认为它与"指向数据成员"有关,但我不知道它如何与运算符优先级相符.

任何解释？

谢谢,亚历山德罗

我想使用指向类成员的指针作为模板参数,如下所示:

template <class Class, class Result, Result Class::*Member>
struct MyStruct {
    // ...
};

使用这个结构MyStruct<SomeClass, SomeResult, &SomeClass::value> variable就好了,但我不喜欢我必须指定SomeClass和SomeResult.

我想使用,MyStruct<&SomeClass::value> variable如果这是可能的,但不会失去传递任何类和任何结果类型的能力.

我尝试了以下方法,但语法是非法的:

template <class Class, class Result>
template <Result Class::*Member>
struct MyStruct {
    // ...
};

错误:模板参数列表太多

我尝试使用辅助函数(实际上在Clang中工作但被GCC拒绝):

template <class Class, class Result>
static constexpr auto makeMyStruct(Result Class::*member) ->
MyStruct<Class, Result, member> {
    // ...
}

错误:在函数体外使用参数`member'
错误:模板参数3无效

有可能有一个简单的MyStruct<&SomeClass::value>,如果是这样,怎么样？

相关问题没有解决我的问题:

• 指向类成员的指针作为模板参数
• 使用constexpr和返回模板函数的C++ 0x错误

可能重复:
带括号的成员函数的地址出错

在最近的这个问题中,OP遇到了C++语言的一个奇怪的规定,如果该成员函数名称被括起来,则取得成员函数的地址是非法的.例如,此代码是非法的:

struct X {
    void foo();
};

int main() {
    void (X::* ptr)();
    ptr = &(X::foo);   // Illegal; must be &X::foo
}

我查了一下,发现这是由于C++ ISO规范的§5.3.1/ 3所致

仅当使用显式&时,才会形成指向成员的指针,并且其操作数是未括在括号中的限定ID [...]

有没有人知道为什么规范有这个规则？它特定于指向成员的指针,所以我怀疑这会解决一些语法歧义,但老实说,我不知道它可能是什么.

我们说我有:

// This is all valid in C++11.
struct Foo {
    int i = 42;
    int& j = i;
};

// Let's take a pointer to the member "j".
auto b = &Foo::j; // Compiler is not happy here
// Note that if I tried to get a pointer to member "i", it would work, as expected.
Foo f;
std::cout << f.*b; // Try using the pointer to member

编译器抱怨我不能获取成员的地址,因为它是一个引用.确切地说:

语义问题:无法形成指向成员的指针指向成员'j'的引用类型'int&'

我知道这样做似乎毫无意义,但我只是想知道为什么不能这样做.

为什么这不可能？