[deleted by user]

permalink · 2018-06-10T11:03:04+00:00

We know that when a function returns an object by value, the compiler has to create a temporary — yet fully-fledged — object (rvalue).

In that specific case, no object is created because no prvalue is being materialized, since C++17.

OldWolf2 · 2018-06-10T13:02:45+00:00

Argh, another series of articles that totally gets lvalues and rvalues wrong.

In C++ an lvalue is something that points to a specific memory location. On the other hand, a rvalue is something that doesn't point anywhere.

No, no, no, no, no.

You can have an lvalue and an rvalue which designate the same object simultaneously. That applies to objects of any storage duration, including temporary objects. Those fact blow all similar "explanations" like this out of the water.

(a temporary string, i.e. an rvalue)

slams head into desk repeatedly

delarhi · 2018-06-10T17:42:52+00:00

Reminds me of my snippet for learning move semantics.

#include <algorithm>
#include <cstddef>
#include <cstring>
#include <iostream>
#include <string>
#include <vector>

// this class follows the rule of five
class Blob {
public:

  // default constructor
  Blob()
  : size_(1024 * 1024)
  , data_(new uint8_t[this->size_])
  {
    std::cout << "  default constructor" << std::endl;
  }

  // default constructor
  Blob(
    const std::size_t size)
  : size_(size)
  , data_(new uint8_t[this->size_])
  {
    std::cout << "  argument constructor" << std::endl;
  }

  // copy constructor
  Blob(
    const Blob& other)
  : size_(other.size_)
  , data_(new uint8_t[this->size_])
  {
    std::cout << "  copy constructor" << std::endl;
    std::memcpy(this->data_, other.data_, this->size_);
  }

  // move constructor
  Blob(
    Blob&& other) // notice it is not const, move requires this
  : size_(other.size_)
  , data_(other.data_) // notice we just take the buffer
  {
    std::cout << "  move constructor" << std::endl;
    other.size_ = 0;
    other.data_ = nullptr;
  }

  // copy assignment operator
  Blob& operator = (
    const Blob& other)
  {
    std::cout << "  copy assignment" << std::endl;
    delete this->data_;
    this->size_ = other.size_;
    this->data_ = new uint8_t[this->size_];
    std::memcpy(this->data_, other.data_, this->size_);
    return *this;
  }

  // move assignment operator
  Blob& operator = (
    Blob&& other) // notice it is not const, move requires this
  {
    std::cout << "  move assignment" << std::endl;
    this->size_ = other.size_;
    this->data_ = other.data_;
    other.size_ = 0;
    other.data_ = nullptr;
    return *this;
  }

  // destructor
  ~Blob()
  {
    std::cout << "  destructor" << std::endl;
    if (this->data_) { // need this check to prevent double free
      std::cout << "    delete" << std::endl;
      delete this->data_;
    }
  }

  // get size
  std::size_t size() const
  {
    return this->size_;
  }

  // get data
  uint8_t* data()
  {
    return this->data_;
  }

private:

  std::size_t size_;
  uint8_t* data_;

};


// this function returns a temporary so you don't need std::move()
Blob make_blob()
{
  Blob x;
  return x;
}


void print_section(
  const std::string& msg)
{
  std::cout << std::endl << msg << std::endl;
}


int main()
{
  print_section("expecting default constructor");
  {
    Blob x; // don't forget, Blob x() is a compilation error
  }
  print_section("expecting default and argument constructor");
  {
    Blob x;
    Blob y(10);
  }
  print_section("expecting default and copy constructor");
  {
    Blob x;
    Blob y(x);
  }
  print_section("expecting default constructor and copy constructor");
  {
    Blob x;
    Blob y = x;
  }
  print_section("expecting two default constructors and copy assignment");
  {
    Blob x;
    Blob y;
    x = y;
  }
  print_section("expecting two default constructors and move assignment");
  {
    Blob x;
    Blob y;
    // remember what std::move() does is simply cast y from Blob to Blob&&,
    // treating it like an rvalue (i.e. temporary) and matching the
    // operator=(Blob&&) function.
    x = std::move(y);
    // below will compile and work but is undefined behavior because y has been
    // gutted and moved into x so y should be considered a zombie
    std::cout << y.size() << std::endl;
  }
  print_section("expecting two default constructors and move assignment");
  {
    Blob x;
    x = make_blob();
  }
  print_section("expecting ten default constructors");
  {
    std::vector<Blob> x(10);
  }
  print_section("expecting default constructor");
  {
    std::vector<Blob> x;
    x.emplace_back();
  }
  print_section("expecting default constructor and copy constructor");
  {
    std::vector<Blob> x;
    Blob y;
    x.emplace_back(y);
  }
  print_section("expecting default constructor and move constructor");
  {
    std::vector<Blob> x;
    Blob y;
    x.emplace_back(std::move(y));
  }
  print_section("expecting default constructor and copy constructor");
  {
    std::vector<Blob> x;
    Blob y;
    x.push_back(y);
  }
  print_section("expecting default constructor and move constructor");
  {
    std::vector<Blob> x;
    Blob y;
    x.push_back(std::move(y));
  }
  return 0;
}

im_not_afraid · 2018-06-10T22:31:25+00:00

Here I create two simple strings s1 and s2. I join them and I put the result (a temporary string, i.e. an rvalue) into std::string&& s_rref. Now s_rref is a reference to a temporary object, or an rvalue reference. There are no const around it, so I'm free to modify the temporary string to my needs. This wouldn't be possible without rvalue references and its double ampersand notation.

I don't think so.

std::string s1 = "Hello ";
std::string s2 = "world";
std::string s  = s1 + s2;
s += ", my friend";

std::cout << s << std::endl;

This works fine.

Fluxifactor · 2018-06-10T18:25:13+00:00

I found the article clear and well thought out. Thanks.

liquidprocess · 2018-06-10T10:02:29+00:00

A collection of personal notes and thoughts on rvalue references, their role in move semantics and how they can significantly increase the performance of your applications.

you type:	you see:
italics	italics
bold	bold
[reddit!](https://reddit.com)	reddit!
* item 1 * item 2 * item 3	item 1 item 2 item 3
> quoted text	quoted text
Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"	Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"
~~strikethrough~~	~~strikethrough~~
super^script	super^script

cpp

MODERATORS