Modern C++: Move Semantics

std::vector<std::string> vec;
vec.reserve(3);

std::string s(getData());

vec.push_back(s);

// temporary object will be created and destory
vec.push_back(getData());

std::string read_str;
std::vector<std::string> read_vec;
while(std::getline(my_stream, read_str)) {      // read a line to read_str
    read_vec.push_back(read_str);               // copy it to the element of read_vec
}

std::string read_str;
std::vector<std::string> read_vec;
while(std::getline(my_stream, read_str)) {      // read a line to read_str
    read_vec.push_back(std::move(read_str));    // move it to the element of read_vec
}

void swap(std::string& a, string& b) {
    std::string temp(std::move(a));
    a = std::move(b);
    b = std::move(temp);
}

template <typename T>
class vector {
    public:
        void push_back(const T& elem);
}

std::vector<std::string> vec;
std::string str = getData();

vec.push_back(s);           // copy s into vec
vec.push_back(getData());   // unnecessary copy into vec
vec.push_back(s+s);         // unnecessary copy into vec
vec.push_back(s);           // no longer need s, unnecessary copy into vec

template <typename T>
class vector {
    public:
        void push_back(const T& elem);
        void push_back(const T&& elem);
}

class string {
    private:
        int len;
        char* data;
    public:
        // create a full copy of s
        string(const string& s)
        : len(s.len) {
            if(len > 0) {
                data = new char[len + 1]
                memcpy(data, s.data, len+1)
            }
        }

        //create a copy of s with content moved
        string (string&& s)
        : len(s.len),       // copy length and
          data(s.data) {    // copy pointer to memory
            // erase the memory at source to move ownership
            s.data = nullptr;
            s.len = 0;
        } 
}

class Foo {
    private:
        std::string first;
        std::string last;
        int val;
  public:
        Foo(const std::string& f, const std::string l, int v): first{f}, last{l}, val{v} {   
        }
    // no copy constructor/assignment 
    // no move constructor/assignment
    // no destructor

    
    // If declared copy constructor/assignment, move fall back to copy constuctor/assignment
    Foo(const Foo& f): first{f.first}, last{f.last}, val{f.val} {}
    
    
    // If declared move constructor/ assignment, copy constuctor/assignment deleted because of speical user-declared speoical move member function
    Foo(Foo&& f) noexcept
        : first{std::move(f.first)}, last{std::move(f.last)}, val{f.val} {
        f.val *= -1
    }
    
    // Then move semantics is enabled 
}

std::vector<Foo> vec;
vec.push_back(Foo{"Dwayne", "Johnson", 44}); // create object and copy/move into vec;