Hoe structs en arrays afdrukken?

Go lijkt structs en arrays rechtstreeks af te kunnen drukken.

struct MyStruct {
    a: i32,
    b: i32
}

en

let arr: [i32; 10] = [1; 10];

Antwoord 1, autoriteit 100%

U wilt de eigenschap Debugimplementeren op uw struct. Het gebruik van #[derive(Debug)]is de gemakkelijkste oplossing. Dan kun je het afdrukken met {:?}:

#[derive(Debug)]
struct MyStruct{
    a: i32,
    b: i32
}
fn main() {
    let x = MyStruct{ a: 10, b: 20 };
    println!("{:?}", x);
}

Antwoord 2, autoriteit 14%

Zoals mdup zegt, kun je Debuggebruiken, maar je kunt ook de Display-eigenschap.

Alle typen kunnen de implementatie fmt::Debugafleiden (automatisch maken) als #[derive(Debug)], maar fmt::Displaymoet handmatig worden geïmplementeerd.

U kunt een aangepaste uitvoer maken:

struct MyStruct {
    a: i32,
    b: i32
}
impl std::fmt::Display for MyStruct {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        write!(f, "(value a: {}, value b: {})", self.a, self.b)
    }
}
fn main() {
    let test = MyStruct { a: 0, b: 0 };
    println!("Used Display: {}", test);    
}

Shell:

Used Display: (value a: 0, value b: 0)

Voor meer informatie kun je de fmtmodule documentatie.

Antwoord 3, autoriteit 7%

Omdat niemand hier expliciet antwoordt op arrays, moet je om een ​​array af te drukken de {:?}specificeren, die ook wordt gebruikt om debug-uitvoer af te drukken

let val = 3;
let length = 32; // the maximum that can be printed without error
let array1d = [val; length];
let array2d = [array1d; length]; // or [[3; 32]; 32];
let array3d = [array2d; length]; // or [[[3; 32]; 32]; 32];

Arrays waar length > 32wordt afgesloten met een fout:

let length = 33;
let array1d = [3; length];
println("{:?}", array1d);
error[E0277]: the trait bound `[{integer}; 33]: std::fmt::Debug` is not satisfied
--> src\main.rs:6:22
|
|     println!("{:?}", array1d);
|                      ^^^^^^^ the trait `std::fmt::Debug` is not implemented for `[{integer}; 33]`

Langere arrays kunnen worden afgedrukt met de benadering van dit antwoord: Implement Debug eigenschap voor groot arraytype

Antwoord 4, autoriteit 5%

Eigenlijk is gewoon {:?}voldoende.

let a = [1, 2, 3, 4, 5];
let complete = &a[..];
println! ("{:?}", a);
println! ("{:?}", complete);

Antwoord 5

#[derive(Debug)]
 struct Rectangle{
       width: u32,
       height: u32,
  }
fn main(){
   let rec = Rectangle{
      width: 50,
      height: 30,
   };
   println!("The rectangle {:?} ", rec);
   println!("The area of the rectangle is {} pixels", 
   area_rectangle(&rec));
}
fn area_rectangle(rectangle: &Rectangle) -> u32{
    rectangle.width * rectangle.height
}