对关联类型使用高阶生存期界限
关联类型是指在类型中引用其他类型的方式。高阶生存期界限是一种用于指定关联类型生命周期的语法。它允许我们在关联类型中使用生命周期参数，并将其限定为特定的生命周期。
在Rust编程语言中，关联类型是通过trait关键字定义的。trait是一种定义共享行为的方式，它可以包含关联类型和函数签名。关联类型允许我们在trait中使用未知的具体类型，而不是事先指定。
高阶生存期界限是一种语法，用于在trait中指定关联类型的生命周期。它的语法形式为'a: 'b，其中'a和'b是生命周期参数。这表示'a的生命周期必须至少与'b一样长，或者更长。
使用高阶生存期界限可以确保在实现trait时，关联类型的生命周期满足特定的要求。这对于需要在trait中使用引用的情况非常有用，因为引用的生命周期必须与其引用的值的生命周期相匹配。
关联类型和高阶生存期界限的优势在于提供了更灵活的类型约束和更强大的抽象能力。它们允许我们在trait中使用未知的具体类型，并对其进行更精确的生命周期约束。这样可以提高代码的可读性、可维护性和安全性。
关联类型和高阶生存期界限在很多场景下都有广泛的应用。例如，在实现迭代器模式时，可以使用关联类型来指定迭代器返回的元素类型。在实现异步编程时，可以使用高阶生存期界限来确保异步任务的生命周期正确管理。
腾讯云提供了一系列与云计算相关的产品，包括云服务器、云数据库、云存储等。这些产品可以帮助用户快速搭建和管理云计算环境，提供高可用性、可扩展性和安全性的解决方案。
以下是腾讯云相关产品和产品介绍链接地址：
- 云服务器（CVM）：提供弹性计算能力，支持多种操作系统和应用场景。详情请参考：https://cloud.tencent.com/product/cvm
- 云数据库（CDB）：提供高性能、可扩展的数据库服务，支持关系型数据库和NoSQL数据库。详情请参考：https://cloud.tencent.com/product/cdb
- 云存储（COS）：提供安全可靠的对象存储服务，适用于存储和管理大量的非结构化数据。详情请参考：https://cloud.tencent.com/product/cos
请注意，以上链接仅供参考，具体产品选择应根据实际需求进行评估和决策。
相关·内容
对于上下文:我正在实现一个实体，基本上是一个围绕异构映射的薄包装器，并试图实现一个update方法：
struct Entity {
pub id: u64,
data: HashMap<TypeId, Box<dyn Any>>,
}
impl Entity {
pub fn new(id: u64) -> Self {
Entity { id, data: HashMap::new() }
}
pub fn get_atom<T: Any>(&self) -> Option
浏览 12提问于2022-04-25得票数 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
回答已采纳
3回答
我正试图把我的头绕着生锈的一生(因为官方指南并没有很好地解释它们)。
生锈寿命仅指引用，还是也可以引用基/原始值？
浏览 5提问于2014-12-15得票数 5
回答已采纳
我有一个特性Foo继承自另一个特性Bar。Bar具有关联的Baz类型。Foo约束Baz，因此Baz必须实现Hoge。
trait Hoge {}
trait Bar {
type Baz;
}
trait Foo: Bar where Self::Baz: Hoge {}
但是，当我定义一个需要泛型类型T来实现Foo的泛型函数时，
// [DESIRED CODE]
fn fizz<T: Foo>(buzz: T) {
// ...
}
rustc向EO277抱怨，除非我显式地约束T：
fn fizz<T: Foo>(buzz: T) where T
浏览 3提问于2016-06-02得票数 14
回答已采纳
1回答
以下代码
struct Cat<'a, T> {
coolness: &'a T,
}
抱怨说
error[E0309]: the parameter type `T` may not live long enough
--> src/main.rs:2:5
|
1 | struct Cat<'a, T> {
| - help: consider adding an explicit lifetime bound `T: 'a`...
2 | coolness: &am
浏览 0提问于2018-03-04得票数 2
回答已采纳
我已经删除了所有额外的无关代码，以找到这个干净的代码来重现我所得到的错误：
trait EventsHandler{}
struct Engine{}
struct Request{}
struct RequestHandler<'a> {
r: &'a mut Request
}
impl<'a> EventsHandler for RequestHandler<'a>{}
impl Engine {
pub fn exec(&mut self, script: &str, hand
浏览 8提问于2022-01-14得票数 4
回答已采纳
这类似于，但我对解决方案的解释似乎行不通。我最初的简化测试用例是：
use std::fmt::Debug;
use std::thread;
trait HasFeet: Debug + Send + Sync + Clone {}
#[derive(Debug, Clone)]
struct Person;
impl HasFeet for Person {}
#[derive(Debug, Copy, Clone)]
struct Cordwainer<A: HasFeet> {
shoes_for: A,
}
impl<A: HasFeet>
浏览 1提问于2015-08-18得票数 9
回答已采纳
2回答
什么是推动特质+‘生命’
、、、、
我正在读。在中有一个代码片段，它的语法我不熟悉：
fn foo_expanded<'a>(x: &'a u8) -> impl Future<Output = u8> + 'a {
async move { *x }
}
在impl Future<Output = u8> + 'a，impl Trait + 'lifetime在这里是什么？
更新:我更多的是问它是什么，而不是终身逻辑解释。官方文档的定义将是非常感谢的。
浏览 13提问于2022-06-30得票数 2
回答已采纳
我试图编写一个构造函数，它使用一个泛型值，通过参数实现某些特性，然后将其装箱(重点是用这些框初始化一些东西，但下面的示例是简化的)：
struct Struct {}
trait Trait {}
impl Trait for Struct {}
fn f(arg: impl Trait) -> Box<dyn Trait> {
Box::new(arg)
}
fn main() {
let x = Struct {};
f(x);
}
在这里，编译器抱怨arg可能活得不够长。这对我来说非常有意义，因为对arg的唯一要求是impl Trait，
浏览 0提问于2021-06-10得票数 5
回答已采纳
concatenator_using函数生成可用于在fold函数中连接字符串的闭包。我已经让它工作了，但是我不明白为什么闭包返回类型需要String + '_而不仅仅是String。实际上，我不明白'_是什么意思或者是指什么。将其替换为'a会导致undeclared lifetime编译错误。
fn main() {
assert_eq!("d|e|f", vec!["d", "e", "f"].iter().fold(String::new(), concatenator_using("|
浏览 10提问于2020-03-15得票数 1
回答已采纳
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
回答已采纳
我需要将fn(I) -> O ( I & O可以作为引用)存储在'static结构中。O需要是一个具有'static泛型关联类型的特征，该关联类型也存储在结构中。I和O本身都不会存储在结构中，所以它们的生命周期不重要。但编译器仍在抱怨I的寿命不够长。
trait IntoState {
type State: 'static;
fn into_state(self) -> Self::State;
}
impl IntoState for &str {
type State = String;
fn in
浏览 2提问于2019-06-17得票数 8
回答已采纳
2回答
高阶函数的计算复杂性？
、、、
映射和过滤器似乎是线性的O(n)，因为它们只需要遍历一次列表，但是它们的复杂性是否受到传递的函数的影响？例如，下面的两个例子是相同顺序的吗？
map (+) list
map (complex_function) list
浏览 5提问于2015-05-24得票数 4
回答已采纳
2回答
我有以下代码：
class D;
class E;
#include "B.h"
#include "C.h"
#include "F.h"
#include "G.h"
#include <vector>
class A: public G {
B b;
std::vector<C> cs;
D* d;
std::vector<E*> es;
std::vector<F*> fs;
public:
A() { fs.pu
浏览 3提问于2015-12-22得票数 2
回答已采纳
2回答
考虑以下代码：
struct foo
{
foo(foo const&) = default; // To make sure it exists
};
foo& get_local_foo_reference()
{
foo my_local_foo;
return my_local_foo; // Return a reference to a local variable
}
int main()
{
foo my_foo = get_local_foo_reference();
}
现在，每个人都会同意，返回对局部变量的引用是不好
浏览 0提问于2018-06-07得票数 5
回答已采纳
我正在尝试创建一个结构来管理Tokio任务，其中一个tokio::sync::mpsc::Sender向任务发送输入，一个tokio::sync::mpsc::Receiver接收来自任务的输出，还有一个句柄，我可以在最后加入。
use tokio::sync::mpsc;
use tokio::task::JoinHandle;
// A type that implements BlockFunctionality consumes instances of T and
// produces either Ok(Some(U)) if an output is ready, Ok(No
浏览 3提问于2020-10-25得票数 1
回答已采纳
考虑以下结构：
struct Promise1<T, Err> {
on_resolve:Option<|promised:T|: Send>,
on_reject:Option<|failed:Err|: Send>,
}
struct Promise2<T, Err> {
on_resolve:Option<|promised:T|: 'static>,
on_reject:Option<|failed:Err|: 'static>,
}
struct Promise
浏览 5提问于2014-11-06得票数 3
回答已采纳
1回答
这是一个非常简单的示例，说明了我遇到的问题，但考虑到实现trait Thing的Ord和实现Thing的struct Object，我有以下结构：
pub struct MyStruct<'a> {
my_things: HashMap<i32, Vec<Box<dyn Thing + 'a>>>
}
impl<'a> MyStruct<'a> {
pub fn new() -> MyStruct<'a> {
MyStruct {
浏览 4提问于2021-02-06得票数 3
回答已采纳
我有下面的struct
struct PeekableRead<'a, R: Read> {
reader: &'a mut R,
peeked_octet: Option<u8>,
}
rustc不喜欢的：
…:27:1: 30:2 error: the parameter type `R` may not live long enough [E0309]
…:27 struct PeekableRead<'a, R: Read> {
…:28 reader: &'a mut R,
…:
浏览 2提问于2016-04-09得票数 4
2回答
在处理锈病生存期时，我看到的典型示例如下：
pub fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
if x.len() > y.len() {
x
} else {
y
}
}
有趣的是，这似乎转化为“longest()的结果的生存期是它的输入参数的最短寿命”。这个逻辑对我来说是有意义的，但我不明白这是如何通过语法传达的。
当我查看这个函数时，它看起来好像只有一个生存期'a，而这个函数似乎强制要求x和y必须具
浏览 3提问于2021-07-01得票数 3
回答已采纳
我有一个具有“部分”生存期的枚举:它的一个变体包含借用值，另一个包含拥有值。我有一个函数，它总是返回一个带有owning变量的枚举。为了让编译器满意，我必须声明返回的枚举的生存期是'static。 我的问题是关于返回枚举的真实生命周期： 通过声明生命周期为'static，我是在引导编译器这个枚举没有关联的生命周期，还是实际上将该实例转换为静态实例？ pub enum Sometimes<'a> {
Own(u16),
Borrow(&'a mut u16),
}
impl<'a> Sometimes&l
浏览 13提问于2019-05-18得票数 1
回答已采纳
2回答
我有一个方法，它接受一些参数，从它们创建(解密)一个中间值，并尝试从这个中间值构造一个类型实例。只要类型是固定的，就可以正常工作。如果我想通过泛型支持多种类型，我就会遇到麻烦。下面是精简的代码：
impl Factory
{
pub fn get<'a, T>(&'a self, value: &'a str) -> T
where T: From<&'a str>
{
let value_parsed = value.chars().rev().collect
浏览 11提问于2022-05-02得票数 0
回答已采纳
1回答
在铁锈里的这一生对我来说仍然是黑暗的魔法。我对它的工作原理有一个大致的了解，但每当我不得不自己定义生命周期时，我就很难弄清楚该做什么。我想做的是：
我有一个来自子模块的[&str, 100]，我想编写一个非常简单的随机迭代器，它使用来自这个子模块的数据。以下是我所做的大致工作：
use rand::distributions::{Distribution, Uniform};
use super::data:Data;
struct RandomData {
range: Uniform<usize>,
rng: rand::rngs::ThreadRng,
}
浏览 0提问于2019-12-05得票数 0
1回答
我试图传递一个异步函数作为参数。异步函数接受引用，因为它有争议。
use std::future::Future;
async fn f(x: &i32) -> i32 {
todo!()
}
async fn g<F, Fut>(f: F)
where
F: Send + Sync + 'static + for<'a> Fn(&'a i32) -> Fut,
Fut: Future<Output = i32> + Send + Sync,
{
// let x = 3;
浏览 4提问于2021-12-28得票数 3
回答已采纳
3回答
我有这个特点和简单的结构：
use std::path::{Path, PathBuf};
trait Foo {
type Item: AsRef<Path>;
type Iter: Iterator<Item = Self::Item>;
fn get(&self) -> Self::Iter;
}
struct Bar {
v: Vec<PathBuf>,
}
我想为Bar实现Foo特征
impl Foo for Bar {
type Item = PathBuf;
type Iter
浏览 2提问于2015-11-16得票数 48
回答已采纳
我好像不懂“锈”里的借贷概念。我有一个简单的例子：
pub struct User {
name: Option<String>,
}
impl User {
pub fn new() -> Self {
Self {
name: Some("".to_string()),
}
}
pub fn write_name(&mut self) -> Result<(), &str> {
let name = self.gen
浏览 2提问于2020-04-06得票数 0
回答已采纳
我对下面的类型检查器的严格性感到有点困惑-似乎Inv[T]的不变T位置在Variantish的参数列表中也是不变的：
scala> class Inv[T]
defined class Inv
scala> class Variantish[+T, +TVar <: Inv[T]]
<console>:12: error: covariant type T occurs in invariant position in type <: Inv[T] of type TVar
class Variantish[+T, +TVar <:
浏览 4提问于2017-04-06得票数 5
Gamma等人的设计模式
考虑一下对象聚合和熟识之间的区别，以及它们在编译和运行时表现出的不同。
聚合意味着一个对象拥有另一个对象或负责另一个对象。一般来说，我们指的是一个拥有另一个物体或作为另一个物体的一部分的物体。聚合意味着聚合对象及其所有者具有相同的生存期。
熟人意味着一个对象仅仅知道另一个对象。有时熟人被称为“交往”或“使用”关系。熟悉的对象可能请求彼此的操作，但它们之间不相互负责。熟人是一种弱于聚合的关系，它暗示对象之间的耦合要松散得多。
另一件有用的事情是，哪些类实例化了其他类。我们称之为“创造”关系。箭头指向实例化的类。在图c中，
多个对象可以聚合相同的对象吗？如果对象
浏览 0提问于2019-06-06得票数 0
我想要创建一个指向类方法的全局函数指针，因此我执行了如下最小可复制示例的操作：
struct Foo<'a> {
data: &'a str,
}
impl<'a> Foo<'a> {
pub fn foo(&self) {
println!("{}", self.data);
}
}
type FooFn = fn(&Foo);
const FUNC: FooFn = Foo::foo;
fn main() {
let data
浏览 0提问于2022-05-09得票数 5
回答已采纳
我不明白为什么在借款人的范围结束后，可变的借入变量仍然被借用。它似乎与特性使用有关，但我不明白为什么：
fn main() {
let mut a = 10;
test::<FooS>(&mut a);
println!("out {:?}", a)
}
trait Foo<'a> {
fn new(data: &'a mut u32) -> Self;
fn apply(&mut self);
}
struct FooS<'a> {
d
浏览 3提问于2016-08-02得票数 10
回答已采纳
我正在为不同的键值存储编写一组基准测试，并且希望有一个我可以在所有基准测试中使用的适配器特性，然后为每个键值存储实现它。
对他们中的两个人来说效果很好。然而，第三项要求我在我的特质上增加一个一生，并且在与借入检查进行了一整天的斗争之后，我似乎仍然不能正确地完成它。
我已经把它提炼成了一个最小的复制：
我不明白的是，为什么在txn上借入的时间超过了benchmark()的范围。在我看来，它应该只活在这一行。
我如何定义AdapterTransaction特性来解决这个问题，它仍然允许实现选择自己的返回类型？
编辑
补充说，我需要能够使用具有工厂特性的AdapterTransaction实现。
浏览 3提问于2021-07-08得票数 0
回答已采纳
我相信这个函数声明告诉Rust，函数输出的生存期与它的s参数的生存期相同：
fn substr<'a>(s: &'a str, until: u32) -> &'a str;
^^^^
在我看来，编译器只需要知道以下(1)：
fn substr(s: &'a str, until: u32) -> &'a str;
函数名称后面的注释<'a>是什么意思？为什么编译器需要它，它用它做什么？
(1)我知道它需要知道的更少，因为它的一生的省略。但这个问题是关于显式地
浏览 1提问于2015-04-24得票数 24
回答已采纳
我试图了解类型约束是如何与关联类型交互的，我偶然发现了这个我不理解的例子。我已经阅读了泛型impl中关于无约束类型的RFC，但我看不出这如何符合不允许的内容列表。直观地说，我希望对于实现Baz<T>的任何类型，这段代码都会精确地指定一个明确的impl of Foo。我是不是弄错了，或者编译器就不能实现逻辑的飞跃？若否，原因为何？
trait Foo {
type Bar;
fn foo(&self) -> Self::Bar;
}
trait Baz<T> {
fn foo(&self) -> T;
}
impl&
浏览 6提问于2022-06-23得票数 2
回答已采纳
2回答
我有一个火箭()路由，它返回一个content::Json<String>，我想使用 (来自主)向该路由添加CORS。
具体来说，我想使用，因为我只想为某些路由启用CORS。
我最初的请求如下：
#[get("/json")]
fn json_without_cors() -> content::Json<String> {
let test = Test {
field1: 0,
field2: String::from("Test"),
};
let json = serd
浏览 1提问于2021-06-30得票数 2
回答已采纳
1回答
我已经阅读了有生之年，并明白每一个单一变量绑定都有一个生命周期。然而，似乎我想不出有一段时间您实际上需要使用它们，考虑到编译器在必要时在推断它们方面做了相当大的工作。
锈书，我读过了。我想要一个简单易懂的例子，即使是像我这样的人！
浏览 1提问于2017-01-14得票数 5
回答已采纳
我正在尝试创建一个在slice以及VecDeque、BTreeMap和HashMap中捕获iter函数的特征。我希望这个特征的实现者能够指定和实现他们自己的迭代器类型，但是看起来这个迭代器类型必须有一个生命周期参数，并且不能作为关联类型给出。 更详细地说，下面是我希望在Rust中可以实现的东西： trait RefIterable<T>
where for<'a> (T: 'a) => (Self::Iter<'a>: Iterator<Item = &'a T>)
{
type Iter; /
浏览 6提问于2021-01-21得票数 5
回答已采纳
1回答
考虑以下玩具示例：
use std::cmp::Ordering;
pub trait SimpleOrder {
fn key(&self) -> u32;
}
impl PartialOrd for dyn SimpleOrder {
fn partial_cmp(&self, other: &dyn SimpleOrder) -> Option<Ordering> {
Some(self.cmp(other))
}
}
impl Ord for dyn SimpleOrder {
fn
浏览 2提问于2019-01-23得票数 20
回答已采纳
这个问题是在Rust中通用关联类型可用之前提出的，尽管它们是和。
我的理解是，特征泛型和关联类型在它们可以绑定到结构的类型的数量上有所不同。
Generics可以绑定任意数量的类型：
struct Struct;
trait Generic<G> {
fn generic(&self, generic: G);
}
impl<G> Generic<G> for Struct {
fn generic(&self, _: G) {}
}
fn main() {
Struct.generic(1);
Stru
浏览 0提问于2019-02-20得票数 10
回答已采纳
1回答
我有一个简单的例子：
fn make_string<'a>() -> &'a str {
let s : &'static str = "test";
s
}
fn make_str<'a>() -> &'a str {
let s : String = String::from_str("test");
s.as_slice()
}
fn main() {
println!("{}", make_str
浏览 4提问于2014-12-03得票数 0
回答已采纳
为什么这段代码要编译？
#[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
回答已采纳
1回答
我阅读了，并对常量字符串/字符串文本的生存期提出了一些问题。
当我编写以下代码时，会得到一个错误：
fn get_str() -> &str {
"Hello World"
}
错误：
error[E0106]: missing lifetime specifier
--> src/main.rs:1:17
|
1 | fn get_str() -> &str {
| ^ expected lifetime parameter
|
= help: this function's
浏览 1提问于2015-07-05得票数 9
回答已采纳
2回答
我有一个，它目前没有编译，有以下错误：
error[E0597]: `line` does not live long enough
--> src/main.rs:19:20
|
19 | let line = line.trim();
| ^^^^-------
| |
| borrowed value does not live long enough
| argument requ
浏览 2提问于2020-10-12得票数 4
回答已采纳
关于下列代码：
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 <iostream>
template<typename Derived>
class VecExp {
public:
double operator[](int i) const {return static_cast<Derived const&>(*this)[i];}
};
template<int n>
class Vector : public VecExp<Vector<n>> {
pub
浏览 3提问于2021-02-08得票数 1
回答已采纳
1回答
我需要一个特征，它允许我构造一个借用对象的对象，而这个对象又借用了一些东西。在下面的示例中，它是PaperBin。
trait GarbageBin<'a,'b>{
fn new(rubbish: &'b Paper<'a>) -> Self;
}
struct PaperBin<'a,'b> {
rubbish: &'b Paper<'a>
}
struct Paper<'a> {
matter: &'
浏览 19提问于2021-06-15得票数 0
回答已采纳
我得到了以下代码分析错误: of 1823:AvoidUnusedPrivateField，用于这一行代码：
private static Timer _timer;
在我的类的构造函数中，我有以下内容：
_timer = new Timer(OnTimerElapsed, _autoResetEvent, 1000, 1000);
我不需要在计时器上调用任何方法；只需实例化就够了。这就是我收到CA警告的原因吗？这是我真的需要抑制错误的情况，还是我遗漏了什么？
顺便提一句，我没有收到一个应该在计时器上调用side ()的错误。我不应该得到那个错误吗？
--编辑--
如果我使_timer成为一个
浏览 0提问于2012-07-25得票数 2
回答已采纳
下面的代码运行得很好：
use std::iter::Peekable;
use std::slice::Iter;
fn has_next(iter: &mut Peekable<Iter<usize>>) -> bool {
match iter.peek() {
Some(_) => true,
None => false,
}
}
fn print_iters(iters: &mut Vec<Peekable<Iter<usize>>>) {
浏览 2提问于2017-07-10得票数 0
回答已采纳
我在玩弄树木和特质，遇到了一种我不明白的行为。下面是一个最小的(不编译)示例：
trait Trait<T> {}
struct Struct<T> {
option: Option<Box<dyn Trait<T>>>, // change this to Option<Box<TestStruct<T>>>
// and it works without issues
}
impl<T> Trait
浏览 1提问于2022-10-18得票数 2
回答已采纳
1回答
我读了的源代码，发现了
pub fn put<T>(uri: T) -> Builder
where
Uri: TryFrom<T>,
<Uri as TryFrom<T>>::Error: Into<crate::Error>,
{
Builder::new().method(Method::PUT).uri(uri)
}
在这个片段中，Uri是类型，T是泛型元素。我一直都看到建筑where T: SomeTrait，但没有看到SomeType: SomeTrait<T>。这个建筑
浏览 2提问于2020-05-02得票数 0
回答已采纳
我试图编写一个函数，返回一个带框的闭包，该闭包可以用于对具有任何生存期的类型的引用。在编写特定实例时，一切都正常。但在编写通用版本时，我遇到了终生的问题。
struct Parameter<'a> {
s: &'a str,
}
fn main() {
let closure = generate_closure_gen();
let string = String::from("Hello World!");
let parameter = Parameter { s: &string }; //
浏览 2提问于2016-03-01得票数 9
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
腾讯会议
实时音视频活动推荐
腾讯云开发者
