blocks|key|132005|text|问题是&Derived::doStuff实际上并不是指向类Derived的成员的指针。来自expr.unary.op|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|132006|132007|一元&运算符的结果是指向其操作数的指针。操作数应为左值或限定id。如果操作数是一个限定id，用于命名类型为T的某个类C的非静态或可变成员m，则结果的类型为“指向类型为T的类C的成员的指针”，并且是一个指定为C::m的prvalue。|blockquote|132008|132009|132010|doStuff不是Derived的成员。它是Base的成员。因此，它具有指向Base或void+(Base::*)()成员的类型指针。using-声明在这里所做的仅仅是帮助来自namespace.udecl的重载解析|132011|132012|出于重载解析的目的，通过使用声明引入派生类的函数将被视为派生类的成员。|132013|132014|132015|这就是d.doStuff()工作的原因。但是，通过函数指针，您正在尝试调用Derived对象上的Base成员函数。这里没有重载解析，因为你直接使用了一个函数指针，所以基类函数将是不可访问的。|132016|您可能认为只需将&Derived::doStuff转换为“正确”类型：|132017|exec(&d,+static_cast<void+(Derived::*)()>(&Derived::doStuff));|code-block|syntax|javascript|132018|但根据conv.mem，您也不能这样做，因为Base是Derived的一个不可访问的基础|132019|132020|“指向类型为cv+T的B的成员的指针”类型的PRV值，其中B是类类型，可以被转换为“指向类型为cv+T的D的成员的指针”类型的PR值，其中D是B的派生类(第10条)。如果B是不可访问(第11条)的、歧义(10.2)或D的虚拟(10.1)基类，或者是D的虚拟基类的基类，则需要进行此转换的程序是格式错误的。|BOLD|132021|132022|entityMap^0|3|H|T|7|0|0|2|1|1H|1|1M|1|1W|1|2B|1|2E|1|2V|4|0|0|0|0|7|9|7|M|4|12|4|17|G|0|0|0|0|0|3|B|11|7|1C|4|0|8|H|0|0|M|4|R|7|0|0|9|1|B|1|T|1|1E|1|1G|1|1X|1|1Z|1|2D|1|30|1|3G|1|2F|B|0|0^^$0|@$1|2|3|4|5|6|7|1A|8|@$9|1B|A|1C|B|C]|$9|1D|A|1E|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|1F|8|@]|D|@]|E|$]]|$1|G|3|H|5|I|7|1G|8|@$9|1H|A|1I|B|C]|$9|1J|A|1K|B|C]|$9|1L|A|1M|B|C]|$9|1N|A|1O|B|C]|$9|1P|A|1Q|B|C]|$9|1R|A|1S|B|C]|$9|1T|A|1U|B|C]]|D|@]|E|$]]|$1|J|3|-4|5|6|7|1V|8|@]|D|@]|E|$]]|$1|K|3|-4|5|6|7|1W|8|@]|D|@]|E|$]]|$1|L|3|M|5|6|7|1X|8|@$9|1Y|A|1Z|B|C]|$9|20|A|21|B|C]|$9|22|A|23|B|C]|$9|24|A|25|B|C]|$9|26|A|27|B|C]]|D|@]|E|$]]|$1|N|3|-4|5|6|7|28|8|@]|D|@]|E|$]]|$1|O|3|P|5|I|7|29|8|@]|D|@]|E|$]]|$1|Q|3|-4|5|6|7|2A|8|@]|D|@]|E|$]]|$1|R|3|-4|5|6|7|2B|8|@]|D|@]|E|$]]|$1|S|3|T|5|6|7|2C|8|@$9|2D|A|2E|B|C]|$9|2F|A|2G|B|C]|$9|2H|A|2I|B|C]]|D|@]|E|$]]|$1|U|3|V|5|6|7|2J|8|@$9|2K|A|2L|B|C]]|D|@]|E|$]]|$1|W|3|X|5|Y|7|2M|8|@]|D|@]|E|$Z|10]]|$1|11|3|12|5|6|7|2N|8|@$9|2O|A|2P|B|C]|$9|2Q|A|2R|B|C]]|D|@]|E|$]]|$1|13|3|-4|5|6|7|2S|8|@]|D|@]|E|$]]|$1|14|3|15|5|I|7|2T|8|@$9|2U|A|2V|B|C]|$9|2W|A|2X|B|C]|$9|2Y|A|2Z|B|C]|$9|30|A|31|B|C]|$9|32|A|33|B|C]|$9|34|A|35|B|C]|$9|36|A|37|B|C]|$9|38|A|39|B|C]|$9|3A|A|3B|B|C]|$9|3C|A|3D|B|C]|$9|3E|A|3F|B|16]]|D|@]|E|$]]|$1|17|3|-4|5|6|7|3G|8|@]|D|@]|E|$]]|$1|18|3|-4|5|6|7|3H|8|@]|D|@]|E|$]]]|19|$]]

The problem is that <code>&amp;Derived::doStuff</code> isn't actually a pointer to a member of class <code>Derived</code>. From [expr.unary.op]:

<blockquote>
 The result of the unary <code>&amp;</code> operator is a pointer to its operand. The operand shall be an lvalue or a qualified-id.
 If the operand is a qualified-id naming a non-static or variant member <code>m</code> of some class <code>C</code> with type <code>T</code>,
 the result has type “pointer to member of class <code>C</code> of type <code>T</code>” and is a prvalue designating <code>C::m</code>.
</blockquote>

<code>doStuff</code> is not a member of <code>Derived</code>. It is a member of <code>Base</code>. Hence it has type pointer to member of <code>Base</code>, or <code>void (Base::*)()</code>. What the using-declaration does here is simply an aid to overload resolution, from [namespace.udecl]:

<blockquote>
 For the purpose of overload resolution, the functions which are introduced by a using-declaration into a
 derived class will be treated as though they were members of the derived class.
</blockquote>

That's why <code>d.doStuff()</code> works. However, through the function pointer, you're trying to call a <code>Base</code> member function on a <code>Derived</code> object. There's no overload resolution here since you're using a function pointer directly, so the base class function would be inaccessible. 

You might think you could just cast <code>&amp;Derived::doStuff</code> to the "correct" type:

<pre><code>exec(&amp;d, static_cast&lt;void (Derived::*)()&gt;(&amp;Derived::doStuff));
</code></pre>

But you can't do that either according to [conv.mem], since again <code>Base</code> is an inaccessible base of <code>Derived</code>:

<blockquote>
 A prvalue of type “pointer to member of <code>B</code> of type cv <code>T</code>”, where <code>B</code> is a class type, can be converted to a
 prvalue of type “pointer to member of <code>D</code> of type cv <code>T</code>”, where <code>D</code> is a derived class (Clause 10) of <code>B</code>. If <code>B</code> is an
 inaccessible (Clause 11), ambiguous (10.2), or virtual (10.1) base class of <code>D</code>, or a base class of a virtual base
 class of <code>D</code>, a program that necessitates this conversion is ill-formed.
</blockquote>

blocks|key|130414|text|根据标准namespace.udecl|type|unstyled|depth|inlineStyleRanges|entityRanges|data|130415|130416|使用声明将一个名称引入到声明区域中，在该区域中将出现使用声明。|blockquote|130417|130418|如果使用声明命名了一个构造函数(3.4.3.1)，它会隐式地在出现该使用声明的类中声明一组构造函数(12.9)；否则，在使用声明中指定的名称是另一个名称空间或类中的一组声明的同义词。|130419|130420|所以您只是将Base::doStuff引入Derived区域，它仍然是Base的成员函数。|offset|length|style|CODE|130421|然后exec被实例化为exec<Derived,+void+(Base::*)()>，但由于私有继承，它不能将Derived*转换为Base*。|130422|entityMap^0|0|0|0|0|0|0|6|D|L|7|Z|4|0|2|4|B|V|1J|8|1U|5|0^^$0|@$1|2|3|4|5|6|7|T|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|U|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|V|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|W|8|@]|9|@]|A|$]]|$1|G|3|H|5|6|7|X|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|Z|8|@$L|10|M|11|N|O]|$L|12|M|13|N|O]|$L|14|M|15|N|O]]|9|@]|A|$]]|$1|P|3|Q|5|6|7|16|8|@$L|17|M|18|N|O]|$L|19|M|1A|N|O]|$L|1B|M|1C|N|O]|$L|1D|M|1E|N|O]]|9|@]|A|$]]|$1|R|3|-4|5|6|7|1F|8|@]|9|@]|A|$]]]|S|$]]

According to the stardard [namespace.udecl]:

<blockquote>
 A using-declaration introduces a name into the declarative region in which the using-declaration appears.
 
 If a using-declaration names a constructor (3.4.3.1), it implicitly
 declares a set of constructors in the class in which the
 using-declaration appears (12.9); otherwise the name specified in a
 using-declaration is a synonym for a set of declarations in another
 namespace or class.
</blockquote>

So you're just introducing <code>Base::doStuff</code> into the <code>Derived</code> region, it's still a member function of <code>Base</code>.

Then <code>exec</code> is instantiated as <code>exec&lt;Derived, void (Base::*)()&gt;</code>, but it can't cast a <code>Derived*</code> to <code>Base*</code> because of the private inheritance.

blocks|key|2693819|text|来自C%2B%2B11标准，§7.3.3+namespace.udecl，18：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2693820|class+A
{
private:
++++void+f(+char+);
public:
++++void+f(+int+);
protected:
++++void+g();
};
class+B+:+public+A
{
++++using+A::f;+//+error:+A::f(char)+is+inaccessible
public:
++++using+A::g;
++++//+B::g+is+a+public+synonym+for+A::g
};|code-block|syntax|javascript|2693821|注B::g是A::g部件的公共同义词。当你获取Derived::doStuff的地址时，GCC创建了一个指向void(Base::*)()类型的成员函数的指针，而标准说它做得很好。因此，我认为编译时错误是公平的。|offset|length|style|BOLD|CODE|2693822|entityMap^0|0|0|1|9|N|G|1I|F|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|Q|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|R|8|@$I|S|J|T|K|L]|$I|U|J|V|K|M]|$I|W|J|X|K|M]]|9|@]|A|$]]|$1|N|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|O|$]]

From the C++11 Standard, §7.3.3 [namespace.udecl], 18:

<pre><code>class A
{
private:
 void f( char );
public:
 void f( int );
protected:
 void g();
};
class B : public A
{
 using A::f; // error: A::f(char) is inaccessible
public:
 using A::g;
 // B::g is a public synonym for A::g
};
</code></pre>

Note the B::g is a public synonym for A::g part. When you take the address of <code>Derived::doStuff</code>, GCC is creating a pointer to member function of type <code>void(Base::*)()</code>, and the standard says it's doing well. So, I think the compile time error is fair.

I have an issue regarding access declarations under g++ (version 5.1).

<pre><code>class Base
{
public:
 void doStuff() {}
};

class Derived : private Base
{
public:
 // Using older access declaration (without using) shoots a warning
 // and results in the same compilation error
 using Base::doStuff;
};

template&lt;class C, typename Func&gt;
void exec(C *c, Func func)
{
 (c-&gt;*func)();
}

int main()
{
 Derived d;
 // Until here, everything compiles fine
 d.doStuff();
 // For some reason, I can't access the function pointer
 exec(&amp;d,&amp;Derived::doStuff);
}
</code></pre>

g++ fails to compile the above code with:

<blockquote>
 test.cpp: In instantiation of ‘void exec(C*, Func) [with C = Derived; Func = void (Base::*)()]’:
 test.cpp:24:27: required from here 
 test.cpp:17:4: error: ‘Base’ is an inaccessible base of ‘Derived’
 (c->*func)();
</blockquote>

Even when the function itself can be called (<code>d.doStuff();</code>) the pointer can't be used even though I declared the function as accessible from the outside.
Private inheritance is also important, to some extent, because the <code>Derived</code> class chooses to expose only a certain set of members from base(s) which are interface implementations IRL.

NB : this is a question about the language, not class design.

Public access declaration does not affect member function pointers?

在g++ (5.1版)下，我有一个关于访问声明的问题。class Base{public:    void doStuff() {}};class Derived : private Base{public:    // Using older access declaration (without using) sh...

问公共访问声明不会影响成员函数指针？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问公共访问声明不会影响成员函数指针？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问公共访问声明不会影响成员函数指针？
EN