structs और arrays मुद्रित करने के लिए कैसे?

Question

गो सीधे structs और सरणी मुद्रित करने में सक्षम प्रतीत होता है।

struct MyStruct { 
    a: i32, 
    b: i32 
} 

और

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

Answer 1

आप अपने struct पर Debug विशेषता लागू करना चाहते हैं। #[derive(Debug)] का उपयोग करना सबसे आसान समाधान है। तो फिर तुम {:?} साथ इसे प्रिंट कर सकते हैं:

#[derive(Debug)] 
struct MyStruct{ 
    a: i32, 
    b: i32 
} 

fn main() { 
    let x = MyStruct{ a: 10, b: 20 }; 
    println!("{:?}", x); 
} 

Answer 2

mdup says रूप में, आप Debug उपयोग कर सकते हैं, लेकिन आप भी Display विशेषता का उपयोग कर सकते हैं। ,

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

अधिक जानकारी के लिए आप fmt module documentation देख सकते हैं:

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);  
} 

शेल: आप एक कस्टम उत्पादन बना सकते हैं।

Answer 3

कोई भी यहाँ स्पष्ट रूप से सरणियों के लिए जवाब देता है, एक सरणी आप {:?} निर्दिष्ट करने की आवश्यकता बाहर मुद्रित करने के लिए के रूप में, यह भी डिबग आउटपुट मुद्रित करने के लिए

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]; 

इस्तेमाल किया हालांकि सरणियों जहां length > 32 एक त्रुटि के साथ बाहर निकल जाएगा:

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]` 

अब सरणियों इस जवाब से दृष्टिकोण के साथ बाहर मुद्रित किया जा सकता: Implement Debug trait for large array type

Answer 4

दरअसल बस {:?} पर्याप्त है।

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