What will happen if you copy an object of type…

The contents of the string (characters after the \0 symbol are not copied) will be copied into a new std::string object. The copying is performed element-wise.

#include <string>
#include <iostream>

int main() {
    std::string original = "Hello, world!";
    std::string copy = original; // Copy occurs

    std::cout << "Original: " << original << std::endl;
    std::cout << "Copy: " << copy << std::endl;

    // Changing the copy does not affect the original
    copy[0] = 'h';
    std::cout << "Original after copy modification: " << original << std::endl;
    std::cout << "Copy after copy modification: " << copy << std::endl;

    return 0;
}

Features:

Deep copy: By default, std::string performs a deep copy of the data. This means a new memory area is allocated for the characters of the copied string, not just copying the pointer to the same data.
Object independence: After copying, the original and new std::string objects become independent. Modifying one does not affect the other.
Runtime: The time complexity of the copy operation is proportional to the length of the string (O(N), where N is the string length).
Copy constructor and assignment operator: Copying is done using the copy constructor or the operator=. std::string implements them by default or provides specialized versions that perform deep copying.
SSO (Small String Optimization): For small strings, std::string may use Small String Optimization. In this case, the characters are stored directly within the std::string object itself, not in dynamically allocated memory. Copying with SSO is faster because it does not require memory allocation. However, the behavior of "deep copy" remains.

// Demonstration of deep copying (without SSO)
#include <string>
#include <iostream>
#include <memory> // For getting memory address

int main() {
    std::string original = "This is a relatively long string to avoid SSO.";
    const char* original_data_ptr = original.c_str(); // Address of original data

    std::string copy = original; // Copy

    const char* copy_data_ptr = copy.c_str(); // Address of copied data

    std::cout << "Original string: " << original << std::endl;
    std::cout << "Original data address: " << static_cast<const void*>(original_data_ptr) << std::endl;

    std::cout << "Copied string: " << copy << std::endl;
    std::cout << "Copied data address: " << static_cast<const void*>(copy_data_ptr) << std::endl;

    // Addresses should be different for deep copy (for strings longer than SSO limit)
    if (original_data_ptr != copy_data_ptr) {
        std::cout << "Addresses are different (deep copy or SSO involved)." << std::endl;
    } else {
         // With SSO, addresses may be the same within the string object,
         // but the data is physically duplicated inside the string structure
         std::cout << "Addresses might be same due to SSO or internal implementation." << std::endl;
    }


    return 0;
}

What will happen if you copy an object of type string?