{"id":2287,"date":"2025-02-15T20:45:03","date_gmt":"2025-02-15T20:45:03","guid":{"rendered":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/?page_id=2287"},"modified":"2025-04-04T22:44:59","modified_gmt":"2025-04-04T22:44:59","slug":"variables-lvalues-and-rvalues","status":"publish","type":"page","link":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/index.php\/topics\/c-details\/variables-lvalues-and-rvalues\/","title":{"rendered":"Variables, lvalues, and rvalues"},"content":{"rendered":"\n

<\/span>Variables, lvalues, and rvalues<\/span><\/h2>\n\n\n\n

<\/span>Variables<\/span><\/h3>\n\n\n\n

A variable<\/em>, sometimes referred to as an object<\/em>, takes up memory space somewhere in a program.<\/p>\n\n\n\n

The following statements define variables:<\/p>\n\n\n\n

int miles_to_go;\ndouble milesPerGallon, price;\nstd::string name;\nVehicle myCar;<\/strong><\/code><\/pre>\n\n\n\n
Each variable definition comprises a type specifier<\/em> (int<\/strong>, double<\/strong>, etc.), followed by a comma-separated list of one or more names (miles_to_go<\/strong>, milesPerGallon<\/strong>, etc.), followed by a semicolon (;<\/strong>) that terminates the list.<\/p>\n\n\n\n
<\/span>Initialization<\/span><\/h4>\n\n\n\n
A definition may provide an initialization for the variable. Here are the various ways to initialize a variable:<\/p>\n\n\n\n
<\/span>Direct Initialization<\/span><\/h5>\n\n\n\n
Direct initialization uses parentheses, (). It was the standard way to initialize variables before C++11.<\/p>\n\n\n\n
int value(42); \/\/ direct-initialization<\/code><\/pre>\n\n\n\n
<\/span>Copy Initialization<\/span><\/h5>\n\n\n\n
Copy initialization uses an equal sign.<\/p>\n\n\n\n
int value = 42; \/\/ copy-initialization<\/code><\/pre>\n\n\n\n
One problem with the copy-initialization<\/em> option is that it confuses programmers because it looks like an assignment<\/em>, because it uses the =<\/strong> operator. It is important for C++ programmers not to confuse initialization<\/em> with assignment<\/em>. As we will see (in particular when we learn about classes), they are not the same.<\/p>\n\n\n\n
<\/span>List Initialization<\/span><\/h5>\n\n\n\n
List initialization uses braces, {}. It was introduced in C++11, to allow for more consistent and safe initialization.<\/p>\n\n\n\n
int value{42}; \/\/ list-initialization<\/code><\/pre>\n\n\n\n
This was called aggregate-initialization<\/em> before C++11. Since C++11, it is now called list-initialization<\/em>.<\/p>\n\n\n\n
List initialization is now the preferred way to initialize a variable, because:<\/p>\n\n\n\n
    \n
  • Improved type safety<\/strong> – generally prevents narrowing conversions, which can lead to unexpected behavior if a value is assigned to a variable of a smaller type.<\/li>\n\n\n\n
  • Readability<\/strong> – this syntax is often considered more intuitive and easier to read, especially when initializing with multiple values.<\/li>\n\n\n\n
  • Consistency<\/strong> – this syntax works in most cases, regardless of variable type.<\/li>\n<\/ul>\n\n\n\n
    If no initializer is specified for an object, the object is default-initialized. If no initializer is specified for a reference, the program is ill-formed.<\/p>\n\n\n\n
    \n
    There are some cases where a variable that has no initializer is not initialized at all. This means that the program behavior may be undefined — a common cause of bugs.<\/p>\n<\/blockquote>\n\n\n\n
    Examples:<\/p>\n\n\n\n
    \n
    \n
    <\/path><\/path><\/svg><\/span>
    #include<\/span> <\/span><string><\/span><\/span>\n <\/span><\/span>\nstd<\/span>::string s1;<\/span>           \/\/ default-initialization<\/span><\/span>\nstd<\/span>::<\/span>string<\/span> <\/span>s2<\/span>();<\/span>         \/\/ NOT an initialization!<\/span><\/span>\n                          \/\/ actually declares a function \u201cs2\u201d<\/span><\/span>\n                          \/\/ with no parameter and returns std::string<\/span><\/span>\nstd<\/span>::string s3 = <\/span>"hello"<\/span>;<\/span> \/\/ copy-initialization<\/span><\/span>\nstd<\/span>::<\/span>string<\/span> <\/span>s4<\/span>(<\/span>"hello"<\/span>);<\/span>  \/\/ direct-initialization<\/span><\/span>\nstd<\/span>::string s5{<\/span>'a'<\/span>};<\/span>      \/\/ list-initialization (since C++11)<\/span><\/span>\n <\/span><\/span>\nchar<\/span> <\/span>a<\/span>[<\/span>3<\/span>] = {<\/span>'a'<\/span>, <\/span>'b'<\/span>};<\/span> \/\/ aggregate initialization<\/span><\/span>\n                        \/\/ (part of list initialization since C++11)<\/span><\/span>\nchar<\/span>& c = <\/span>a<\/span>[<\/span>0<\/span>];<\/span>         \/\/ reference initialization<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
    <\/div>\n<\/div>\n\n\n\n
    As you can see, using parentheses is potentially confusing, and using copy-initialization<\/em> is often confused with assignment. <\/p>\n\n\n\n
    <\/span>lvalues and rvalues<\/span><\/h3>\n\n\n\n
    There are two kinds of expressions in C++:<\/p>\n\n\n\n
      \n
    • lvalue<\/em><\/strong> – An expression that may appear as either the left-hand or right-hand side of an assignment.<\/li>\n\n\n\n
    • rvalue<\/strong><\/em> – An expression that may appear on the right-hand side of an assignment, but not the left-hand side.<\/li>\n<\/ul>\n\n\n\n
      Numeric literals are rvalue<\/em><\/strong>s, and so may not be assigned to<\/p>\n\n\n\n
      int miles_to_go = 37, units = 502;\ndouble price = 42.0, milesPerGallon = 27;\n\nprice * units = total_price; \/\/ error: arithmetic expression is not an lvalue\n0 = 5; \/\/ error: literal constant is not an lvalue<\/code><\/pre>\n\n\n\n
      You may find that some errors or warnings issued by the compiler use the terms lvalue<\/em><\/strong> and rvalue<\/em><\/strong>, so it important to know their meanings.<\/p>\n\n\n\n
      <\/span>lvalue References and rvalue References<\/span><\/h3>\n\n\n\n
      Prior to C++11, only one type of reference existed in C++, and so it was known as \u201creference<\/em>\u201d. For better distinction, the ordinary reference X&<\/strong> is now called an lvalue reference<\/em>.<\/p>\n\n\n\n
      When lvalues<\/em> were originally defined, they were defined as \u201cvalues that are suitable to be on the left-hand side of an assignment expression\u201d<\/em>. However once the const keyword was added to the C++, lvalues<\/em> were split into \u2014<\/p>\n\n\n\n
        \n
      • modifiable lvalues<\/em><\/li>\n\n\n\n
      • non-modifiable lvalues<\/em> that are const<\/li>\n<\/ul>\n\n\n\n
        <\/span>Lvalue references<\/span><\/h4>\n\n\n\n
        A reference that binds to an lvalue,<\/strong> and is <\/strong>marked with a single ampersand (&). It acts as an alias for the bound object.<\/p>\n\n\n\n
        =========================================================\n \n int x{};\n const int y = 0; \/\/ or const int x {0};\n\n=========================================================\n\n\/\/ l-value references (Table 1)\n int &ref1{ x }; \/\/ OK\n int &ref2{ y }; \/\/ Error\n int &ref3{ 5 }; \/\/ Error\n\n=========================================================\n\n\/\/ lvalue references to const (Table 2)\n const int &ref4{ x }; \/\/ OK\n const int &ref5{ y }; \/\/ OK but can't modify\n const int &ref6{ 5 }; \/\/ OK\n int &ref7{ 5 }; \/\/ Error\n\n=========================================================<\/code><\/pre>\n\n\n\n
        Table 1<\/strong><\/p>\n\n\n
        \n\t\t\t
        \n\t\t\t\t<\/colgroup>\n\n\n\n
        \n
        Type of Values<\/p>\n<\/div><\/th>\n\n
        \n
        lvalue ref can be initialized<\/p>\n<\/div><\/th>\n\n
        \n
        lvalue ref can modify<\/p>\n<\/div><\/th>\n<\/tr>
        \n
        Modifiable lvalues<\/p>\n<\/div><\/td>\n\n
        \n
        Yes<\/p>\n<\/div><\/td>\n\n
        \n
        Yes<\/p>\n<\/div><\/td>\n<\/tr>
        \n
        Non-modifiable lvalues<\/p>\n<\/div><\/td>\n\n
        \n
        No<\/p>\n<\/div><\/td>\n\n
        \n
        No<\/p>\n<\/div><\/td>\n<\/tr>
        \n
        rvalues<\/p>\n<\/div><\/td>\n\n
        \n
        No<\/p>\n<\/div><\/td>\n\n
        \n
        No<\/p>\n<\/div><\/td>\n<\/tr><\/tbody><\/table>\n\t\t\t<\/div>\n\t\t<\/div>\n\n\n
        Table 2<\/strong><\/p>\n\n\n
        \n\t\t\t
        \n\t\t\t\t<\/colgroup>\n\n\n\n
        \n
        Type of Values<\/p>\n<\/div><\/th>\n\n
        \n
        lvalue ref to const can be initialized<\/p>\n<\/div><\/th>\n\n
        \n
        lvalue ref to const can modify<\/p>\n<\/div><\/th>\n<\/tr>
        \n
        Modifiable lvalues<\/p>\n<\/div><\/td>\n\n
        \n
        Yes<\/p>\n<\/div><\/td>\n\n
        \n
        No<\/p>\n<\/div><\/td>\n<\/tr>
        \n
        Non-modifiable lvalues<\/p>\n<\/div><\/td>\n\n
        \n
        Yes<\/p>\n<\/div><\/td>\n\n
        \n
        No<\/p>\n<\/div><\/td>\n<\/tr>
        \n
        rvalues<\/p>\n<\/div><\/td>\n\n
        \n
        Yes<\/p>\n<\/div><\/td>\n\n
        \n
        No<\/p>\n<\/div><\/td>\n<\/tr><\/tbody><\/table>\n\t\t\t<\/div>\n\t\t<\/div>\n\n\n
        <\/span>Rvalue References<\/span><\/h4>\n\n\n\n
        A reference that binds to an rvalue<\/strong>, and is marked with two ampersands (&&). It extends the life of the rvalue<\/em> temporary objects.<\/p>\n\n\n\n
        =========================================================\n\nint x{};\nconst int y = 0; \/\/ or const int x {0};\n\n=========================================================\n\n\/\/ r-value references (Table 3)\n int &&ref7{ x }; \/\/ Error\n int &&ref8{ y }; \/\/ Error\n int &&ref9{ 5 }; \/\/ OK\n ref9 = 6;        \/\/ OK\n\n=========================================================\n\n\/\/ r-value references to const (Table 4)\n const int &&ref10{ x }; \/\/ Error\n const int &&ref11{ y }; \/\/ Error\n const int &&ref12{ 5 }; \/\/ OK but can't modify\n\n=========================================================<\/code><\/pre>\n\n\n\n
        Table<\/strong> 3<\/strong><\/p>\n\n\n
        \n\t\t\t
        \n\t\t\t\t<\/colgroup>\n\n\n\n
        \n
        Type of Values<\/p>\n<\/div><\/th>\n\n
        \n
        rvalue ref can be initialized<\/p>\n<\/div><\/th>\n\n
        \n
        rvalue ref can modify<\/p>\n<\/div><\/th>\n<\/tr>
        \n
        Modifiable lvalues<\/p>\n<\/div><\/td>\n\n
        \n
        No<\/p>\n<\/div><\/td>\n\n
        \n
        No<\/p>\n<\/div><\/td>\n<\/tr>
        \n
        Non-modifiable lvalues<\/p>\n<\/div><\/td>\n\n
        \n
        No<\/p>\n<\/div><\/td>\n\n
        \n
        No<\/p>\n<\/div><\/td>\n<\/tr>
        \n
        rvalues<\/p>\n<\/div><\/td>\n\n
        \n
        Yes<\/p>\n<\/div><\/td>\n\n
        \n
        Yes<\/p>\n<\/div><\/td>\n<\/tr><\/tbody><\/table>\n\t\t\t<\/div>\n\t\t<\/div>\n\n\n
        Table 4<\/strong><\/p>\n\n\n
        \n\t\t\t
        \n\t\t\t\t<\/colgroup>\n\n\n\n
        \n
        Type of Values<\/p>\n<\/div><\/th>\n\n
        \n
        rvalue ref to const can be initialized<\/p>\n<\/div><\/th>\n\n
        \n
        rvalue ref to const can modify<\/p>\n<\/div><\/th>\n<\/tr>
        \n
        Modifiable lvalues<\/p>\n<\/div><\/td>\n\n
        \n
        No<\/p>\n<\/div><\/td>\n\n
        \n
        No<\/p>\n<\/div><\/td>\n<\/tr>
        \n
        Non-modifiable lvalues<\/p>\n<\/div><\/td>\n\n
        \n
        No<\/p>\n<\/div><\/td>\n\n
        \n
        No<\/p>\n<\/div><\/td>\n<\/tr>
        \n
        rvalues<\/p>\n<\/div><\/td>\n\n
        \n
        Yes<\/p>\n<\/div><\/td>\n\n
        \n
        No<\/p>\n<\/div><\/td>\n<\/tr><\/tbody><\/table>\n\t\t\t<\/div>\n\t\t<\/div>\n\n\n
        <\/p>\n","protected":false},"excerpt":{"rendered":"
        Variables, lvalues, and rvalues Variables A variable, sometimes referred to as an object, takes up memory space somewhere in a program. The following statements define variables: Each variable definition comprises a type specifier (int, double, etc.), followed by a comma-separated list of one or more names (miles_to_go, milesPerGallon, etc.), followed by a semicolon (;) that […]<\/p>\n","protected":false},"author":1,"featured_media":0,"parent":910,"menu_order":0,"comment_status":"closed","ping_status":"closed","template":"","meta":{"footnotes":""},"class_list":["post-2287","page","type-page","status-publish","hentry"],"blocksy_meta":[],"_links":{"self":[{"href":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/index.php\/wp-json\/wp\/v2\/pages\/2287","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/index.php\/wp-json\/wp\/v2\/pages"}],"about":[{"href":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/index.php\/wp-json\/wp\/v2\/types\/page"}],"author":[{"embeddable":true,"href":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/index.php\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/index.php\/wp-json\/wp\/v2\/comments?post=2287"}],"version-history":[{"count":10,"href":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/index.php\/wp-json\/wp\/v2\/pages\/2287\/revisions"}],"predecessor-version":[{"id":2366,"href":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/index.php\/wp-json\/wp\/v2\/pages\/2287\/revisions\/2366"}],"up":[{"embeddable":true,"href":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/index.php\/wp-json\/wp\/v2\/pages\/910"}],"wp:attachment":[{"href":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/index.php\/wp-json\/wp\/v2\/media?parent=2287"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}