Rust does not have constructors as a language construct. Instead, the
convention is to use an associated function new
to create an object:
/// Time in seconds.
///
/// # Example
///
/// ```
/// let s = Second::new(42);
/// assert_eq!(42, s.value());
/// ```
pub struct Second {
value: u64
}
impl Second {
// Constructs a new instance of [`Second`].
// Note this is an associated function - no self.
pub fn new(value: u64) -> Self {
Self { value }
}
/// Returns the value in seconds.
pub fn value(&self) -> u64 {
self.value
}
}
Rust supports default constructors with the Default
trait:
/// Time in seconds.
///
/// # Example
///
/// ```
/// let s = Second::default();
/// assert_eq!(0, s.value());
/// ```
pub struct Second {
value: u64
}
impl Second {
/// Returns the value in seconds.
pub fn value(&self) -> u64 {
self.value
}
}
impl Default for Second {
fn default() -> Self {
Self { value: 0 }
}
}
Default
can also be derived if all types of all fields implement Default
,
like they do with Second
:
/// Time in seconds.
///
/// # Example
///
/// ```
/// let s = Second::default();
/// assert_eq!(0, s.value());
/// ```
#[derive(Default)]
pub struct Second {
value: u64
}
impl Second {
/// Returns the value in seconds.
pub fn value(&self) -> u64 {
self.value
}
}
Note: When implementing Default
for a type, it is neither required nor
recommended to also provide an associated function new
without arguments.
Hint: The advantage of implementing or deriving Default
is that your type
can now be used where a Default
implementation is required, most prominently,
any of the *or_default
functions in the standard library.
-
The default idiom for a more in-depth description of the
Default
trait. -
The builder pattern for constructing objects where there are multiple configurations.