I have some questions:

• When passing a struct as a function parameter, it is passed a copy or a reference?
  • A struct is passed as a copy
• When passing a object as a function parameter, it is passed a copy or a reference?
  • A object is sent as a copy
  • But keep in mind, that when they get destroyed, they use the destructor
• When passing an array as a function parameter, it is passed a copy or a reference?
  • Arrays are pointers basically. So is always sent a reference

#include <iostream>

struct MyStruct {
    int value;
};

// Function that takes MyStruct by value (copy)
void modifyByValue(MyStruct s) {
    s.value = 100;
    std::cout << "Inside modifyByValue: " << s.value << std::endl;
}

// Function that takes MyStruct by reference
void modifyByReference(MyStruct* s) {
    s->value = 200;
    std::cout << "Inside modifyByReference: " << s->value << std::endl;
}

int main() {
    MyStruct s1 {10}; // Initialize struct with value 10
    
    std::cout << "Before modifyByValue: " << s1.value << std::endl;
    modifyByValue(s1); // Pass by copy
    std::cout << "After modifyByValue: " << s1.value << std::endl;

    std::cout << "\nBefore modifyByReference: " << s1.value << std::endl;
    modifyByReference(&s1); // Pass by reference
    std::cout << "After modifyByReference: " << s1.value << std::endl;

    return 0;
}

#include <iostream>

class MyClass {
public:
    int value;

    MyClass(int val) : value(val) {}

    void display() const {
        std::cout << "Value: " << value << std::endl;
    }
};

// Function that takes MyClass object by value (copy)
void modifyByValue(MyClass obj) {
    obj.value = 100;
    std::cout << "Inside modifyByValue: ";
    obj.display();
}

// Function that takes MyClass object by reference
void modifyByReference(MyClass& obj) {
    obj.value = 200;
    std::cout << "Inside modifyByReference: ";
    obj.display();
}

int main() {
    MyClass obj(10);  // Initialize object with value 10
    
    std::cout << "Before modifyByValue: ";
    obj.display();
    modifyByValue(obj);  // Pass by copy
    std::cout << "After modifyByValue: ";
    obj.display();

    std::cout << "\nBefore modifyByReference: ";
    obj.display();
    modifyByReference(obj);  // Pass by reference
    std::cout << "After modifyByReference: ";
    obj.display();

    return 0;
}

#include <stdio.h>

// Function that takes an array as a pointer and modifies it
void modifyArray(int arr[], int size) {
    for (int i = 0; i < size; ++i) {
        arr[i] += 10;  // Modify each element in the array
    }
    printf("Inside modifyArray: ");
    for (int i = 0; i < size; ++i) {
        printf("%d ", arr[i]);
    }
    printf("\n");
}

// Another way to declare the function, emphasizing it's a pointer
void modifyArrayPointer(int *arr, int size) {
    for (int i = 0; i < size; ++i) {
        arr[i] += 20;  // Further modify each element
    }
    printf("Inside modifyArrayPointer: ");
    for (int i = 0; i < size; ++i) {
        printf("%d ", arr[i]);
    }
    printf("\n");
}

int main() {
    int arr[] = {1, 2, 3, 4, 5};  // Initialize array
    int size = sizeof(arr) / sizeof(arr[0]);  // Calculate array size

    printf("Before modifyArray: ");
    for (int i = 0; i < size; ++i) {
        printf("%d ", arr[i]);
    }
    printf("\n");

    modifyArray(arr, size);  // Pass array to modifyArray

    printf("After modifyArray: ");
    for (int i = 0; i < size; ++i) {
        printf("%d ", arr[i]);
    }
    printf("\n");

    modifyArrayPointer(arr, size);  // Pass array to modifyArrayPointer

    printf("After modifyArrayPointer: ");
    for (int i = 0; i < size; ++i) {
        printf("%d ", arr[i]);
    }
    printf("\n");

    return 0;
}