Rust:泛型必须实现&xx[...]
Rust是一种系统级编程语言，注重安全性、并发性和性能。它具有静态类型检查、内存安全和零成本抽象等特性，适用于开发高性能、可靠和安全的软件。
泛型是Rust中的一个重要特性，它允许我们编写可以适用于多种类型的代码。在Rust中，泛型必须实现特定的trait（类似于接口），以确保代码的类型安全性和正确性。
&xx[...]是一个Rust中的切片（slice）类型的表达方式。切片是对数组或向量的引用，它允许我们引用集合中的一部分元素，而不需要复制整个集合。&xx[...]表示对xx数组或向量的一个切片，其中...表示切片的起始和结束位置。
Rust的泛型和切片在实际开发中有广泛的应用场景。泛型可以提高代码的重用性和灵活性，使得我们可以编写更加通用的函数和数据结构。切片则可以有效地处理大型数据集合，减少内存占用和提高性能。
在腾讯云中，与Rust相关的产品和服务包括：
- 云服务器（ECS）：提供可扩展的计算资源，用于部署和运行Rust应用程序。详情请参考：腾讯云云服务器
- 云数据库MySQL（CDB）：提供高性能、可靠的MySQL数据库服务，适用于存储和管理Rust应用程序的数据。详情请参考：腾讯云云数据库MySQL
- 云存储（COS）：提供安全可靠的对象存储服务，用于存储和管理Rust应用程序的静态文件和数据。详情请参考：腾讯云云存储
- 人工智能平台（AI Lab）：提供丰富的人工智能算法和模型，可用于开发基于Rust的人工智能应用。详情请参考：腾讯云人工智能平台
请注意，以上仅是腾讯云提供的一些与Rust相关的产品和服务，其他云计算品牌商也提供类似的产品和服务。
相关·内容
1回答
我有一个复杂的代码块，我在下面概述了一下。基本上我需要初始化一个泛型，它总是一个结构体，并且该结构体已经默认实现了，但是编译器还是会报错：
fn create<T: Default>() -> T
{
T { ..Default::default() }
}
fn main()
{
let mut x = create::<Bob>();
}
收益率：
error[E0574]: expected struct, variant or union type, found type parameter `T`
--> macro.rs:7
浏览 40提问于2017-12-28得票数 1
回答已采纳
我见过一些Rust示例中使用的关键字type，但我从来没有看到过它的解释。下面是我看过的一些使用它的例子：
impl Add<Foo> for Bar {
type Output = BarFoo;
// omitted
}
还有这个，
type T = HashMap<i32,String>; // Type arguments used in a type expression
let x = id::<i32>(10); // Type arguments used in a call expression
有人能解释一下
浏览 0提问于2015-04-04得票数 36
回答已采纳
2回答
我正在用Rust构建一个webapp，并试图实现基本的Rails风格的数据库迁移来管理我的数据库。在我的代码中，Migration是up和down方法用于应用和回滚迁移的一个特性。每个单独的数据库迁移都是一个实现迁移特性的结构。为了按照正确的顺序跟踪数据库迁移，我构建了一个MigrationIndex类。
struct MigrationIndex<T> {
migrations: Vec<Box<T>>
}
impl <T: Migration> MigrationIndex<T> {
// methods for
浏览 4提问于2015-08-21得票数 3
回答已采纳
以下内容仅用作示例，并不是有效的Rust代码。
struct Vec<T: Sized, Count> {
a: [T; Count]
}
类似的东西在C++模板中是可能的，但我还没有在Rust中看到它。
浏览 0提问于2015-01-25得票数 37
回答已采纳
1回答
最近，当我遇到这个有趣的错误时，我正试图用不同的迭代样式对Rust循环进行基准测试。如果我使用下面的代码进行迭代，我将得到&[i32; 1000000] is not an iterator; maybe try calling .iter() or a similar method。我知道，我可以只使用iter()，，但是我正在试图找到哪个更快，iter()还是&array。
代码：
extern crate time;
fn main() {
let array: [i32; 1000000] = [0; 1000000]; // This will produc
浏览 0提问于2018-09-03得票数 4
回答已采纳
1回答
我知道默认情况下，Rust会在堆栈上分配，但是论文说Rust闭包通常是动态分配的(我的意思是“在堆上”)。
浏览 1提问于2021-02-15得票数 7
回答已采纳
考虑下面的代码： pub trait Hello {
fn hello(&self);
}
impl Hello for Any {
fn hello(&self) {
println!("Hello!!!!!");
}
} 我记得在某个地方看到Rust中有一个新功能，它允许您实现一个可以直接访问所有对象的函数，如下所示： let foo = 0 as u8;
foo.hello(); 不幸的是，我还没能找到它。是否真的有一个全局/通用的“实现者”？
浏览 32提问于2019-05-17得票数 0
回答已采纳
1回答
来自ML家族，并学会了用SML编程，一个非常严格的类型系统是很常见的。
我正在努力学习Rust，因为我习惯了强类型语言，所以我是一名计算机科学专业的学生，主修编译器理论和编程语言理论。我想我只是跳过了那些无聊的hello world介绍。目前，我正在尝试了解我范围内的泛型和生命周期的类型系统。
对于一个简单的项目，我正在实现一个单一的链表库，因为我很怀念它，它会给我一个类型系统是如何工作的感觉。我使用引用/借用而不是装箱来将东西保存在堆栈上，因此当列表节点超出范围时，需要显式地告诉编译器。
pub enum List<'a, L> {
Cons(L, &&
浏览 2提问于2020-07-25得票数 0
1回答
在下面将特征作为参数传递的示例中，函数签名中发送impl的必要性是什么？
我理解特征是更一般的类型，而不是具体的类型，但是既然Rust编译器不允许跨结构和特征共享名称，为什么需要在函数签名中提供impl来表示类型？
pub fn notify(item: impl Summary) {
println!("Breaking news! {}", item.summarize());
}
文档提到，上面的签名只是下面签名的语法糖。使用trait Summary而不是impl Summary不是有意义的，因为impl也可以用于在结构上定义方法吗？
pub fn notify
浏览 1提问于2019-08-19得票数 0
回答已采纳
2回答
我在试着理解“锈蚀”中的仿制药。我不知道这里出了什么问题
fn say<T>(msg: &T) {
let slen = msg.chars().count();
if slen > 0 {
println!("Char Count {} " ,slen);
}
}
fn main() {
let msg = String::from("Hello World from Rust!!!");
say::<String>(&msg);
}
编译错误：
er
浏览 2提问于2021-03-25得票数 1
回答已采纳
1回答
我正在玩一些锈蚀的特点和共性，以熟悉语言。
fn main() {
println(test(6f).to_str());
}
enum Result<TS,TE>{
Success(TS),
Error(TE)
}
impl<TS: ToStr, TE: ToStr> ToStr for Result<TS,TE> {
fn to_str(&self) -> ~str {
match *self {
Success(s) => s.to_str(),
浏览 5提问于2013-05-25得票数 2
回答已采纳
是否可以编译一个Rust库机箱，这样用户就不能看到源代码，但仍然可以使用这个库？
如果是的话，所有的泛型是以“源代码”或某些IR的形式提供的，还是Rust实现的泛型与C++模板不同？
浏览 1提问于2015-01-17得票数 39
回答已采纳
1回答
我习惯于Scala的Future类型，您可以在Future[..]中包装任何要返回的对象来指定它。
我的Rust函数hello返回Query，而且我似乎无法将这个结果作为参数传递给Future<Output = Query>类型。为什么不呢?我该如何更好地打字呢？
当我试图将未来作为一个论点传递时，失败就会发生：
use std::future::Future;
struct Person;
struct DatabaseError;
type Query = Result<Vec<Person>, DatabaseError>;
async fn h
浏览 6提问于2021-08-31得票数 3
回答已采纳
我希望能够共享我正在构建的服务的代码库中的数据结构(模型)。目前，我已经在一个名为domain的库和一个名为log_service的二进制文件中划分了代码。
在domain库中，我定义了一个包含日志信息的结构，如下所示。
pub struct Log {
pub id: u32,
pub message: String,
}
在log_service二进制文件中，我希望使用In作为数据库ORM，并使用domain库中定义的这个结构作为一个表。柴油文档指出，为了将此结构用作数据库表，您需要派生某些特征(例如，Queryable)，并可能应用其他属性。
然而，Rust不允许从另一个
浏览 1提问于2020-01-25得票数 3
回答已采纳
1回答
在TypeScript中，我需要：
const right = <T>(a: T) => <U>(b: U) => b;
const log = (msg: unknown) =>
right
(console.log(msg))
(msg);
log(1); // 1
log("hello"); // "hello"
log(right(1)(2)); // 2
现在，我想在Rust中用泛型实现相同的代码。
let right = |_a| |b| b;
let log = |msg| rig
浏览 3提问于2020-09-11得票数 0
UPDATE
通过更好地理解语言，我意识到我在问题中提出的问题与我遇到的问题无关。
标题仍然有效，但是，并且仍然可以从响应中获得值。请注意那里。谢谢。
Basic Rust Function
use std::convert::TryFrom;
fn calculate <T: Display>(input: T){
where {
i32: From<T>
}
--code snip--
let output = i32::try_from(input)
--code snip--
}
Error
the trait bound `
浏览 3提问于2021-11-21得票数 1
回答已采纳
在Swift中，我可以将扩展方法附加到struct、enum或protocol中的任何一个(与Rust中的trait相同)。
protocol Foo1 {
func method1() -> Int
}
extension Foo1 {
func method2() {
print("\(method1())")
}
}
然后，所有符合协议Foo1的类型现在都具有method2()。这对于轻松构建“方法链接”非常有用。
如何在Rust中做同样的事情？这在出现错误的情况下不起作用。
struct Kaz {}
impl Foo
浏览 16提问于2019-11-14得票数 8
回答已采纳
在Rust版指南中，它说在Rust 1.2中，。它给出了Rc<T>的例子，但没有给出一个完整的列表。还有哪些容器支持Rust 1.2+中的特征对象？
浏览 10提问于2019-07-05得票数 1
我正在为外部C库编写包装器代码，并试图说服Rust编译器强制执行Rust代码本身没有反映的外部生命周期限制。例如，一种类型的“不透明句柄”可以返回子句柄，该子句柄仅在父句柄的生命周期内有效。
我尝试使用std::marker::PhantomData，但我无法说服编译器返回预期的错误。
换句话说，我希望下面的代码块不能被编译：
struct Parent;
struct Child; // Note that there is no reference to the parent struct
impl Parent {
fn get_child( &self ) ->
浏览 0提问于2015-12-02得票数 9
2回答
我知道数组和向量在锈蚀语言中是不同的类型，但是我想知道为什么在比较这两种语言时没有错误。
// Rust Programming Language
fn main() {
let vec = vec!["a", "b", "c"]; // Vector
let arr = ["a", "b", "c"]; // Array
println!("{}", vec == arr); // true!
浏览 5提问于2022-06-08得票数 0
回答已采纳
这是对我在上的问题的跟进.
我正在尝试创建(并存储在事件循环附近)一个回调函数的列表，这些函数将在将来的某个不确定点被调用。
struct ComplexThing {
calls: Vec<Box<FnMut()>>,
}
impl ComplexThing {
fn call<'a, T: FnMut() + 'a>(&'a mut self, func: T) {
self.calls.push(Box::new(func));
}
}
错误有：
calls.rs:30:25:
浏览 1提问于2015-03-12得票数 3
编者注:问题中提出的代码按-在Rust 1.0中编译.
我试过：
trait Inner {}
struct Outer<'a> {
inner: &'a Inner,
}
但是编译器抱怨：
Compiling tst v0.1.0 (file:///home/chris/rust/tst)
/home/chris/rust/tst/src/main.rs:4:14: 4:19 error: explicit lifetime bound required
/home/chris/rust/tst/src/main.rs:4 in
浏览 4提问于2014-10-14得票数 1
回答已采纳
2回答
在我看来，Rust的trait和interface是一样的--一组需要在对象上实现的函数。
是否有技术原因将其命名为trait而不是interface，还是只是一些偏好？
浏览 2提问于2021-10-07得票数 15
回答已采纳
x86和其他可能的体系结构提供了一种方法来获取single operation (DIV)中的商和余数。正因为如此，许多语言都具有DIVMOD组合操作(如DIVREM in C#、DIVMOD in Python或与div and div_t in C。我如何在Rust中做到这一点？ 有没有一种优化的方法来同时执行这两种任务 let res = (a / b, a % b);
浏览 77提问于2021-09-03得票数 6
我有一段代码，我想在库的周围创建一个包装器，使其以与我的其余代码相同的理念工作。为了避免编写数百个结构，我创建了一个泛型结构(Worker)。但我使用函数来配置它，并将该信息作为枚举传递： fn configure(config: Config) -> Worker<T> {
match config {
some_config => Worker<some_type>,
_ => {...}
} 由于我已经将信息作为枚举传递，所以我希望避免将类型参数传递给函数，但显然rust会抱怨，因为没有定义T。 有没有办
浏览 17提问于2021-11-06得票数 1
1回答
我正在阅读“编程锈”一书，并了解了锈菌的特性和一般类型。我发现，类型边界可以放在特征的方法上。然后，我构造了以下特性，并将其实现为一个结构。
use std::fmt::Display;
trait Test<T> {
fn show(&self)
where
T: Display;
fn test(&self);
}
struct S<T> {
field: T,
}
impl<T> Test<T> for S<T> {
fn show(&self)
浏览 1提问于2019-04-26得票数 3
在Rust中，您只能使用特征来指定类型限制，例如：<T: A + B>、A和B必须是特征，它们不能是i32或f64这样的原始类型。
trait Foo {}
impl Foo for i32 {}
fn blah<T: i32>(val: T) {
// ^^^ works if this is Foo
println!("hello\n");
}
fn main() {
let toast: i32 = 33;
blah(toast);
}
您可以通过为原语实现一个特性来解决这个问题，但是为什么语言的设计者
浏览 1提问于2016-11-04得票数 1
回答已采纳
我觉得这是个简单的问题。我还在学习锈病，我想做以下几件事：
我希望创建一个异步特征(使用async-trait)，它将实例化一个DB连接实例，并返回实现该特性的结构。
mongo.rs
#[async_trait]
pub trait DB {
async fn init<T, E>() -> Result<T, E>;
}
然后：favorites.rs (请参阅下面DB特性的实现)
use async_trait::async_trait;
use mongodb::Collection;
use rocket::form::FromForm;
use
浏览 8提问于2022-02-05得票数 0
回答已采纳
锈蚀字符串实现和
但是为什么Rust正确地允许字符串被借用为&str，而不是&u8，即使我们提供了显式的类型注释提示？
let s = String::from("hello");
let item: &str = &s; // Works
let item2: &[u8] = &s; // Fails
当然，显式调用可以工作，但奇怪的是，为什么上面的调用不起作用？
let item2: &[u8] = s.as_ref();
浏览 14提问于2022-10-26得票数 3
回答已采纳
我有一个函数，它接受对象的向量，它实现了一些特性。我想用它像下面这样：
trait SomeTrait {
fn trait_function() {
println!("Rust works !");
}
}
struct MyStruct {}
impl SomeTrait for MyStruct {}
fn test(items: Vec<impl SomeTrait>) {
for item in items {
item::trait_function();
}
}
fn main (
浏览 2提问于2022-06-09得票数 0
回答已采纳
我有一个3元素数组：
let color = [0.25, 0.25, 0.25];
我想将其转换为一个4元素数组，即3元素数组加上一个附加元素：
let color_with_alpha = [color[0], color[1], color[2], 1.0];
我知道Rust在很多事情上都有一些很酷的语法糖，这有什么用的吗？类似于：
let color_with_alpha = [color, 1.0];
我读过关于的文章，但这似乎只会创建字符串切片。我可以想象有一个基于向量的解决方案，但我不需要动态调整。
浏览 0提问于2018-03-17得票数 2
回答已采纳
如何在Rust中创建一个接受任何类型或多个类型作为函数参数的函数？
我的第一个方法是：
fn multiple_types(argument : _) {
println!("{}",argument);
}
我尝试了类型占位符"_“作为参数，但这是不允许的.
浏览 2提问于2015-05-26得票数 1
回答已采纳
我正在尝试构建一个操作递归(树状)数据结构的Rust代码。天真地，我们可以把它定义为
struct ALinkedList {
value: i32,
next: Option<Box<Self>>
}
为了试验不同的内存布局和将算法设计与存储分开，我想将定义概括为如下
struct ALinkedList<D: Deref<Target=Self>> {
value: i32,
next: Option<D>
}
但是，当试图构造ALinkedList实例时，我得到
64 | let t: A
浏览 4提问于2020-12-25得票数 3
回答已采纳
1回答
有没有办法为枚举实现一个带有泛型类型T的特征？如下所示： use rand::thread_rng;
use rand::seq::SliceRandom;
pub enum Color {
Red,
Blue,
Green,
}
trait Shuffable {
fn values<T>() -> Vec<T>;
fn shuffled<T: Shuffable>() -> Vec<T> {
let mut items = T::values();
i
浏览 16提问于2021-05-02得票数 0
回答已采纳
2回答
我希望能够将泛型函数传递给另一个函数(在本例中是闭包)，而不会失去传递函数的“通用性”。因为这是一个相当复杂的陈述，下面是一个例子：
use std::fmt::Debug;
fn test<F, I: Debug>(gen: F) where F: Fn(fn(I) -> I) -> I {
fn input<I: Debug>(x: I) -> I {
x
}
println!("{:?}", gen(input));
}
fn main() {
test(|input|
浏览 1提问于2016-06-03得票数 23
回答已采纳
2回答
Rust允许以这种方式格式化打印变量：
fn main(){
let r:f64 = rand::random();
println!("{}",r);
}
但这不起作用：
fn main(){
println!("{}",rand::random());
}
它显示以下错误：
|
31 | println!("{}",rand::random());
| ^^^^^^^^^^^^ cannot infer type for type parameter `T` declared on
浏览 53提问于2020-05-22得票数 1
回答已采纳
下面的C#代码能被翻译成Rust吗？
dynamic x = 109;
x = "Hi";
我要求一个通用的动态类型，以允许创建一个动态值数组。例如：
var l = new dynamic[2];
l[0] = 102;
l[1] = "Hi";
浏览 7提问于2016-07-05得票数 4
回答已采纳
1回答
如何在Rust中初始化泛型变量
、、、、
在T上的泛型函数中，如何在安全(或不安全)的Rust中正确创建和初始化T类型的变量？T可以是任何类型的变量。做这件事的惯用方式是什么？ fn f<T>() {
let t: T = todo!("what to put here?");
} 一种可能的用例是使用T作为交换的临时变量。
浏览 24提问于2021-02-08得票数 1
回答已采纳
1回答
在玩Rust及其泛型时，我遇到了一些问题，我找不到任何文档。
我已经实现了一个类型Wrapper，它封装了另一个类型。在某种程度上，我想实现From特性。
impl<TSrc, TDst> From<Wrapper<TSrc>> for Wrapper<TDst>
where
TSrc: From<TDst>
{
fn from(other: Wrapper<TSrc>) -> Self {
todo!()
}
}
rustc抱怨有以下错误
58 | impl<TSrc
浏览 6提问于2022-10-04得票数 1
fn main() {
let mut v = vec![1, 2, 3];
go(&mut v);
// still need v here, so I can't pass ownership to the "go' method above
println!("{}", v.len())
}
fn go(v: &mut Vec<i32>) {
for i in v {
println!("{}", i);
}
v.push(4)
浏览 8提问于2021-12-21得票数 1
回答已采纳
更新 TL;DR:重定向引用：
在C++中，我们可以使用类继承来实现接口多态性：
class Base {
public:
virtual void func(int) = 0;
};
class DerivedA : Base {
public:
void func(int) override {
// specific behavior of DerivedA
}
};
class DerivedB : Base {
public:
void func(int) override {
// specific behav
浏览 6提问于2020-11-10得票数 0
回答已采纳
public TResponse ExecuteCustomMessage<TResponse>(IModbusMessage request)
where TResponse : IModbusMessage, new()
以上是什么意思呢？我以前从来没有见过这样的东西，尽管我已经用C#编程好几年了……它应该是一个函数，但我不确定这是什么<>和关键字where和new()在结尾...
浏览 4提问于2012-03-15得票数 3
回答已采纳
我正在尝试编写一个函数，它从别人的框中接收对泛型结构的可变引用(因此我不能修改该结构的定义)。为结构实现的一些方法仅在结构满足特定边界时才可用： impl<'s, 'p: 's, P> TryCatch<'s, P>
where
Self: AsMut<HandleScope<'p, ()>>,
{
// functions that I want to use
} 我的函数可以正常工作，如果我这样声明它： fn my_func(try_catch: &mut v8::TryCatch
浏览 15提问于2021-04-14得票数 1
我在Rust中遇到了许多用单个撇号表示的类型：
'static
'r
'a
那个撇号的意义是什么？也许它是引用的修饰语(&)？泛型类型是否特定于引用？我不知道这方面的文档藏在哪里。
浏览 3提问于2014-02-27得票数 123
回答已采纳
这个问题是在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
回答已采纳
我有一个使用UnitOfWork的通用存储库模式，而且我使用的是IoC。除了存储库使用的基本方法之外，我还有一些自定义方法。我没有再次实现整个IRepository方法，而是继承了GenericRepository类。
下面是我的UnitofWork实现：
public interface IUnitOfWork<T> : IDisposable where T : DbContext
{
int Save();
T Context { get; }
}
public class UnitOfWork<T> : IUnitOfWork<T>
浏览 3提问于2016-09-13得票数 0
回答已采纳
1回答
Vala泛型到C代码
、、、
我读到了vala语言，它编译成Ansi C代码。然而，我也看到它支持像Java或Rust这样的泛型。现在我的问题是这是如何编译成C代码的？如果我有一个gerneric类或函数，那么生成什么样的C代码来模拟泛型行为？
浏览 6提问于2016-07-04得票数 3
回答已采纳
我正在做我的第一个NHibernate项目，并且有以下设置/要求。
我有两个项目xx.Data和xx.Business。在数据项目中，这是我的域类、映射文件所在的位置。我正在做的是创建一个在线应用程序，其中我有一个存储ID、修改日期的SQL表，以及一个存储应用程序表单详细信息的XML字段。这映射到一个EnrolmentApplication域类。
xml被反序列化为ApplicationForm类，目前该类位于xx.Business项目中。业务项目引用数据项目。
我从我的代码开始创建一个新的ApplicationForm，序列化成xml，然后将EnrolmentApplicaiton属性设置为
浏览 3提问于2010-06-21得票数 1
回答已采纳
fn add<T: Add<T,T>>(a: T, b: T) -> T{
a + b
}
fn main() {
println!("{}", add(10i,5));
}
我知道Rust不允许重载函数。
1.)添加是否在编译时生成？
2.)(如果1.)是真的，如果没有重载函数，它是如何实现这一点的？
在我的头脑中，编译器会生成
fn add(a: i32, b: i32) -> i32{
a + b
}
fn add(a: f32, b: f32) -> f32{
a + b
}
浏览 2提问于2014-08-23得票数 5
回答已采纳
1回答
我想从实现以下接口：
public interface Converter {
// Convert the specified input object into an output object of the specified type
<T> T convert(java.lang.Class<T> tClass, java.lang.Object o);
}
我的实现应该接受Enum的子类，并将String对象转换为指定类型的枚举。我试图使用以下声明：
class EnumConverter implements Converter {
浏览 5提问于2014-02-19得票数 1
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
腾讯会议
实时音视频活动推荐
腾讯云开发者
