Ownership और Functions

जब आप किसी function को एक value देते हैं, तो आप अक्सर इसे हमेशा के लिए दे रहे होते हैं, जब तक आप इसे वापस न मांगें।

In this page:

Passing Ownership Into a Function
Returning Ownership
Passing Ownership In and Returning It Back Out
Avoiding Unnecessary Moves with References

Syntax

rust

fn take(param: Type) {
    // takes ownership
}

fn give() -> Type {
    // returns ownership
}

Passing Ownership Into a Function

जब एक non-Copy value जैसे String को किसी function में value से pass किया जाता है, ownership उस function के parameter में move हो जाती है, और caller बाद में original variable उपयोग नहीं कर सकता।

उदाहरण: Passing Ownership Into a Function

markup

// Define the function `consume` taking `s`
fn consume(s: String) {
    // Print "Consumed: {}" to the console, substituting in `s` (with a trailing newline)
    println!("Consumed: {}", s);
}

// Entry point: execution of the program starts here
fn main() {
    // Declare an immutable variable `text`, set to `String::from("gift")`
    let text = String::from("gift");
    consume(text);
}

Returning Ownership

एक function किसी value की ownership सिर्फ इसे final expression के रूप में return करके अपने caller को वापस transfer कर सकता है, caller को एक नई binding के तहत data उपयोग करते रहने देते हुए।

उदाहरण: Returning Ownership

markup

// Define the function `create_greeting` with no parameters and returning a String
fn create_greeting() -> String {
    String::from("Hello from a function")
}

// Entry point: execution of the program starts here
fn main() {
    // Declare an immutable variable `greeting`, set to `create_greeting()`
    let greeting = create_greeting();
    // Print "{}" to the console, substituting in `greeting` (with a trailing newline)
    println!("{}", greeting);
}

Passing Ownership In and Returning It Back Out

एक function किसी value की ownership accept कर सकता है, इसे उपयोग कर सकता है, और फिर इसे वापस return कर सकता है, references के बजाय moves के ज़रिए call की अवधि के लिए इसे effectively "borrow" करते हुए।

उदाहरण: Passing Ownership In and Returning It Back Out

markup

// Define the function `add_exclamation` taking `s` and returning a String
fn add_exclamation(mut s: String) -> String {
    // Append `'!'` to `s`
    s.push('!');
    s
}

// Entry point: execution of the program starts here
fn main() {
    // Declare an immutable variable `phrase`, set to `String::from("Rust is great")`
    let phrase = String::from("Rust is great");
    // Declare an immutable variable `phrase`, set to `add_exclamation(phrase)`
    let phrase = add_exclamation(phrase);
    // Print "{}" to the console, substituting in `phrase` (with a trailing newline)
    println!("{}", phrase);
}

Avoiding Unnecessary Moves with References

हर बार data पढ़ने की ज़रूरत पर ownership move करने के बजाय, एक function एक reference accept कर सकता है (अगले chapter में covered), caller को call के बाद अपने original variable उपयोग करते रहने देते हुए।

उदाहरण: Avoiding Unnecessary Moves with References

markup

// Define the function `print_length` taking `s`
fn print_length(s: &String) {
    // Print "Length is {}" to the console, substituting in `s.len()` (with a trailing newline)
    println!("Length is {}", s.len());
}

// Entry point: execution of the program starts here
fn main() {
    // Declare an immutable variable `word`, set to `String::from("borrowed")`
    let word = String::from("borrowed");
    print_length(&word);
    // Print "Still usable: {}" to the console, substituting in `word` (with a trailing newline)
    println!("Still usable: {}", word);
}

Chapter Quiz — Complete all 6 topics to unlock

0/6 topics done

Complete these topics first:

← Previous Lesson Scope and the Drop Trait Next Lesson → References Basics

Ownership और Functions

Passing Ownership Into a Function

Returning Ownership

Passing Ownership In and Returning It Back Out

Avoiding Unnecessary Moves with References

Chapter Quiz — Complete all 6 topics to unlock

Login to run this code