1回答
汇编如下：
namespace platform {
struct event {};
struct keyboard_event : public event {};
const platform::event& wait_event()
{
return platform::keyboard_event();
}
}
int main(int argc, const char* argv[])
{
const platform::event& event = platform::wait_event();
return 0;
}
使
浏览 2提问于2017-02-19得票数 0
回答已采纳
我正在尝试运行以下代码。很容易理解，inner()的返回值的生存期与'static的生存期不兼容，但是如何在不更改main()函数的情况下实现这一点呢？
struct Wrapper<'a>(&'a str);
impl<'a> Wrapper<'a> {
fn inner(&self) -> &str {
self.0
}
}
pub fn main() {
let x = "hello";
let wrapper =
浏览 0提问于2018-02-17得票数 1
1回答
我有一个简单的功能，我想使之成为通用的，生锈的。我犯了一辈子的错误。我仍然掌握着生锈这一生的诀窍。
函数简单地使用serde的序列化将1个结构转换为另一个结构。
下面是一个包含完整简单场景的。
代码：
pub fn convert<'de: 'a, 'a, T>(from: &'a Left, print: bool) -> (T, &'a Left)
where
T: Deserialize<'de> + std::fmt::Debug {
let serialized = ser
浏览 5提问于2020-02-08得票数 3
回答已采纳
因此，我的问题是：“标题”以及SystemVerilog中动态数组的垃圾收集规则是什么？
上下文：
在我的程序中，我发现了一个bug，您可以在函数中实例化动态数组(本地)并在该函数中向该数组添加元素，但是如果不删除该数组，则条目将保留在那里(即内存和引用被保留)。因此，当您再次调用该函数时，可以访问以前输入的所有条目。解决方案是在退出函数之前简单地删除动态数组。我假设数组没有被删除，因为数组是在堆上实例化的，而不是堆栈，编译器不知道什么时候垃圾收集它，因为它可能是一个返回的引用(如果我错了，请纠正我--我不熟悉动态数组的垃圾收集规则)。
但是，如果动态数组在类内实例化(作为成员变量)，会发生什
浏览 5提问于2020-07-23得票数 1
回答已采纳
我在Rust中遇到了许多用单个撇号表示的类型：
'static
'r
'a
那个撇号的意义是什么？也许它是引用的修饰语(&)？泛型类型是否特定于引用？我不知道这方面的文档藏在哪里。
浏览 3提问于2014-02-27得票数 123
回答已采纳
我有一些困难，让工作的流媒体输入从车上的相机。我使用的是XCode 7.1.1和iPhone 5S。下面是我的初始化代码：
let detector = AFDXDetector.init(delegate: self, usingCamera: AFDX_CAMERA_FRONT, maximumFaces: 1)
detector.setDetectAllEmotions(true)
detector.setDetectAllExpressions(true)
detector.maxProcessRate = 5.0
detector.licensePath = NSBundle.mai
浏览 2提问于2015-11-21得票数 1
回答已采纳
1回答
我已经阅读了有生之年，并明白每一个单一变量绑定都有一个生命周期。然而，似乎我想不出有一段时间您实际上需要使用它们，考虑到编译器在必要时在推断它们方面做了相当大的工作。
锈书，我读过了。我想要一个简单易懂的例子，即使是像我这样的人！
浏览 1提问于2017-01-14得票数 5
回答已采纳
为什么这段代码要编译？
#[derive(Debug)]
pub struct Foo<'a> {
pub x: &'a [&'a str],
}
fn main() {
let s = "s".to_string();
let t: &str = s.as_ref();
{
let v = vec![t];
let foo = Foo { x: &v[..] };
println!("{:?}", &fo
浏览 3提问于2016-04-12得票数 1
回答已采纳
我仍然不明白'static的行为。在以下代码中，say_foo工作，但say_bar不工作：
fn say_foo(_: &String) -> &str {
"foo!"
}
fn say_bar(_: &'static String) -> &str {
"bar!"
}
fn main() {
let f = "f".to_string();
let f2 = say_foo(&f); // ok:)
println!("{
浏览 2提问于2017-03-10得票数 2
回答已采纳
在带有表达式的node.js中，我想定义一个页脚，例如(在layout.jade中)
footer
p © Me 2015 - Your IP: #{currentIP}
在app.js中，我有：
app.locals.currentIP = function(req) {
return req.ip;
}
当运行时，我得到以下错误：
> 29| block content 30| footer
> > 31| p © Me 2015 - Your IP: #{currentIP()}
浏览 3提问于2015-08-05得票数 0
回答已采纳
我正在使用来制作一个web服务器，并试图为Responder特性做一个包装器，这样我的路由方法就可以返回任何结构。
下面的代码没有编译，因为我不完全理解关于生命周期的错误。错误是；它从E0492跳到E0496。
因为这段代码使用Rocket，所以它需要夜间编译器。
main.rs
#![feature(custom_attribute, proc_macro_hygiene, decl_macro)]
#[macro_use]
extern crate rocket;
extern crate rocket_contrib;
use rocket::{http::Status, respon
浏览 1提问于2018-12-10得票数 3
代码如下： fn inner<'a:'b, 'b>(x:&'a i32, _y:&'b i32) -> &'b i32 {
x
}
fn main() {
let a = 1;
{
let b = 2;
inner(&b, &a);
inner(&a, &b);
}
} 函数inner中的绑定'a:'b意味着'a的生命周期比'b长。在上面的例子中，变量b的生命周期比a短。遇到inne
浏览 9提问于2021-03-31得票数 5
回答已采纳
2回答
Rust 声明注释不会篡改变量的生存期，但这有多真实呢？根据本书，函数接受字符串的两个引用，并返回较长的字符串。但在错误的情况下
fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
if x.len() > y.len() {
x
} else {
y
}
}
fn main() {
let string1 = String::from("long string is long");
浏览 0提问于2019-03-14得票数 5
回答已采纳
4回答
我有两个类型为&T、x和y的变量，在函数中本地交换：
pub fn foo<T: Copy>(mut x: &T) {
let y_owned = *x;
let mut y = &y_owned;
for _ in 0..10 {
do_work(x, y);
std::mem::swap(&mut x, &mut y);
}
}
fn do_work<T>(_x: &T, _y: &T) {}
此代码无法编译，从而产生以下错误：
error[E0
浏览 0提问于2018-12-18得票数 7
回答已采纳
我对QLoggingCategory(const char * category)有个问题。
当我像这样使用它时：
QString rt = "3";
QString sv = "P";
QLoggingCategory dailyLogger(QString(rt+sv+"Logger").toStdString().c_str());
它无法工作(我的自定义消息处理程序无法识别此类别)。
但是当我使用的时候：
QLoggingCategory dailyLogger("3PLogger");
消息处理程序会看到该类别。
下面是
浏览 3提问于2015-10-15得票数 2
试图找出如何描述这种终生的关系。
因此，假设我有一个具有生命周期参数的组件：
struct Foo<'a> { ... }
假设我想要另一个组件，它包含对Foo的引用
struct Bar<??> {
foo: &'? Foo<'?>
}
我如何表达以下几点：
--对foo的引用的生存期应该是包含foo的Bar的生存期--我不关心底层Foo的生存期，只要它比包含引用<代码>G 212</code>的Bar的生存期长
编辑：因此，如果Foo本身没有生命周期参数，我将像这样实现Bar：
struct
浏览 6提问于2022-09-15得票数 0
回答已采纳
1回答
在这里的代码中
trait Foo {
type Output;
fn foo(self) -> Self::Output;
}
impl<'a> Foo for &'a () {
type Output = &'a ();
fn foo(self) -> Self::Output {
self
}
}
fn func<F: Foo>(f: F) -> F::Output {
f.foo()
}
fn func2<'a>(f
浏览 1提问于2016-09-18得票数 3
回答已采纳
6回答
如果我这样写：
#include <iostream>
int main()
{
using namespace std;
{int n;n=5;} cout<<n;
system("pause");
return 0;
}
编译器告诉我n是未声明的。然后我尝试将它设为静态的，但是编译器再次告诉我它是未声明的。变量解密的static不是有程序作用域吗？如果没有，我该如何在这个程序中使用n呢？
浏览 2提问于2013-03-01得票数 6
回答已采纳
4回答
我是否需要将MyAction设置为null，以便垃圾收集能够继续处理这两个类中的任何一个？
当两个类的生命周期几乎相同时，我就不那么关心了。当Class1的寿命比Class2长得多，或者当Class2的寿命比Class1长得多时，我的问题就更合适了。
这里的代码是精简的。假设Class1和Class2都包含可能影响其生命周期的其他成员和方法。
public class Class1 : IDisposable
{
public Action<string> MyAction { get; set; }
// Is this necessary?
publi
浏览 1提问于2011-11-18得票数 17
回答已采纳
我对让一个静态成员弄乱我的头不感兴趣，因为它只被cpp主体中的一个自由函数使用。如果我在这里声明一个静态变量，它会像静态成员一样只占用一个地址吗？
抱歉，但在C++中对静态的大量使用让我很不确定。
我的想法大致如下：
static Osp::Base::Runtime::Monitor sharedMonitor;
浏览 2提问于2012-03-02得票数 1
给出下面的代码示例，变量currOn似乎是在循环之外启动的，并且只实例化了一次。例如，假设itemList中有三项，在第二次迭代中，SomeFunctionThatDoesSomeStuff返回true。然后，currOn的值将是true。在第三次迭代中，我认为给定的VB.NET是一种块作用域语言，currOn将被重新实例化并默认为false；然而，我看到它仍然是true，因此不管sOn的值如何，都不会在以后的迭代中得到更新。它看起来像是javascript的函数作用域，其中currOn的声明将被拉到循环之外。有人知道这是怎么回事吗？
For Each item As MyIt
浏览 2提问于2015-09-16得票数 7
回答已采纳
3回答
我有一个关于问题的答案的问题，但我不能评论它，因为我有不到50个代表。
我想知道在答案中，foo()被多次调用，静态变量被分配了相同的次数。那么，为什么静态变量不被重新分配到每次10次？
浏览 6提问于2017-03-30得票数 6
回答已采纳
2回答
循环内的变量声明
、、
For i As Integer = 1 To 10
Dim j As Integer = 10
Next
现在我的问题是，是否每次在for循环中执行j时都分配内存给它？或者在随后的迭代中只分配10的值？
浏览 0提问于2011-08-26得票数 3
回答已采纳
考虑到以下锈蚀计划：
struct Value<'v>(&'v ());
struct Container {}
impl Container {
fn get<'v>(&'v self) -> Value<'v> {
todo!()
}
fn set<'v>(&'v self, x: Value<'v>) {
todo!()
}
}
fn convert<&
浏览 2提问于2020-06-30得票数 11
回答已采纳
考虑以下方案：
fn main() {
let c; |<-'a
let mut a = "Hello, world!".to_string(); |
{ |
let b = &mut a; |<-'b |
c = foo(b); | |
浏览 2提问于2019-08-12得票数 3
回答已采纳
因此，在：
fn v1<'a> (a:~[&'a str]) -> ~[&'a str] {
return a;
}
#[test]
fn test_can_create_struct() {
let x = v1("Hello World".split(' ').collect());
}
我知道，我读过，但我不明白这段代码实际上是做什么的。
这个函数基本上是参数化的，就像一个通用的fn，但是有一个生命周期，这是我在IRC通道上看到的，但是让我们想象一下是这样的，我们有一个L，它是一些特定的生
浏览 0提问于2014-03-05得票数 6
回答已采纳
1回答
这是我的密码
extern crate postgres;
use postgres::{Connection, SslMode};
struct User {
reference: String,
email: String
}
static DB_URI: &'static str = "postgres://postgres:postgres@localhost/test";
fn main() {
let conn = Connection::connect(DB_URI, &SslMode::None).unw
浏览 3提问于2015-06-11得票数 0
回答已采纳
关于下列代码：
struct Config<'a> {
query: &'a str,
filename: &'a str,
case_sensitive: bool,
}
impl<'a> Config<'a> {
pub fn new(args: &'a [String]) -> Result<Config, &'static str> {
if args.len() < 3 {
浏览 0提问于2019-06-01得票数 0
回答已采纳
1回答
局部变量至少(且至多)存在于函数内部。但是，块外部的块作用域变量会发生什么，但它是相同的函数，我可以保留和使用它们的地址吗？此代码有效吗？
#include <stdio.h>
int main()
{
char *f;
if (1)
{
char q[] = "123";
f = q;
}
printf ("%s\n", f);
return 0;
}
事实上，gcc -ansi -pedantic和valgrind都不会抱怨它，但我可以跨平台和跨编译器使用它吗？在我看
浏览 3提问于2017-04-18得票数 4
考虑到以下条件：
/// Zero Sized Type
struct ZST;
/// What the ZST converts into
const TEXT: &str = "target text";
下面的代码片段至少在表面上做了同样的事情：
// static impl
impl From<ZST> for &'static str {
fn from(_: ZST) -> &'static str {
TEXT
}
}
// generic impl
impl<'a>
浏览 3提问于2021-10-20得票数 0
我正在编写一个混合应用程序，有几个单独的html/js将加载到不同的Android are视图中。
为了调试，我必须更改ajax请求的基本Url，因为不同的网络连接，不同的同事.
但是不同的urls在许多JS文件中。
//file1.js
baseUrl = "192.168.1.114:3000";
//file2.js
baseUrl = "192.168.1.114:3000";
//file3.js
// there are the same baseUrl;
我希望同时配置和修改所有这些字段，以便进行生产或调试。多么?有格朗特吗？还是在Ajax
浏览 0提问于2015-11-08得票数 0
回答已采纳
考虑以下代码：
trait Trait<T> {}
fn foo<'a>(_b: Box<dyn Trait<&'a usize>>) {}
fn bar(_b: Box<dyn for<'a> Trait<&'a usize>>) {}
foo和bar这两个函数似乎都接受Box<Trait<&'a usize>>，尽管foo做的比bar更简洁。他们之间有什么区别？
此外，在什么情况下我需要像上面这样的for<>
浏览 1提问于2016-02-24得票数 103
回答已采纳
4回答
如果我按照rustc告诉我的那样做，下面的错误将消失，并将绑定更改为
where F: Fn() -> () + 'static
pub struct Struct(Box<dyn Fn() -> ()>);
pub fn example<F>(f: F)
where
F: Fn() -> ()
{
Struct(Box::new(|| ())); // ok
Struct(Box::new(f)); // error: The parameter type `F` may not live long eneough
浏览 12提问于2021-12-26得票数 5
我在使用Combine模式的最简单的实现时遇到了问题，即订阅一个UITextField textDidChangeNotification。 import UIKit
import Combine
class ViewController: UIViewController {
let textField = UITextField()
override func viewDidLoad() {
super.viewDidLoad()
view.addSubview(textField)
textField.frame
浏览 124提问于2019-09-14得票数 3
回答已采纳
因此，我试图测试我是否理解生命周期，并希望创建一个在编译时失败的场景。我想出的代码如下：
#[test]
fn lifetime() {
struct Identity<'a> {
first_name: &'a str
}
let name: Identity;
{
let first: &str = "hello";
name = Identity {
first_name: first
};
浏览 3提问于2022-11-08得票数 1
回答已采纳
下面是一个代码示例，其中我测试了两个&str，并返回其中一个：
fn bad_longest(s1: &str, s2: &str) -> &str {
if s1.len() >= s2.len() { s1 } else { s2 }
}
它没有编译请求明确的生命周期，所以我提供了它们：
fn longest<'r, 'a, 'b>(s1: &'a str, s2: &'b str) -> &'r str
where
'a: 'r,
浏览 0提问于2020-08-03得票数 0
回答已采纳
我见过多个类似或的帖子，但我认为这不是重复。我想我还不太明白如何利用有生之年来超越彼此。这是一个MWE：
struct Point;
pub struct Line<'a> {
pub start: &'a Point,
pub end: &'a Point,
}
impl<'a> Line<'a> {
pub fn new(start: &Point, end: &Point) -> Self {
Line {
浏览 0提问于2017-06-23得票数 1
回答已采纳
2回答
如何释放数组中隐式分配的内存？
、、、、
对于C中的动态内存分配，可以在执行和编译程序之前释放(或释放)保留的内存。例如：
....
... = malloc(...)
...
free(...)
return 0;
但是，如果我不使用动态内存分配，它是如何工作的。例如，如果我使用int array [10000000]预留了40000000字节的空间，那么当我不需要内存时，如何在以后的程序中释放内存呢？
浏览 1提问于2020-11-18得票数 0
回答已采纳
2回答
在Rust book ()中，此代码用作示例(转译)：
fn main() {
let string1 = String::from("long string is long");
{
let string2 = String::from("xyz");
let result = longest(string1.as_str(), string2.as_str()); // line 5
println!("The longest string is {}", result);
浏览 0提问于2021-01-30得票数 1
pub struct FooStruct<'a> {
pub bars: Vec<&'a str>,
}
pub trait FooTrait<'a> {
fn getBars(&self) -> &'a Vec<&'a str>;
}
impl<'a> FooTrait<'a> for FooStruct<'a> {
fn getBars(&self) -> &'
浏览 1提问于2019-09-29得票数 2
回答已采纳
1回答
我是C++新手，出身于Java背景。我想确认以下几点：
我正在通过Ira 的剖析阅读C++，书中指出文件/extern变量/函数的生命周期是程序的持续时间(这是有意义的，因为变量不是在类中声明的)。
我想知道的是，在类中声明的变量也是这样吗？如果不是，如果在类中声明了一个变量，那么该变量是否使用auto存储类？
谢谢。
浏览 0提问于2011-01-05得票数 1
回答已采纳
此代码无法通过可怕的借用检查器()：
struct Data {
a: i32,
b: i32,
c: i32,
}
impl Data {
fn reference_to_a(&mut self) -> &i32 {
self.c = 1;
&self.a
}
fn get_b(&self) -> i32 {
self.b
}
}
fn main() {
let mut dat = Data{ a: 1, b: 2, c: 3 };
浏览 0提问于2016-12-17得票数 13
我希望将匹配中的所有命名组提取到HashMap中，在编译这段代码时遇到一个“不长寿”错误：
extern crate regex;
use std::collections::HashMap;
use regex::Regex;
pub struct Route {
regex: Regex,
}
pub struct Router<'a> {
pub namespace_seperator: &'a str,
routes: Vec<Route>,
}
impl<'a> Router<&
浏览 4提问于2016-08-27得票数 4
回答已采纳
在下面的生锈代码中，我预计对pass_through的两个调用都会失败，因为a和b都超出了内部块末尾的作用域。然而，由于某些原因，发生了以下情况：
创建对一个函数值的引用并将该引用存储在enough.Creating中的允许它长寿--一个NC值并将其存储在b中，然后对函数参数进行b引用会导致一个错误。
#[derive(Debug)]
struct NC(i32);
fn pass_through(x: &NC) -> &NC {
x
}
fn main() {
let a2: &NC;
let b2: &NC;
{
浏览 7提问于2022-05-21得票数 2
回答已采纳
1回答
我有一个泛型函数，创建一个本地对象，并接受一个特征，指定如何处理该对象。该特性接受对对象的引用，并将其保存在对象的生存期内(以避免一次又一次地将其传递给每个函数调用)。它在死亡之前
fn do_stuff<'a, T>()
where T : BigBorrower<'a>
{
let borrowee = Borrowed{ data : 1 };
{
let _borrowee = T::new(&borrowee);
}
}
这是函数调用。由于特性的生存期必须在函数declaraion中指定，这使得编译器认为_bor
浏览 0提问于2019-09-04得票数 2
回答已采纳
1回答
我正在运行一个“Foo”对象的模拟。每个Foo必须有一个随机类型t。我希望通过(静态)成员函数将随机数生成封装到类中：
#include <boost/random.hpp>
class Foo {
public:
static void set_seed(int seed);
Foo();
void print() { std::cout << t << std::endl; };
private:
double t;
static boost::mt19937 rng;
static boost::uni
浏览 3提问于2015-12-19得票数 0
我试着做一个简短的可重复的例子，但是无法重现我的问题，所以我从保留错误的主要代码中删除了大部分内容。
lib.rs
extern crate proc_macro;
use proc_macro::TokenStream;
use quote::{quote};
use syn::{
parse_macro_input, Data, DeriveInput, Field, Fields, Ident,
Type, TypeGenerics,
};
struct IterMapped<Ret, T: Iterator + Clone> {
iter: T,
浏览 2提问于2020-11-10得票数 0
考虑一下
#![feature(generic_associated_types)]
pub trait Func {
type Input<'a>;
type Output;
fn call(self, input: Self::Input<'_>) -> Self::Output;
}
fn invoke<'cx, F>(f: F, ctx: &'cx mut u8)
where F: 'static + Func<Input<'cx&
浏览 6提问于2021-12-17得票数 1
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
即时通信 IM
实时音视频活动推荐
腾讯云开发者
