Value semantics and copy

In plain English

In C++ an object is a value, which means a variable owns its own storage and copying it makes a full, independent duplicate. A stack object lives inside a function and is destroyed automatically when the function returns, which is the simplest kind of ownership. When you copy an object, the copy constructor runs, and when you assign to an existing object, the copy assignment operator runs instead. Passing by value makes a copy, while passing by reference lets the function use the original object without copying it.

Step by step

1. 1Declare a class that owns a std::string member.
2. 2Add a copy constructor that copies every member from another instance.
3. 3Add a copy assignment operator that copies members into an existing object.
4. 4Write one function that takes the object by const reference and another that takes it by value.
5. 5Observe that by-value makes a copy while by-reference does not.

#include <iostream>
#include <string>

class Course {
public:
    Course(std::string title) : title_(title) {}

    Course(const Course& other) : title_(other.title_) {}

    Course& operator=(const Course& other) {
        title_ = other.title_;
        return *this;
    }

    const std::string& title() const { return title_; }

private:
    std::string title_;
};

void read(const Course& course) {
    std::cout << course.title() << "\n";
}

void keep(Course course) {
    std::cout << course.title() << "\n";
}

int main() {
    Course a{"HTML"};
    Course b = a;
    Course c{"CSS"};
    c = a;
    read(a);
    keep(a);
}

Common mistakes

• Passing a large object by value copies it needlessly, which slows the program down.
• Confusing copy construction with copy assignment is common; construction builds a brand new object while assignment overwrites one that already exists.
• Forgetting to copy a member in your copy constructor leaves that field with the wrong value in the copy.
• Assuming a copy shares storage with the original is wrong; a correct copy is fully independent.