I have found a really good resource for learning C++ on Youtube: CopperSpice! It has a suitable amount of information: not too much, and not too little. Great!😀👍

I have been reading and writing C++ code extensively for these two years. I like this language: it’s fast, giving developers a great deal of details and control, and it also has a huge community. However, unlike Python, it’s easy to make you scratch your head and hard to understand what’s going on.

I will take notes of some interesting topics when I have learned something new.

Get Started

Reference in C++ is a data type. when initialized, reference always represent that memory, like an alias, it cannot change its representation any more.

#include <iostream>

struct Point {
    float x;
    float y;
    float z;
    Point(){}
    Point(float x, float y, float z): x(x), y(y), z(z) {}
};

int main()
{
    Point p1 = Point();
    Point p2 = Point();
    Point& p_ref = p1;  // alias name of p1
    p_ref = p2;  // copy p2's value to p1; not to make a reference of p2
    std::cout << (&p_ref == &p1) << std::endl;   // 1
    std::cout << (&p_ref == &p2) << std::endl;  // 0
}

A pointer is different, you can change that pointer’s value, so you can change the memory it points to. Pointers have less limites, so they are more powerful.

#include <iostream>

struct Point {
    float x;
    float y;
    float z;
    Point(): x(0), y(0), z(0) {}
    Point(float x, float y, float z): x(x), y(y), z(z) {}
};

int main()
{
    Point p1 = Point();
    Point p2 = Point();
    Point* p_ptr = &p1;  // points to p1
    *p_ptr = p2;  // you can also copy value to p1 using this way
    p_ptr = &p2;  // then points to p2
    std::cout << (p_ptr == &p1) << std::endl;   // 0
    std::cout << (p_ptr == &p2) << std::endl;   // 1
}

Expression and Value Catogory

Expression is characterized by two factors:

• data type
• value category

Value catogory is either lvalue or rvalue. There is more in fact, but that’s not important unless you are writing a compiler. So save your time.

When a expression satisfy one of these rules:

• has a name
• has a memory location
• can get its address

then it’s a lvalue, otherwise it’s a rvalue.

You can assign value to lvalue, but can’t do it to rvalue. lvalue and rvalue can both be assigned to a lvalue. So, lvalue are more powerful. Because lvalue has a explicit memory, it is assignable and its lifetime is more stable.

But why make a distinction between lvalue and rvalue? The compiler can use these information to generate more performant binary and check errors easily.

Types of References

References have three types:

• lvalue reference
• const reference
• rvalue reference

Things become a bit of tricky. In fact, these names are so confusing, this is why my hair is getting less.😇

I want to put it in this way: As a data type, References have three types:

• reference for lvalue
• reference for both, but guarentees it won’t change
• reference for rvalue

reference for lvalue:

void PrintPoint(Point& p)
{
    std::cout << "Point(" << p.x << "," << p.y << "," << p.z << ")\n";
}

int main()
{
    Point p1 = Point();
    PrintPoint(p1);  // lvalue: valid
    PrintPoint(Point{});  // rvalue: invalid
}

reference for both:

void PrintPoint(const Point& p)
{
    std::cout << "Point(" << p.x << "," << p.y << "," << p.z << ")\n";
}

int main()
{
    Point p1 = Point();
    PrintPoint(p1);       // lvalue: valid
    PrintPoint(Point{});  // rvalue: valid
}

reference for rvalue:

void PrintPoint(Point&& p)
{
    std::cout << "Point(" << p.x << "," << p.y << "," << p.z << ")\n";
}

int main()
{
    Point p1 = Point();
    PrintPoint(p1);       // lvalue: invalid
    PrintPoint(Point{});  // rvalue: valid
}

Done.

But that’s a little strange. The problem is: why do I need a reference for rvalue?

Modern C++ uses rvalue references to implement move operations that can avoid unneccesary copying.

Back to Basics: Understanding Value Categories – Ben Saks – CppCon 2019

OK. I see. Now, imagine, we have a big rvalue already, which has a huge temporary object. we can reuse that temporary object, by assigning it to a rvalue reference. Now, this object has been binded to this rvalue reference(its lifetime is well defined now), and there is no any copying.

Const Qualifier

I also find const very confusing when they are not in the first location of that declaration.😀 Let’s clarify it.

• const variable
• pointer to const
• const pointer
• reference to const
• const method

Const Variable

The easiest part, const variable:

const Point p1 = Point();
p1 = Point();  // Can't compile

Pointer to Const

In this form, const is before Point, so it means: guarentee the pointer can’t change this Point object.

Point p1 = Point();
const Point* ptr = &p1;

ptr->x = 10;  // Invalid: guaratee you can't use this pointer to change the object
p1.y = 6;  // Valid: this object may change by itself

Point p2 = Point();
ptr = &p2;  // Valid: Can point to another object

Const Pointer

In this form, const is before the pointer, so it means: guarentee the pointer itself can’t change.

Point p1 = Point();
Point* const ptr = &p1;

ptr->x = 10;  // Valid: have nothing to do with the object it points
Point p2 = Point();
ptr = &p2;  // Invalid: Can't point to another object

Reference to Const

Reference is a little easier. Because reference can’t be assigned once, it’s invalid to do this:

Point p1 = Point();
Point& const ref = p1;  // Invalid: can't apply const to reference type

So const can only constrain the Point object:

Point p1 = Point();
const Point& ref = p1;

//ref.x = 10;  // Invalid: guaratee you can't use this reference/alias to change the object
p1.y = 6;  // Valid: this object may change by itself
Point p2 = Point();
ref = p2;  // Invalid: reference can't bind to another object based on its own rules

Const method

const method is also easy, it means: this method won’t change the object’s status.

struct Point {
    float x;
    float y;
    float z;
    Point(): x(0), y(0), z(0) {}
    Point(float x, float y, float z): x(x), y(y), z(z) {}
    float GetX() const { return x; }  // Valid
    void SetX(float val) const { x = val; }  // Invalid
};

Const vs Constexpr

I think Modern C++ (value categories) has already summarized very clearly.

• const: means “promised no to change”
• constexpr: means “known at compile time”

Clearly constexpr can help compiler preprocess the source code to gain more performance. So use constexpr if you can.

That’s today’s C++ learning experience. Keep going on. Good luck!💪

References

• Modern C++ (data types, references)
• Modern C++ (value categories)
• C++ Rvalue References Explained
• Back to Basics: Understanding Value Categories – Ben Saks – CppCon 2019