Lvalue и rvalue

class A
{
public:
    A() = default;
    void setName(const std::string& name)
    {
        m_Name = name;
    }
 
    void setName(std::string&& name)
    {
        m_Name = std::move(name);
    }
private:
    std::string m_Name;
};

int main()
{
    A a;
    std::string name{"another name"};
    a.setName("New name");//№1
    a.setName(name);//№2
    return 0;
}

void setName(std::string&& name)
    {
        m_Name = std::move(name);
    }

a.setName("New name");

m_Name = name;

void SetName(std::string&& s)
{
    std::string&& ref=s;//Ошибка
...

void setName(std::string&& name)
{
    m_Name = std::move(name);//Вызовется operator=(string&&)
    m_Name = name;//Вызовется operator=(string&), т.к. name - lvalue
}

int main()
{
* * A a;
* * std::string name{"another name"};
* * a.setName("New name"); // не №1, а №2
* * a.setName(name); // не №2, а №1
* * return 0;
}

#include <iostream>
#include <chrono>
 
class Example
{
public:
 
    // default ctor
    Example() : pointer_{::new int[100500]} { }
 
    // copy ctor
    Example(Example const& other) : pointer_{::new int[100500]}
    {
        // в данном примере, лучше юзать std::memcpy, т.к. это интринсик
        // но на месте int, может быть любой другой класс
        // внимание тут надо акцентировать на том, что тут происходит копия
 
        for(std::size_t i = 0; i < 100500; ++i)
        {
            pointer_[i] = other.pointer_[i];
        }
    }
 
    // move ctor
    Example(Example&& other) : pointer_{other.pointer_}
    {
        // а тут надо акцентировать внимание на следующем:
        // 1) раз вызывается конструктор перемещения, значит переданный объект
        // является временным, в большинстве случаев (может быть и не временным, если вызвать std::move)
        // 2) значит мы можем просто забрать указатель на хранимые в нем данные и пропустить копирование
 
        other.pointer_ = nullptr;
    }
 
    ~Example() { ::delete pointer_; }
 
private:
    int* pointer_;
};
 
void call_copy_ctor(Example ex)
{
    // просто, чтобы заглушить warning от компилятора
    (void)ex;
 
    /* создается объект ex, с помощью копирования, затем уничтожается, исходный объект не портится */
}
 
void call_move_ctor(Example&& ex)
{
    // просто, чтобы заглушить warning от компилятора
    (void)ex;
 
    /* создается объект ex, с помощью перемещения, затем уничтожается, исходный объект обнуляется */
}
 
int main()
{
    Example arr[1000];
 
    auto start = std::chrono::high_resolution_clock::now();
    for(std::size_t i = 0; i < 1000; ++i)
    {
        call_copy_ctor(arr[i]);
    }
    auto end = std::chrono::high_resolution_clock::now();
 
    std::cout << "Time for copy: ";
    std::cout << std::chrono::duration_cast<std::chrono::nanoseconds>(end - start).count();
    std::cout << " nanoseconds." << std::endl;
 
    start = std::chrono::high_resolution_clock::now();
    for(std::size_t i = 0; i < 1000; ++i)
    {
        call_move_ctor(std::move(arr[i]));
    }
    end = std::chrono::high_resolution_clock::now();
 
    std::cout << "Time for move: ";
    std::cout << std::chrono::duration_cast<std::chrono::nanoseconds>(end - start).count();
    std::cout << " nanoseconds." << std::endl;
 
    return 0;
}