Pas "kullan" vs C++ "ad alanını kullanarak"

Question

Rust'ta birden çok "kullanım" ifadesi bildirmek kötü bir stil olarak kabul edilir mi? Yakın zamanda Rust'u denemeye başlayan bir C++ programcısıyım. Rust kodunu incelediğimde fark ettiğim bir şey, pek çok Rust programında, programın üst kısmında bir grup use ifadesi olacak. C++ gelen, özellikle başlık dosyaları yaparken, using namespace std kullanmak için cesaret edildi, ama gördüğüm Pas programlarının çoğunda böyle görünmüyor. Yani aşağıdaki önemsiz örneklerden hangisinin daha iyi Pas programlama tarzı olduğu düşünülüyor? Bir modül ile ikili bir program yapıyorsanız değişir mi? Ve neden? C#

use std::sync::Arc; 
use std::sync::Mutex; 
use std::thread::Thread; 
use std::rand::random; 

fn main() { 
    let mut vec: Vec<char> = (0u8..10).map(|i| i as char).collect(); 

    let mut data = Arc::new(Mutex::new(vec)); 
    for i in 1usize..10 { 
     let data = data.clone(); 
     let thread = Thread::spawn(move || { 
      let mut data = match data.lock() { 
       Ok(guard) => guard, 
       Err(e)  => panic!("{}, was poisoned", e) 
      }; 
      data.push(random::<char>()); 
     }); 
    } 
} 

Ya da bu ...

fn main() { 
    let mut vec: Vec<char> = (0u8..10).map(|i| i as char).collect(); 

    let mut data = std::sync::Arc::new(
          std::sync::Mutex::new(vec) 
             ); 
    for i in 1usize..10 { 
     let data = data.clone(); 
     let thread = std::thread::Thread::spawn(move || { 
      let mut data = match data.lock() { 
       Ok(guard) => guard, 
       Err(e)  => panic!("{}, was poisoned", e) 
      }; 
      data.push(std::rand::random::<char>()); 
     }); 
    } 
} 

Answer 1

Muhtemelen benzer baktım isimlerin (use ve using namespace) ile karıştırılıyor yazmak için üzgünüm. Aslında semantik olarak çok farklılar.

using namespace std; 

cout << "Hello!\n"; 

use Rust, ancak, sadece belirtilen adını içerir:

C

using namespace ++ örneğin, cout yerine std::cout kullanabilirsiniz, geçerli kapsamı içine ad tüm içeriğini içerir, bu nedenle , yine de aslında atıfta hangi madde nitelemek zorunda: Debug elemeleri ancakolmadan nasıl kullanıldığını

use std::mem; 
use std::fmt::Debug; 

fn do_something<T: Debug>(t: T) { ... } 

fn main() { 
    let (mut x, mut y) = ...; 
    mem::swap(&mut x, &mut y); 
} 

Not 10 hala bir modül niteleyicisini gerektirir, bu yüzden Rust'ta use, C++ 'da using (namespace olmadan) gibidir. use, neyi içe aktardığı konusunda çok spesifik olduğundan, hemen her zaman kullanmak için iyi bir stil olarak kabul edilir, bu nedenle ilk örneğiniz deyimseldir. Aslında

, using namespace daha Rust glob ithalatı gibidir:

use std::*; 

Ve glob ithalatı gerçekten biraz edilmez. Ancak, pas konfigürasyon sözleşmeleri C++ (özellikle std kütüphanesinde) tarafından kullanılanlara göre daha esnektir, bu nedenle use std::* size sadece standart olarak tüm standart kütüphaneyi vermeyecektir. Glob ithalatı, birkaç başka durumda da, örn. Başka bir modülden yeniden adlandırırken veya tüm modül uzantı özelliklerini tek bir modülde toplarken.

Ve hayır, bir kitaplık veya yürütülebilir dosya oluşturuyor olmanıza bakılmaksızın sözleşmeler değişmez. Rust, C/C++ 'nun baş harfleri gibi harfleri içermez, bu yüzden her derleme birimi tamamen bağımsızdır ve istediğiniz herhangi bir ithalatı yapabilir - kullanıcılarını etkilemez (bunlar, pub use' un elbette olmadığı sürece).

Answer 2

using System; tamamen normaldir ve Java, hatta zaten varsayılan olarak içe olarak import java.lang.*; yazmaya gerek yoktur. Ve birden çok ifade yazarken herhangi bir kusur görmüyorum - aynı isimde bir şey çağırmanız gerekirse, ikinci kod örneğinizde yaptığınız gibi, tanımlayıcıları her zaman tam adlarıyla çağırabilirsiniz.

P.S. .: bir görüş tahrik cevabı ^^