blocks|key|430964|text|auto的规则在很大程度上与模板类型推导规则相同。上述示例的工作原因与您可以将私有类型的对象传递给模板函数的原因相同：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|430965|template+<typename+T>
void+fun(T+t)+{}

int+main()+{
++++Foo+f;
++++fun(f.Baz());+++++++++//+ok
}|code-block|syntax|javascript|430966|你会问，为什么我们可以将私有类型的对象传递给模板函数？因为只有类型的名称是不可访问的。类型本身仍然可用，这就是为什么您可以将其返回给客户端代码的原因。|430967|entityMap^0|0|4|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|S|8|@]|D|@]|E|$]]|$1|M|3|-4|5|6|7|T|8|@]|D|@]|E|$]]]|N|$]]

The rules for <code>auto</code> are, for the most part, the same as for template type deduction. The example posted works for the same reason you can pass objects of private types to template functions:

<pre><code>template &lt;typename T&gt;
void fun(T t) {}

int main() {
 Foo f;
 fun(f.Baz()); // ok
}
</code></pre>

And why can we pass objects of private types to template functions, you ask? Because only the name of the type is inaccessible. The type itself is still usable, which is why you can return it to client code at all.

blocks|key|430994|text|为了补充其他(好的)答案，这里有一个来自C%2B%2B98的示例，它说明了这个问题实际上与auto无关|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|430995|class+Foo+{
++struct+Bar+{+int+i;+};
public:
++Bar+Baz()+{+return+Bar();+}
++void+Qaz(Bar)+{}
};

int+main()+{
++Foo+f;
++f.Qaz(f.Baz());+//+Ok
++//+Foo::Bar+x+=+f.Baz();
++//+f.Qaz(x);
++//+Error:+error:+‘struct+Foo::Bar’+is+private
}|code-block|syntax|javascript|430996|使用私有类型并不是被禁止的，它只是命名类型。例如，在所有版本的C%2B%2B中都可以创建该类型的未命名临时文件。|430997|entityMap^0|15|4|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|S|8|@]|D|@]|E|$]]|$1|M|3|-4|5|6|7|T|8|@]|D|@]|E|$]]]|N|$]]

To add to the other (good) answers, here's an example from C++98 that illustrates that the issue really doesn't have to do with <code>auto</code> at all

<pre><code>class Foo {
 struct Bar { int i; };
public:
 Bar Baz() { return Bar(); }
 void Qaz(Bar) {}
};

int main() {
 Foo f;
 f.Qaz(f.Baz()); // Ok
 // Foo::Bar x = f.Baz();
 // f.Qaz(x);
 // Error: error: ‘struct Foo::Bar’ is private
}
</code></pre>

Using the private type isn't prohibited, it was only naming the type. Creating an unnamed temporary of that type is okay, for instance, in all versions of C++.

blocks|key|212633|text|这个问题已经被chill和R.+Martinho+Fernandes回答得很好了。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|212634|我只是不能错过用哈利波特类比回答问题的机会：|212635|class+Wizard
{
private:
++++class+LordVoldemort
++++{
++++++++void+avada_kedavra()
++++++++{
++++++++++++//+scary+stuff
++++++++}
++++};
public:
++++using+HeWhoMustNotBeNamed+=+LordVoldemort;

++++friend+class+Harry;
};

class+Harry+:+Wizard
{
public:
++++Wizard::LordVoldemort;
};

int+main()
{
++++Wizard::HeWhoMustNotBeNamed+tom;+//+OK
++++//+Wizard::LordVoldemort+not_allowed;+//+Not+OK
++++Harry::LordVoldemort+im_not_scared;+//+OK
++++return+0;
}|code-block|syntax|javascript|212636|https://ideone.com/I5q7gw|offset|length|212637|感谢Quentin提醒我哈里漏洞。|212638|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|0|0|P|0|0|0^^$0|@$1|2|3|4|5|6|7|V|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|W|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|X|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|Y|8|@]|9|@$K|Z|L|10|1|11]]|A|$]]|$1|M|3|N|5|6|7|12|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|13|8|@]|9|@]|A|$]]]|P|$Q|$5|R|S|T|A|$U|J]]]]

This question has already been answered very well by both chill and R. Martinho Fernandes.

I just couldn't pass up the opportunity to answer a question with a Harry Potter analogy:

<pre><code>class Wizard
{
private:
 class LordVoldemort
 {
 void avada_kedavra()
 {
 // scary stuff
 }
 };
public:
 using HeWhoMustNotBeNamed = LordVoldemort;

 friend class Harry;
};

class Harry : Wizard
{
public:
 Wizard::LordVoldemort;
};

int main()
{
 Wizard::HeWhoMustNotBeNamed tom; // OK
 // Wizard::LordVoldemort not_allowed; // Not OK
 Harry::LordVoldemort im_not_scared; // OK
 return 0;
}
</code></pre>

<a href="https://ideone.com/I5q7gw" rel="nofollow noreferrer">https://ideone.com/I5q7gw</a>

Thanks to Quentin for reminding me of the Harry loophole.

blocks|key|431076|text|对于任何来到这里并需要解决办法的人(例如，为了声明一个接受私有类型的函数)，这是我所做的：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|431077|void+Func(decltype(Foo().Baz())+param)+{...}|code-block|syntax|javascript|431078|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|$]]

For anyone else coming here and needs a workaround (e.g. for declaring a function that accepts the private type), this is what I did:
<pre><code>void Func(decltype(Foo().Baz()) param) {...}
</code></pre>

I was somehow surprised that the following code compiles and runs (vc2012 &amp; gcc4.7.2)

<pre><code>class Foo {
 struct Bar { int i; };
public:
 Bar Baz() { return Bar(); }
};

int main() {
 Foo f;
 // Foo::Bar b = f.Baz(); // error
 auto b = f.Baz(); // ok
 std::cout &lt;&lt; b.i;
}
</code></pre>

Is it correct that this code compiles fine? And why is it correct? Why can I use <code>auto</code> on a private type, while I can't use its name (as expected)?

Why can I use auto on a private type?

令我感到惊讶的是，以下代码可以编译并运行(vc2012 & gcc4.7.2)class Foo {    struct Bar { int i; };public:    Bar Baz() { return Bar(); }};int main() {    Foo f;    // Foo::Bar b = f....

问为什么我可以在私有类型上使用auto？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问为什么我可以在私有类型上使用auto？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问为什么我可以在私有类型上使用auto？
EN