如何在Rust中实现可接受String或&str的灵活构造方法？

我是Rust完全新手，写了个存储人员信息的程序练手：

person.rs

pub struct Person {
    firstname: String,
    lastname: String,
    pub age: u8
}


impl Person {
    pub fn new(firstname: String, lastname: String, age: u8) -> Person {
        return Person { firstname: firstname, lastname: lastname, age: age };
    }

    pub fn from_str(firstname: &str, lastname: &str, age: u8) -> Person {
        return Person::new(firstname.to_string(), lastname.to_string(), age);
    }

    pub fn name(&self) -> String {
        return self.firstname.to_owned() + " " + &self.lastname;
    }
}

main.rs

mod person;
use person::Person;


fn main() {
    let me = Person::from_str("John", "Doe", 42);
    println!("{} is {} years old.", me.name(), me.age);
}

我知道Rust没有函数重载，听说过Trait但还没搞懂。它是不是和C++的模板类似？有没有办法用Trait让Person::new()同时接受String或&str类型的参数？

我试了下面的代码但编译失败：

person.rs

pub struct Person {
    firstname: String,
    lastname: String,
    pub age: u8
}


impl Person {
    /*
    pub fn new(firstname: String, lastname: String, age: u8) -> Person {
        return Person { firstname: firstname, lastname: lastname, age: age };
    }

    pub fn from_str(firstname: &str, lastname: &str, age: u8) -> Person {
        return Person::new(firstname.to_string(), lastname.to_string(), age);
    }
    */
    
    pub fn new<T>(firstname: &T, lastname: &T, age: u8) -> Person {
        return Person::new(firstname.to_string(), lastname.to_string(), age);
    }

    pub fn name(&self) -> String {
        return self.firstname.to_owned() + " " + &self.lastname;
    }
}

main.rs

mod person;
use person::Person;


fn main() {
    let me = Person::new("John", "Doe", 42);
    println!("{} is {} years old.", me.name(), me.age);
}

编译报错如下：

$ rustc main.rs -o main
error[E0599]: the method `to_string` exists for reference `&T`, but its trait bounds were not satisfied
  --> person.rs:20:38
   |
20 |         return Person::new(firstname.to_string(), lastname.to_string(), age);
   |                                      ^^^^^^^^^ method cannot be called on `&T` due to unsatisfied trait bounds
   |
   = note: the following trait bounds were not satisfied:
           `T: std::fmt::Display`
           which is required by `T: ToString`
           `&T: std::fmt::Display`
           which is required by `&T: ToString`

error[E0599]: the method `to_string` exists for reference `&T`, but its trait bounds were not satisfied
  --> person.rs:20:60
   |
20 |         return Person::new(firstname.to_string(), lastname.to_string(), age);
   |                                                            ^^^^^^^^^ method cannot be called on `&T` due to unsatisfied trait bounds
   |
   = note: the following trait bounds were not satisfied:
           `T: std::fmt::Display`
           which is required by `T: ToString`
           `&T: std::fmt::Display`
           which is required by `&T: ToString`

error[E0277]: the size for values of type `str` cannot be known at compilation time
  --> main.rs:6:14
   |
6  |     let me = Person::new("John", "Doe", 42);
   |              ^^^^^^^^^^^ doesn't have a size known at compile-time
   |
   = help: the trait `Sized` is not implemented for `str`
note: required by a bound in `Person::new`
  --> person.rs:19:16
   |
19 |     pub fn new<T>(firstname: &T, lastname: &T, age: u8) -> Person {
   |                ^ required by this bound in `Person::new`
help: consider relaxing the implicit `Sized` restriction
  --> person.rs:19:17
   |
19 |     pub fn new<T: ?Sized>(firstname: &T, lastname: &T, age: u8) -> Person {
   |                 ++++++++

error: aborting due to 3 previous errors

Some errors have detailed explanations: E0277, E0599.
For more information about an error, try `rustc --explain E0277`.

问题解答 #

1. Trait和C++模板的区别

Rust的Trait和C++模板有相似之处（都是编译时处理的泛型机制），但核心不同：

• C++模板是鸭子类型：只要代码里调用的方法存在，编译就能通过，没有明确的约束。
• Rust的Trait是明确的约束：必须为泛型参数指定Trait边界，编译器会严格检查参数类型是否实现了对应的Trait，保证代码的安全性和可读性。

Trait更像是定义了一套行为规范，任何实现了该Trait的类型都可以使用这套规范下的接口，同时支持动态多态（通过Trait对象）和静态多态（泛型）。

2. 让Person::new()支持String和&str的正确实现

最简洁的方式是使用标准库中的Into<String> Trait，因为String和&str都默认实现了这个Trait：

• String调用into()会直接返回自身（因为String: Into<String>）
• &str调用into()会自动转换为String（因为&str: Into<String>）

修改后的person.rs代码：

pub struct Person {
    firstname: String,
    lastname: String,
    pub age: u8
}

impl Person {
    // 泛型参数N约束为Into<String>，表示任何能转成String的类型都可以传入
    pub fn new<N: Into<String>>(firstname: N, lastname: N, age: u8) -> Person {
        Person {
            firstname: firstname.into(),
            lastname: lastname.into(),
            age // 字段名和参数名相同时可以简写
        }
    }

    // 用format!替代字符串拼接，更简洁直观
    pub fn name(&self) -> String {
        format!("{} {}", self.firstname, self.lastname)
    }
}

对应的main.rs可以同时用两种类型调用：

mod person;
use person::Person;

fn main() {
    // 直接传入&str字面量
    let me = Person::new("John", "Doe", 42);
    println!("{} is {} years old.", me.name(), me.age);

    // 传入String类型
    let first_name = String::from("Jane");
    let last_name = String::from("Smith");
    let another_person = Person::new(first_name, last_name, 30);
    println!("{} is {} years old.", another_person.name(), another_person.age);
}

3. 你之前代码的错误原因

• 缺少Trait约束：你定义的泛型T没有任何边界，编译器不知道&T有to_string()方法，必须指定T: ToString或者T: Display（因为ToString默认依赖Display）。
• 动态大小类型问题：str是动态大小类型（DST），Rust默认要求泛型参数是Sized（编译时大小已知），所以需要添加T: ?Sized来放松约束，但这会增加复杂度，不如直接用Into<String>简洁。

内容的提问来源于stack exchange，提问作者user3515670