// lvalue examples
int i = 7;  // i: lvalue
int *pi = &i;  // i is addressable
i = 10;  // we can modify it

class cat {};
cat c;   // c is an lvalue for a user defined type 

// rvalue examples
int i = 7;  // i: lvalue but 7 is rvalue
int k = i+3;  // (i+3) is an rvalue 
int *pi = &(i + 3); // error, it's not addressable
i + 3 = 10;   // error - cannot assign a value to it
3 = i;        // error - not assignable

class cat {};
c = cat();   // cat() is an rvalue

int square(int x) { return x*x;  }
int sq = square(10);  // square(10) is an rvalue

How about a reference, is it a rvalue or a lvalue?

The references that we've been using are lvalue references - references to lvalues. The lvalues references can only be bound to lvalues but not rvalues.

int i;
int &r; = i;
int &r; = 7; // error: lvalue cannot be bound to rvalue 7

However, we can bind an rvalue to a const lvalue reference (const reference):

const int&r; = 7;  // OK

It's legal since when a compiler sees const, it converts 7 to an lvalue, and then assign it to the reference.

The rule "lvalue references can only be bound to lvalues but not rvalues" equally applies to an argument to a function:

int square(int& x) { return x*x;  }
int i = 7;
square(i);  // OK
square(7);  // error, 7 is an rvalue and cannot be assigned to a reference

Is there a way to pass 7 to the square function? Seems I've seen it working.

Yes, we can. The const is here for us!

int square(const int& x) { return x*x;  }
square(i);  // OK
square(7);  // OK

default

If a class is defined with any constructors, the compiler will not generate a default constructor. This is useful in many cases, but it is some times vexing. For example, we defined the class as below:

class A
{
public:
    A(int a){};
};

Then, if we do:

A a;

The compiler complains that we have no default constructor. That's because compiler did not make the one for us because we've already had one that we defined.

class A
{
public:
    A(int a){}
    A() = default;
};

Then, compiler won't complain for this any more:

A a;

Suppose we have a class with a constructor taking an integer:

class A
{
public:
    A(int a){};
};

Then, the following three operations will be successful:

A a(10);     // OK
A b(3.14);   // OK  3.14 will be converted to 3
a = b;       // OK  We have a compiler generated assignment operator

However, what if that was not we wanted. We do not want the constructor allow double type parameter nor the assignment to work.

C++11 allows us to disable certain features by using delete:

class A
{
public:
    A(int a){};
    A(double) = delete;         // conversion disabled
    A& operator=(const A&) = delete;  // assignment operator disabled
};

Then, if we write the code as below:

A a(10);     // OK
A b(3.14);   // Error: conversion from double to int disabled
a = b;       // Error: assignment operator disabled

In that way, we could achieve what we intended.

Qt Quick Application use for to design this UI using the Qt QML language. To run this application using the Qt5.15.x version .

Basically, this UI will teach you how to design component or customize the component according to as per the need.

Qt Quick Application use for to design this UI using the Qt QML language. To run this application using the Qt5.15.x version .

Basically, this UI will teach you how to design component or customize the component according to as per the need.

Note :You can find the whole source code on my github.