C/Rust Programming Languages Review

A loop that executes for a specific number of iterations/steps.

A programming language where you use functions to perform tasks.

A system programming language offering memory safety without garbage collection.

A function definition describes the body of a function, including the code that it should execute.

Using a function multiple times in a program (without rewriting the code).

Invoking a function by its name followed by parentheses containing arguments.

Tells the compiler the function's return type and parameters.

Functions can be called in any order; compilation finds all functions first.

Data passed to a function to use.

A block of code that performs a specific task.

Hiding the internal workings of a function from the user, focusing on the result.

A fixed, immutable string value that is defined at compile time and stored on the stack. They are declared using the &str type.

A flexible, mutable string value that can be changed at runtime and is stored on the heap. They are declared using the String type.

String objects can be created using methods like String::new() to initialize an empty string or String::from() to create a string with a default value.

A reference to a portion of a string, allowing access to a substring without copying the entire string.

A heap-allocated, mutable string data structure, allowing dynamic resizing and modification.

A static, immutable string slice that exists for the entire program execution and is stored on the stack.

The standard encoding used by Rust's String objects to represent characters from different languages.

The process of allocating memory for mutable data structures like String objects during program execution.

Memory allocated in Rust by default, used for local variables within function calls. Fast but limited in size.

Memory explicitly allocated by the program. Slower than the stack, but it's globally accessible and effectively unlimited in size.

To store data that needs to be accessed across different functions or persist longer than a single function's execution.

A data type in Rust that allows you to store a value on the heap.

A mechanism that ensures each piece of data in Rust has a single owner, managing memory safety and preventing data corruption.

Transferring ownership of data from one variable to another.

Creating a copy of data, allowing multiple variables to own the same data.

Creating a copy of simple data types (like integers or booleans) without transferring ownership.

The & symbol in Rust indicates a reference to a value. It allows functions to borrow data without moving ownership, enabling efficient code and reducing memory consumption.

A reference to a value in Rust. Borrowing allows functions to use a value without transferring ownership, ensuring the data remains accessible in the original scope.

References are essential in Rust for avoiding unnecessary copying, enhancing performance, and maintaining data integrity. They allow functions to access and modify data without duplicating it.

In Rust, the type of an argument passed to a function determines how it will be used. A borrowed reference (&T) allows the data to be reused, while moving ownership (T) transfers the data to the called function.

Functions can return multiple values using tuples in Rust. This allows returning relevant information related to the function's purpose.

The calculate_length function demonstrates the use of a tuple to return both the original string and its calculated length.

In Rust, String literals (&str) are immutable and stored on the stack, while String objects are mutable, heap-allocated, and allow dynamic resizing.

A way to call a function on an instance of a struct. It involves using a dot (.) followed by the function name, parentheses, and any necessary parameters.

A special parameter within a function defined within an 'impl' block for a struct. It represents the specific instance of the struct that called the function.

A block of code that defines methods and associated functions for a struct. It begins with the 'impl' keyword and specifies the struct type it applies to.

A data type that represents a fixed set of possible values. These values are named and can be used to represent various types within a single enumeration.

IP addresses are either IPv4 or IPv6, with distinct formats and structures. They're represented by enums like 'IpAddrKind' to ensure type safety.

Enums enforce type safety by ensuring that only valid values from the defined set can be assigned. This prevents errors related to incompatible data types.

Enums are more suitable than structs when representing a set of fixed, distinct values. They directly represent the possible states of a concept, improving clarity and maintainability.

Enums improve code readability and maintainability by clearly representing different possibilities within a single type. They ensure type safety and make the code less prone to errors.