blocks|key|150292|text|这里的问题是，也可以为引用实现一个特征，所以如果你没有为Box指定所需的生命周期，那么任何东西都可能存储在那里。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|150293|您可以在此rfc中查看有关生命周期的要求。|offset|length|150294|因此，一种可能的解决方案是绑定生存期，以便Send+(我们将I放在S中)：|style|CODE|150295|trait+A+{
++++fn+f(&self);
}

struct+I;

impl+A+for+I+{
++++fn+f(&self)+{
++++++++println!("A+for+I")
++++}
}

struct+S+{
++++a:+Box<A+%2B+Send>
}

fn+main()+{
++++let+s+=+S+{
++++++++a:+box+I
++++};
++++s.a.f();
}|code-block|syntax|javascript|150296|另一种方法是将生存期设置为'a+(我们可以将引用&I或I设置为S)：|150297|trait+A+{
++++fn+f(&self);
}

struct+I;

impl+A+for+I+{
++++fn+f(&self)+{
++++++++println!("A+for+I")
++++}
}

impl+<'a>+A+for+&'a+I+{
++++fn+f(&self)+{
++++++++println!("A+for+&I")
++++}
}

struct+S<'a>+{
++++a:+Box<A+%2B+'a>
}

fn+main()+{
++++let+s+=+S+{
++++++++a:+box+&I
++++};
++++s.a.f();
}|150298|注意，这更通用，我们可以同时存储引用和拥有的数据(生命周期为'static的Send类型)，但是在使用该类型的任何地方都需要一个生命周期参数。|150299|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/rust-lang/rfcs/blob/master/text/0192-bounds-on-object-and-generic-types.md#lifetime-bounds-on-object-types^0|0|5|3|0|0|L|4|0|0|D|2|0|0|U|7|12|4|0^^$0|@$1|2|3|4|5|6|7|12|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|13|8|@]|9|@$D|14|E|15|1|16]]|A|$]]|$1|F|3|G|5|6|7|17|8|@$D|18|E|19|H|I]]|9|@]|A|$]]|$1|J|3|K|5|L|7|1A|8|@]|9|@]|A|$M|N]]|$1|O|3|P|5|6|7|1B|8|@$D|1C|E|1D|H|I]]|9|@]|A|$]]|$1|Q|3|R|5|L|7|1E|8|@]|9|@]|A|$M|N]]|$1|S|3|T|5|6|7|1F|8|@$D|1G|E|1H|H|I]|$D|1I|E|1J|H|I]]|9|@]|A|$]]|$1|U|3|-4|5|6|7|1K|8|@]|9|@]|A|$]]]|V|$W|$5|X|Y|Z|A|$10|11]]]]

The problem here is that a trait can be implemented for references too, so if you don't specify the required lifetime for Box anything could be stored in there.

You can see about lifetime requirements in this <a href="https://github.com/rust-lang/rfcs/blob/master/text/0192-bounds-on-object-and-generic-types.md#lifetime-bounds-on-object-types" rel="noreferrer">rfc</a>.

So one possible solution is to bind the lifetime so <code>Send</code> (we put I in S):

<pre><code>trait A {
 fn f(&amp;self);
}

struct I;

impl A for I {
 fn f(&amp;self) {
 println!("A for I")
 }
}

struct S {
 a: Box&lt;A + Send&gt;
}

fn main() {
 let s = S {
 a: box I
 };
 s.a.f();
}
</code></pre>

The other is setting the lifetime to <code>'a</code> (we can put a reference &amp;I or I to S):

<pre><code>trait A {
 fn f(&amp;self);
}

struct I;

impl A for I {
 fn f(&amp;self) {
 println!("A for I")
 }
}

impl &lt;'a&gt; A for &amp;'a I {
 fn f(&amp;self) {
 println!("A for &amp;I")
 }
}

struct S&lt;'a&gt; {
 a: Box&lt;A + 'a&gt;
}

fn main() {
 let s = S {
 a: box &amp;I
 };
 s.a.f();
}
</code></pre>

Note that this is more general and we can store both references and owned data (<code>Send</code> kind that has a lifetime of <code>'static</code>) but you require a lifetime parameter everywhere the type is used.

blocks|key|150306|text|(有点老生常谈：A是一个特征，所以S并不拥有A的实例，而是拥有实现A的某种类型的盒装实例。)|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|150307|特征对象表示具有某种未知类型的数据，也就是说，关于数据的唯一已知的事情就是它实现了特征A。由于类型未知，编译器无法直接推断所包含数据的生存期，因此要求此信息在特征对象类型中显式声明。|150308|这是通过Trait%2B'lifetime完成的。最简单的方法是只使用'static，也就是说，完全不允许存储由于作用域而变得无效的数据：|150309|a:+Box<A+%2B+'static>|code-block|syntax|javascript|150310|以前(在引入生命周期受限的特征对象的可能性和这个explicit+lifetime+bound+required错误消息之前)，所有装箱的特征对象都是隐式'static的，也就是说，这种受限形式是惟一的选择。|150311|最灵活的形式是将生命周期暴露在外部：|150312|struct+S<'x>+{
++++a:+Box<A+%2B+'x>
}|150313|这允许S存储实现A的任何类型的特征对象，可能对S有效的作用域有一些限制(例如，对于'x小于'static的类型，S对象将被捕获在某个堆栈帧中)。|150314|entityMap^0|8|1|H|1|M|1|X|1|0|17|1|0|4|F|X|7|0|0|O|W|25|7|0|0|0|3|1|8|1|N|1|15|2|19|7|1K|1|0^^$0|@$1|2|3|4|5|6|7|Y|8|@$9|Z|A|10|B|C]|$9|11|A|12|B|C]|$9|13|A|14|B|C]|$9|15|A|16|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|17|8|@$9|18|A|19|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|1A|8|@$9|1B|A|1C|B|C]|$9|1D|A|1E|B|C]]|D|@]|E|$]]|$1|J|3|K|5|L|7|1F|8|@]|D|@]|E|$M|N]]|$1|O|3|P|5|6|7|1G|8|@$9|1H|A|1I|B|C]|$9|1J|A|1K|B|C]]|D|@]|E|$]]|$1|Q|3|R|5|6|7|1L|8|@]|D|@]|E|$]]|$1|S|3|T|5|L|7|1M|8|@]|D|@]|E|$M|N]]|$1|U|3|V|5|6|7|1N|8|@$9|1O|A|1P|B|C]|$9|1Q|A|1R|B|C]|$9|1S|A|1T|B|C]|$9|1U|A|1V|B|C]|$9|1W|A|1X|B|C]|$9|1Y|A|1Z|B|C]]|D|@]|E|$]]|$1|W|3|-4|5|6|7|20|8|@]|D|@]|E|$]]]|X|$]]

(Slightly pedantic point: that <code>A</code> is a trait, so <code>S</code> is not owning an instance of <code>A</code>, it is owning an boxed instance of some type that implements <code>A</code>.)

A trait object represents data with some unknown type, that is, the only thing known about the data is that it implements the trait <code>A</code>. Because the type is not known, the compiler cannot directly reason about the lifetime of the contained data, and so requires that this information is explicitly stated in the trait object type.

This is done via <code>Trait+'lifetime</code>. The easiest route is to just use <code>'static</code>, that is, completely disallow storing data that can become invalid due to scopes:

<pre><code>a: Box&lt;A + 'static&gt;
</code></pre>

Previously, (before the possibility of lifetime-bounded trait objects and this <code>explicit lifetime bound required</code> error message was introduced) all boxed trait objects were implicitly <code>'static</code>, that is, this restricted form was the only choice.

The most flexible form is exposing the lifetime externally:

<pre><code>struct S&lt;'x&gt; {
 a: Box&lt;A + 'x&gt;
}
</code></pre>

This allows <code>S</code> to store a trait object of any type that implements <code>A</code>, possibly with some restrictions on the scopes in which the <code>S</code> is valid (i.e. for types for which <code>'x</code> is less than <code>'static</code> the <code>S</code> object will be trapped within some stack frame).

<blockquote>
 Editor's note: This code no longer produces the same error after <a href="https://github.com/rust-lang/rfcs/blob/master/text/0599-default-object-bound.md" rel="nofollow noreferrer">RFC 599</a> was implemented, but the concepts discussed in the answers are still valid.
</blockquote>

I'm trying to compile this code:

<pre><code>trait A {
 fn f(&amp;self);
}

struct S {
 a: Box&lt;A&gt;,
}
</code></pre>

and I'm getting this error:

<pre class="lang-none prettyprint-override"><code>a.rs:6:13: 6:14 error: explicit lifetime bound required
a.rs:6 a: Box&lt;A&gt;,
</code></pre>

I want <code>S.a</code> to own an instance of <code>A</code>, and don't see how that lifetime is appropriate here. What do I need to do to make the compiler happy?

My Rust version:

<pre class="lang-none prettyprint-override"><code>rustc --version
rustc 0.12.0-pre-nightly (79a5448f4 2014-09-13 20:36:02 +0000)
</code></pre>

Why "explicit lifetime bound required" for Box<T> in struct?

编译器

编者注:在实现之后，此代码不再生成相同的错误，但答案中讨论的概念仍然有效。我正在尝试编译这段代码：trait A { fn f(&self);}struct S { a: Box<A>,}我得到了这个错误：a.rs:6:13: 6:14 error: explicit lifetime bound requ...

问为什么结构中的Box<T>需要“显式生命周期限制”？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问为什么结构中的Box<T>需要“显式生命周期限制”？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问为什么结构中的Box<T>需要“显式生命周期限制”？
EN