Trait ToString

ToString trait 来自 std::string 模块，它的主要目的是将值转换为 String。它通过 blanket impl 为所有实现 Display 的类型自动提供，通常用于需要字符串表示的场景，如日志记录或字符串拼接。与 Display 不同，ToString 专注于生成拥有所有权的 String，而非格式化输出。

1. `ToString` Trait 简介

1.1 定义和目的

ToString trait 定义在 std::string::ToString 中，自 Rust 1.0.0 起稳定可用。其语法如下：

#![allow(unused)]
fn main() {
pub trait ToString {
    fn to_string(&self) -> String;
}
}

目的：提供一种将值转换为 String 的机制。它允许类型定义如何生成其字符串表示，返回拥有所有权的 String。核心方法 to_string 通常委托给 Display 的格式化。这在需要字符串作为返回值或中间表示时特别有用，如在错误消息中拼接或序列化。

根据官方文档，ToString 不应手动实现：应实现 Display，然后通过 blanket impl 自动获得 ToString。 blanket impl 为所有实现 Display 的类型提供：impl<T: fmt::Display + ?Sized> ToString for T { fn to_string(&self) -> String { format!("{}", self) } }。这确保转换高效，且与格式化一致。

为什么需要 ToString？ Rust 强调类型安全和便利转换。ToString 简化生成 String，支持泛型函数，并避免手动格式化。例如，在日志中：log::info!("{}", value.to_string());。

1.2 与相关 Trait 的区别

ToString 与格式化 trait 相关，但专注于字符串生成：

与 Display：
- ToString 生成 String；Display 用于格式化输出（无所有权）。
- ToString 依赖 Display（通过 blanket impl）；实现 Display 自动获 ToString。
- Display 更基础、更高效（无分配）；ToString 便利，但有分配开销。
- 示例：println!("{}", value); 用 Display；let s = value.to_string(); 用 ToString。
- 选择：实现 Display，免费获 ToString。
与 Debug：
- ToString 用户友好（基于 Display）；Debug 开发者导向（详细结构）。
- Debug 可派生；ToString 间接通过 Display。
- 示例：value.to_string() 如 "Point(1, 2)"（用户友好）；format!("{:?}", value) 如 "Point { x: 1, y: 2 }"（调试）。
与 Into<String>：
- ToString 用引用（&self）；Into<String> 消耗 self。
- ToString 更通用（不消耗）；Into 用于所有权转移。
- 许多类型（如 &str）实现两者，但 ToString 更常见。

何时选择？ 用 ToString 需要 String 时；优先实现 Display 以获 ToString。避免直接实现 ToString，以防覆盖 blanket impl。

2. 手动实现 `ToString`

官方推荐不直接实现 ToString：实现 Display 即可。但如果需要自定义，可手动实现（罕见）。

2.1 通过 Display 间接实现

use std::fmt;

struct Point {
    x: i32,
    y: i32,
}

impl fmt::Display for Point {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "Point({}, {})", self.x, self.y)
    }
}

fn main() {
    let p = Point { x: 1, y: 2 };
    let s = p.to_string();
    assert_eq!(s, "Point(1, 2)");
}

实现 Display，自动获 to_string。

2.2 直接实现（不推荐）

use std::string::ToString;

impl ToString for Point {
    fn to_string(&self) -> String {
        format!("Custom: {} {}", self.x, self.y)
    }
}

fn main() {
    let p = Point { x: 1, y: 2 };
    assert_eq!(p.to_string(), "Custom: 1 2");
}

覆盖 blanket impl；仅在特殊需求。

2.3 枚举

enum Shape {
    Circle(f64),
    Rectangle(f64, f64),
}

impl fmt::Display for Shape {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Shape::Circle(r) => write!(f, "Circle({})", r),
            Shape::Rectangle(w, h) => write!(f, "Rectangle({}x{})", w, h),
        }
    }
}

fn main() {
    let circle = Shape::Circle(5.0);
    assert_eq!(circle.to_string(), "Circle(5.0)");
}

通过 Display 处理变体。

2.4 泛型类型

struct Pair<T> {
    first: T,
    second: T,
}

impl<T: fmt::Display> fmt::Display for Pair<T> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "({}, {})", self.first, self.second)
    }
}

fn main() {
    let pair = Pair { first: 1, second: "two" };
    assert_eq!(pair.to_string(), "(1, two)");
}

约束 T: Display。

#![allow(unused)]
fn main() {
trait MyTrait: fmt::Display {}

impl ToString for dyn MyTrait {
    fn to_string(&self) -> String {
        format!("{}", self)
    }
}
}