{"id":2258,"date":"2025-02-10T22:48:55","date_gmt":"2025-02-10T22:48:55","guid":{"rendered":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/?page_id=2258"},"modified":"2025-02-15T17:43:06","modified_gmt":"2025-02-15T17:43:06","slug":"const-volatile-mutable-and-more","status":"publish","type":"page","link":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/index.php\/topics\/c-details\/const-volatile-mutable-and-more\/","title":{"rendered":"const, volatile, mutable, and More"},"content":{"rendered":"\n

<\/span>const, volatile, mutable, and More<\/span><\/h2>\n\n\n\n

In C++, const<\/strong>, volatile<\/strong>, and mutable<\/strong> are type qualifiers that modify the behavior of variables.<\/p>\n\n\n\n

<\/span>const<\/span><\/h3>\n\n\n\n

const<\/strong> specifies that a variable’s value cannot be changed after initialization. Any attempt to modify a const<\/strong> variable will result in a compile-time error.<\/p>\n\n\n\n

<\/span>volatile<\/span><\/h3>\n\n\n\n

volatile<\/strong> indicates that a variable’s value can be changed by external factors outside the control of the program, such as hardware or another thread. It prevents the compiler from performing optimizations that might assume the variable’s value remains constant.<\/p>\n\n\n\n

<\/span>mutable<\/span><\/h3>\n\n\n\n

mutable<\/strong> applies only to class members and allows modification of a member variable even within a const<\/strong><\/code> object. It is useful when a class has internal state that needs to be updated without affecting the object’s externally visible const<\/strong>-ness.<\/p>\n\n\n\n

mutable<\/strong> may not be used in combination with static<\/strong> or const<\/strong><\/p>\n\n\n\n

<\/span>Some C++ Specification Jargon<\/span><\/h3>\n\n\n\n

Here is some jargon from the C++ specification which may be a little esoteric, but you may find this jargon used in some compiler error and warning messages.<\/p>\n\n\n\n

\n

<\/span>cv (const and volatile) type qualifiers<\/span><\/h4>\n\n\n\n

Any (possibly incomplete) type other than function type or reference type is a type in a group of the following four distinct but related types:<\/p>\n\n\n\n

    \n
  • A cv-unqualified<\/em> version.<\/li>\n\n\n\n
  • A const-qualified<\/em> version.<\/li>\n\n\n\n
  • A volatile-qualified<\/em> version.<\/li>\n\n\n\n
  • A const-volatile-qualified<\/em> version.<\/li>\n<\/ul>\n\n\n\n

    Array types are considered to have the same cv-qualification<\/em> as their element types.<\/p>\n\n\n\n

    A const volatile object<\/em> is:<\/p>\n\n\n\n

      \n
    • an object whose type is const-volatile-qualified<\/em>,<\/li>\n\n\n\n
    • a non-mutable subobject of a const volatile object,<\/li>\n\n\n\n
    • a const subobject of a volatile object, or<\/li>\n\n\n\n
    • a non-mutable volatile subobject of a const object.<\/li>\n<\/ul>\n\n\n\n

      Behaves as both a const<\/strong> object and as a volatile<\/strong> object.<\/p>\n<\/blockquote>\n\n\n\n

      <\/span>Examples<\/span><\/h3>\n\n\n\n

      The following program exhibits a number of compile-time errors:<\/p>\n\n\n\n

      <\/path><\/path><\/svg><\/span>
      \/\/<\/span><\/span>\n\/\/  main.cpp<\/span><\/span>\n\/\/  const, volatile, mutable<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 2\/10\/25.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#<\/span>include<\/span> <<\/span>iostream<\/span>><\/span><\/span>\n<\/span>\nclass<\/span> <\/span>Example<\/span> <\/span><\/span>\n{<\/span><\/span>\npublic<\/span>:<\/span><\/span>\n  <\/span>Example<\/span>(<\/span>int<\/span> <\/span>a<\/span>, <\/span>int<\/span> <\/span>b<\/span>, <\/span>int<\/span> <\/span>c<\/span>)<\/span><\/span>\n    : <\/span>constVar<\/span>(<\/span>a<\/span>), <\/span>nonConstVar<\/span>(<\/span>b<\/span>), <\/span>volatileVar<\/span>(<\/span>c<\/span>), <\/span>mutableVar<\/span>(0)<\/span><\/span>\n  {}<\/span><\/span>\n<\/span>\n  <\/span>void<\/span> <\/span>modify<\/span>() <\/span><\/span>\n  {<\/span><\/span>\n    <\/span>nonConstVar<\/span> = <\/span>10<\/span>; <\/span>\/\/ OK<\/span><\/span>\n    <\/span>constVar<\/span> = <\/span>20<\/span>; <\/span>\/\/ Cannot assign to non-static data member 'constVar' with const-qualified type 'const int'<\/span><\/span>\n                   <\/span>\/\/ Non-static data member 'constVar' declared const<\/span><\/span>\n    <\/span>volatileVar<\/span> = <\/span>30<\/span>; <\/span>\/\/ OK<\/span><\/span>\n    <\/span>mutableVar<\/span> = <\/span>40<\/span>; <\/span>\/\/ OK<\/span><\/span>\n  }<\/span><\/span>\n<\/span>\n  <\/span>void<\/span> <\/span>constModify<\/span>() const<\/span><\/span>\n  {<\/span><\/span>\n    <\/span>nonConstVar<\/span> = <\/span>10<\/span>;<\/span><\/span>\n    <\/span>constVar<\/span> = <\/span>20<\/span>; <\/span>\/\/ Cannot assign to non-static data member within const member function 'constModify'<\/span><\/span>\n                   <\/span>\/\/ Member function 'Example::constModify' is declared const<\/span><\/span>\n    <\/span>volatileVar<\/span> = <\/span>30<\/span>; <\/span>\/\/ Cannot assign to non-static data member within const member function 'constModify'<\/span><\/span>\n                      <\/span>\/\/ Member function 'Example::constModify' is declared const<\/span><\/span>\n    <\/span>mutableVar<\/span> = <\/span>40<\/span>;  <\/span>\/\/ OK to modify a mutable member in a const member function<\/span><\/span>\n  }<\/span><\/span>\n  <\/span><\/span>\nprivate<\/span>:<\/span><\/span>\n  <\/span>int<\/span> <\/span>nonConstVar<\/span>;<\/span><\/span>\n  <\/span>const<\/span> <\/span>int<\/span> <\/span>constVar<\/span>;<\/span><\/span>\n  <\/span>volatile<\/span> <\/span>int<\/span> <\/span>volatileVar<\/span>;<\/span><\/span>\n  <\/span>mutable<\/span> <\/span>int<\/span> <\/span>mutableVar<\/span>;<\/span><\/span>\n};<\/span><\/span>\n<\/span>\nint<\/span> <\/span>main<\/span>(<\/span>int<\/span> <\/span>argc<\/span>, <\/span>const<\/span> <\/span>char<\/span> * <\/span>argv<\/span>[])<\/span><\/span>\n{<\/span><\/span>\n  <\/span>const<\/span> <\/span>Example<\/span> constObj(1, 2, 3);<\/span><\/span>\n  <\/span>constObj<\/span>.<\/span>constModify<\/span>();<\/span><\/span>\n<\/span>\n  <\/span>Example<\/span> <\/span>obj<\/span>(<\/span>4<\/span>, <\/span>5<\/span>, <\/span>6<\/span>);<\/span><\/span>\n  <\/span>obj<\/span>.<\/span>modify<\/span>();<\/span><\/span>\n<\/span>\n  <\/span>volatile<\/span> <\/span>int<\/span> <\/span>vol<\/span> = <\/span>7<\/span>;<\/span><\/span>\n  <\/span>const<\/span> <\/span>volatile<\/span> int constVol = <\/span>8<\/span>;<\/span><\/span>\n<\/span>\n  <\/span>vol<\/span> = <\/span>9<\/span>; <\/span>\/\/ OK<\/span><\/span>\n  <\/span>constVol<\/span> = <\/span>10<\/span>; <\/span>\/\/ Cannot assign to variable 'constVol' with const-qualified type 'const volatile int'<\/span><\/span>\n                 <\/span>\/\/ Variable 'constVol' declared const<\/span><\/span>\n  <\/span>int<\/span> <\/span>x<\/span> = <\/span>vol<\/span>; <\/span>\/\/ Compiler must read the current value of vol<\/span><\/span>\n  <\/span>int<\/span> <\/span>y<\/span> = <\/span>constVol<\/span>; <\/span>\/\/ Compiler must read the current value of constVol<\/span><\/span>\n<\/span>\n  <\/span>return<\/span> <\/span>0<\/span>;<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n\n\n\n
      <\/span>constexpr Specifier (since C++11)<\/span><\/h3>\n\n\n\n
      The idea of constexpr<\/strong> is to provide a performance improvement for programs by doing computations at compile time rather than run time. Note that once a program is compiled and finalized by the developer, it is run multiple times by users. The idea is to spend time in compilation and save time at run time (similar to template metaprogramming<\/em> – see later…).  <\/p>\n\n\n\n
      constexpr<\/strong> specifies that the value of an object or a function can be evaluated at compile-time and the expression can be used in other constant expressions. Such entities can then be used where only compile time constant expressions are allowed (provided that appropriate function arguments are given).<\/p>\n\n\n\n
      A constexpr<\/strong> specifier used in an object declaration or non-static member function (until C++14) implies const<\/strong>.<\/p>\n\n\n\n
      A constexpr<\/strong> specifier used in the first declaration of a function or static data member (since C++17) implies inline<\/strong>. If any declaration of a function or function template has a constexpr<\/strong> specifier, then every declaration must contain that specifier.<\/p>\n\n\n\n
      It defines an expression that can be evaluated at compile time.<\/p>\n\n\n\n
      Constant expressions<\/em> can be used as non-type template arguments, array sizes, and in other contexts that require constant expressions, for example:<\/p>\n\n\n\n
      <\/path><\/path><\/svg><\/span>
      int<\/span> <\/span>n<\/span> = <\/span>1<\/span>;<\/span><\/span>\nstd::<\/span>array<\/span><<\/span>int<\/span>, <\/span>n<\/span>> <\/span>a1<\/span>; <\/span>\/\/ Non-type template argument is not a constant expression<\/span><\/span>\n                       <\/span>\/\/ Read of non-const variable 'n' is not allowed in a constant expression<\/span><\/span>\nconst<\/span> <\/span>int<\/span> cn = <\/span>2<\/span>;<\/span><\/span>\nstd::<\/span>array<\/span><<\/span>int<\/span>, <\/span>cn<\/span>> <\/span>a2<\/span>; <\/span>\/\/ OK: \u201ccn\u201d is a constant expression<\/span><\/span><\/code><\/pre><\/div>\n\n\n\n
      \n
      NOTE:<\/strong> We talk about templates in detail later, so, until then, bear with us…<\/p>\n<\/blockquote>\n\n\n\n
      <\/span>constexpr variable<\/span><\/h4>\n\n\n\n
      A variable or variable template (since C++14) can be declared constexpr<\/strong> if all following conditions are satisfied:<\/p>\n\n\n\n
        \n
      • The declaration is a definition.<\/li>\n\n\n\n
      • It is of a literal type.<\/li>\n\n\n\n
      • It is initialized (by the declaration).<\/li>\n<\/ul>\n\n\n\n
        <\/span>constexpr Example<\/span><\/h4>\n\n\n\n
        Here is a simple example of the use of constexpr<\/strong> usage:<\/p>\n\n\n\n
        <\/path><\/path><\/svg><\/span>
        \/\/<\/span><\/span>\n\/\/  main.cpp<\/span><\/span>\n\/\/  const, volatile, mutable<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 2\/10\/25.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#<\/span>include<\/span> <<\/span>iostream<\/span>><\/span><\/span>\n<\/span>\nconstexpr<\/span> <\/span>int<\/span> <\/span>size<\/span> = <\/span>5<\/span>;<\/span><\/span>\nint<\/span> <\/span>arr<\/span>[<\/span>size<\/span>]; <\/span>\/\/ Valid, size is known at compile time<\/span><\/span>\n<\/span>\nconstexpr<\/span> <\/span>int<\/span> <\/span>square<\/span>(<\/span>int<\/span> <\/span>x<\/span>)<\/span><\/span>\n{<\/span><\/span>\n  <\/span>return<\/span> <\/span>x<\/span> * <\/span>x<\/span>;<\/span><\/span>\n}<\/span><\/span>\n<\/span>\nint<\/span> <\/span>main<\/span>(<\/span>int<\/span> <\/span>argc<\/span>, <\/span>const<\/span> <\/span>char<\/span> * <\/span>argv<\/span>[])<\/span><\/span>\n{<\/span><\/span>\n  <\/span>constexpr<\/span> <\/span>int<\/span> <\/span>result<\/span> = <\/span>square<\/span>(<\/span>size<\/span>); <\/span>\/\/ evaluated at compile time<\/span><\/span>\n  std::<\/span>cout<\/span> << <\/span>"The square of "<\/span> << <\/span>size<\/span> << <\/span>" is "<\/span> << <\/span>result<\/span> << std::<\/span>endl<\/span>;<\/span><\/span>\n<\/span>\n  <\/span>int<\/span> <\/span>num<\/span> = <\/span>10<\/span>;<\/span><\/span>\n  <\/span>int<\/span> <\/span>runtime_result<\/span> = <\/span>square<\/span>(<\/span>num<\/span>); <\/span>\/\/ evaluated at runtime<\/span><\/span>\n  std::<\/span>cout<\/span> << <\/span>"The square of "<\/span> << <\/span>num<\/span> << <\/span>" is "<\/span> << <\/span>runtime_result<\/span> << std::<\/span>endl<\/span>;<\/span><\/span>\n  <\/span><\/span>\n  <\/span>return<\/span> <\/span>0<\/span>;<\/span><\/span>\n}<\/span><\/span>\n<\/span><\/code><\/pre><\/div>\n\n\n\n
        The program outputs:<\/p>\n\n\n\n
        The square of 5 is 25\nThe square of 10 is 100\nProgram ended with exit code: 0<\/code><\/pre>\n\n\n\n
        <\/span>constexpr Example with a Class<\/span><\/h4>\n\n\n\n
        Here’s an example of constexpr<\/strong> used with a class:<\/p>\n\n\n\n
        <\/path><\/path><\/svg><\/span>
        \/\/<\/span><\/span>\n\/\/  main.cpp<\/span><\/span>\n\/\/  const, volatile, mutable<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 2\/10\/25.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#<\/span>include<\/span> <<\/span>iostream<\/span>><\/span><\/span>\n<\/span>\n\/\/ 3. constexpr with class<\/span><\/span>\nclass<\/span> <\/span>Rectangle<\/span> {<\/span><\/span>\npublic<\/span>:<\/span><\/span>\n    <\/span>constexpr<\/span> <\/span>Rectangle<\/span>(<\/span>int<\/span> <\/span>w<\/span>, <\/span>int<\/span> <\/span>h<\/span>) : <\/span>width<\/span>(<\/span>w<\/span>), <\/span>height<\/span>(<\/span>h<\/span>) {}<\/span><\/span>\n    <\/span>constexpr<\/span> <\/span>int<\/span> <\/span>area<\/span>() const { <\/span>return<\/span> <\/span>width<\/span> * <\/span>height<\/span>; }<\/span><\/span>\nprivate<\/span>:<\/span><\/span>\n    <\/span>int<\/span> <\/span>width<\/span>;<\/span><\/span>\n    <\/span>int<\/span> <\/span>height<\/span>;<\/span><\/span>\n};<\/span><\/span>\n<\/span>\nint<\/span> <\/span>main<\/span>(<\/span>int<\/span> <\/span>argc<\/span>, <\/span>const<\/span> <\/span>char<\/span> * <\/span>argv<\/span>[])<\/span><\/span>\n{<\/span><\/span>\n    <\/span>constexpr<\/span> <\/span>Rectangle<\/span> <\/span>rect<\/span>(<\/span>5<\/span>, <\/span>10<\/span>);<\/span><\/span>\n    <\/span>constexpr<\/span> <\/span>int<\/span> <\/span>rect_area<\/span> = <\/span>rect<\/span>.<\/span>area<\/span>(); <\/span>\/\/ evaluated at compile time<\/span><\/span>\n    std::<\/span>cout<\/span> << <\/span>"The area of the rectangle is: "<\/span> << <\/span>rect_area<\/span> << std::<\/span>endl<\/span>;<\/span><\/span>\n    <\/span><\/span>\n    <\/span>return<\/span> <\/span>0<\/span>;<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n\n\n\n
        This program outputs:<\/p>\n\n\n\n
        The area of the rectangle is: 50\nProgram ended with exit code: 0<\/code><\/pre>\n\n\n\n
        <\/span>constexpr Example to Calculate the Size of an Array at Compile Time<\/span><\/h4>\n\n\n\n
        \n
        \n
        <\/path><\/path><\/svg><\/span>
        \/\/<\/span><\/span>\n\/\/  main.cpp<\/span><\/span>\n\/\/  const, volatile, mutable<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 2\/10\/25.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#<\/span>include<\/span> <<\/span>iostream<\/span>><\/span><\/span>\n<\/span>\nconstexpr<\/span> <\/span>int<\/span> <\/span>product<\/span>(<\/span>int<\/span> <\/span>x<\/span>, <\/span>int<\/span> <\/span>y<\/span>) { <\/span>return<\/span> (<\/span>x<\/span> * <\/span>y<\/span>); }<\/span><\/span>\n<\/span>\nint<\/span> <\/span>main<\/span>(<\/span>int<\/span> <\/span>argc<\/span>, <\/span>const<\/span> <\/span>char<\/span> * <\/span>argv<\/span>[])<\/span><\/span>\n{<\/span><\/span>\n  <\/span>int<\/span> <\/span>arr<\/span>[<\/span>product<\/span>(<\/span>2<\/span>, <\/span>3<\/span>)] = {<\/span>1<\/span>, <\/span>2<\/span>, <\/span>3<\/span>, <\/span>4<\/span>, <\/span>5<\/span>, <\/span>6<\/span>};<\/span><\/span>\n  std::<\/span>cout<\/span> << <\/span>"Size of arr: = "<\/span> <\/span><\/span>\n            << <\/span>sizeof<\/span>(<\/span>arr<\/span>)\/<\/span>sizeof<\/span>(<\/span>arr<\/span>[<\/span>0<\/span>]) << std::<\/span>endl<\/span>;<\/span><\/span>\n  <\/span><\/span>\n  <\/span>return<\/span> <\/span>0<\/span>;<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
        <\/div>\n<\/div>\n\n\n\n
        This program outputs:<\/p>\n\n\n\n
        Size of arr: = 6\nProgram ended with exit code: 0<\/code><\/pre>\n\n\n\n
        <\/span>constexpr Example to Convert from One Unit to Another<\/span><\/h4>\n\n\n\n
        \n
        \n
        <\/path><\/path><\/svg><\/span>
        \/\/<\/span><\/span>\n\/\/  main.cpp<\/span><\/span>\n\/\/  const, volatile, mutable<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 2\/10\/25.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#<\/span>include<\/span> <<\/span>iostream<\/span>><\/span><\/span>\n#<\/span>include<\/span> <<\/span>cmath<\/span>> <\/span>\/\/ For standard declaration of pi (M_PI)<\/span><\/span>\n<\/span>\nconstexpr<\/span> <\/span>double<\/span> <\/span>ConvertDegreeToRadian<\/span>(<\/span>const<\/span> <\/span>double<\/span>& <\/span>degrees<\/span>)<\/span><\/span>\n{<\/span><\/span>\n  <\/span>return<\/span> (<\/span>degrees<\/span> * (<\/span>M_PI<\/span> \/ <\/span>180<\/span>));<\/span><\/span>\n}<\/span><\/span>\n<\/span>\nint<\/span> <\/span>main<\/span>(<\/span>int<\/span> <\/span>argc<\/span>, <\/span>const<\/span> <\/span>char<\/span> * <\/span>argv<\/span>[])<\/span><\/span>\n{<\/span><\/span>\n  <\/span>double<\/span> <\/span>angleInRadians<\/span> = <\/span>ConvertDegreeToRadian<\/span>(<\/span>90.0<\/span>);<\/span><\/span>\n  std::<\/span>cout<\/span> << <\/span>"Angle in radians: "<\/span> << <\/span>angleInRadians<\/span> << std::<\/span>endl<\/span>;<\/span><\/span>\n    <\/span><\/span>\n  <\/span>return<\/span> <\/span>0<\/span>;<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
        <\/div>\n<\/div>\n\n\n\n
        which outputs:<\/p>\n\n\n\n
        Angle in radians: 1.5708\nProgram ended with exit code: 0<\/code><\/pre>\n\n\n\n
        <\/span>constexpr Example to Calculate a Value in the Fibonacci Sequence<\/span><\/h4>\n\n\n\n
        \n
        The Fibonacci Sequence<\/strong><\/p>\n\n\n\n
        In mathematics, the Fibonacci sequence<\/strong> is a sequence in which each element is the sum of the two elements that precede it. Numbers that are part of the Fibonacci sequence are known as Fibonacci numbers<\/strong>, commonly denoted Fn<\/sub><\/em>\u200a.<\/p>\n\n\n\n
        The Fibonacci numbers may be defined by the recurrence relation<\/em>:<\/p>\n\n\n\n
        \"{\\displaystyle<\/figure>\n\n\n\n
        and<\/p>\n\n\n\n
        \"{\\displaystyle<\/figure>\n\n\n\n
        for n > 1.<\/em><\/p>\n<\/blockquote>\n\n\n\n
        \n
        \n
        <\/path><\/path><\/svg><\/span>
        \/\/<\/span><\/span>\n\/\/  main.cpp<\/span><\/span>\n\/\/  const, volatile, mutable<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 2\/10\/25.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#<\/span>include<\/span> <<\/span>iostream<\/span>><\/span><\/span>\n<\/span>\nconstexpr<\/span> <\/span>int<\/span> <\/span>fibonacci<\/span>(<\/span>int<\/span> <\/span>n<\/span>) <\/span><\/span>\n{<\/span><\/span>\n  <\/span>return<\/span> (<\/span>n<\/span> <= <\/span>1<\/span>) ? <\/span>n<\/span> : <\/span>fibonacci<\/span>(<\/span>n<\/span>-<\/span>1<\/span>) + <\/span>fibonacci<\/span>(<\/span>n<\/span>-<\/span>2<\/span>);<\/span><\/span>\n}<\/span><\/span>\n<\/span>\nint<\/span> <\/span>main<\/span>(<\/span>int<\/span> <\/span>argc<\/span>, <\/span>const<\/span> <\/span>char<\/span> * <\/span>argv<\/span>[])<\/span><\/span>\n{<\/span><\/span>\n  <\/span>constexpr<\/span> <\/span>int<\/span> <\/span>result<\/span> = <\/span>fibonacci<\/span>(<\/span>10<\/span>);<\/span><\/span>\n  std::<\/span>cout<\/span> << <\/span>"Fibonacci(10) = "<\/span> << <\/span>result<\/span> << std::<\/span>endl<\/span>;<\/span><\/span>\n<\/span>\n  <\/span>return<\/span> <\/span>0<\/span>;<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
        <\/div>\n<\/div>\n\n\n\n
        which outputs:<\/p>\n\n\n\n
        Fibonacci(10) = 55\nProgram ended with exit code: 0<\/code><\/pre>\n\n\n\n
        \n
        NOTE:<\/strong> There is a limit (specific to each C++ compiler) to the evaluation of constexpr compile-time expressions. In the above case, the expression at line 17 is a call to a recursive function<\/em>. It succeeds for a value of 10 (in my compiler), but if I change the value to 30, I get the following:<\/p>\n\n\n\n
        Constexpr variable ‘result’ must be initialized by a constant expression
        Constexpr evaluation hit maximum step limit; possible infinite loop?<\/strong><\/p>\n\n\n\n
        Some compilers may crash instead of emitting such a compile-time error.<\/p>\n\n\n\n
        <\/p>\n<\/blockquote>\n\n\n\n
        <\/span>consteval and constinit Specifiers (since C++20)<\/span><\/h3>\n\n\n\n
        <\/span>consteval Specifier<\/span><\/h4>\n\n\n\n
        The consteval<\/strong> specifier declares a function that must be evaluated at compile time. Any call to a consteval<\/strong> function must occur in a context where a constant expression is required.<\/p>\n\n\n\n
        Example:<\/p>\n\n\n\n
        \n
        \n
        <\/path><\/path><\/svg><\/span>
        \/\/<\/span><\/span>\n\/\/  main.cpp<\/span><\/span>\n\/\/  const, volatile, mutable<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 2\/10\/25.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\nconsteval<\/span> <\/span>int<\/span> <\/span>multiply<\/span>(<\/span>int<\/span> <\/span>x<\/span>, <\/span>int<\/span> <\/span>y<\/span>) <\/span><\/span>\n{<\/span><\/span>\n  <\/span>return<\/span> <\/span>x<\/span> * <\/span>y<\/span>;<\/span><\/span>\n}<\/span><\/span>\n<\/span>\nint<\/span> <\/span>main<\/span>(<\/span>int<\/span> <\/span>argc<\/span>, <\/span>const<\/span> <\/span>char<\/span> * <\/span>argv<\/span>[])<\/span><\/span>\n{<\/span><\/span>\n  <\/span>constexpr<\/span> <\/span>int<\/span> <\/span>result1<\/span> = <\/span>multiply<\/span>(<\/span>5<\/span>, <\/span>3<\/span>); <\/span>\/\/ OK: evaluated at compile time<\/span><\/span>\n  <\/span>static_assert<\/span>(<\/span>result1<\/span> == <\/span>15<\/span>);<\/span><\/span>\n<\/span>\n  <\/span>int<\/span> <\/span>a<\/span> = <\/span>5<\/span>;<\/span><\/span>\n  <\/span>int<\/span> <\/span>result2<\/span> = <\/span>multiply<\/span>(<\/span>a<\/span>, <\/span>3<\/span>); <\/span>\/\/ Call to consteval function 'multiply' is not a constant expression<\/span><\/span>\n                                <\/span>\/\/ Read of non-const variable 'a' is not allowed in a constant expression<\/span><\/span>\n  <\/span>return<\/span> <\/span>0<\/span>;<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
        <\/div>\n<\/div>\n\n\n\n
        <\/span>constinit Specifier<\/span><\/h4>\n\n\n\n
        The constinit<\/strong> specifier ensures that a variable with static or thread storage duration is initialized at compile time. It guarantees that the initialization is either zero initialization or constant initialization.<\/p>\n\n\n\n
        \n
        In C++ Formal Language<\/strong><\/p>\n\n\n\n
        If a variable is declared with constinit<\/strong>, its initializing declaration must be applied with constinit<\/strong>. If a variable declared with constinit<\/strong> has dynamic initialization<\/em> (even if it is performed as static initialization<\/em>), the program is ill-formed.<\/p>\n\n\n\n
        If no constinit<\/strong> declaration is reachable at the point of the initializing declaration, the program is ill-formed, no diagnostic required.<\/p>\n\n\n\n
        constinit<\/strong> cannot be used together with constexpr<\/strong>. When the declared variable is a reference, constinit<\/strong> is equivalent to constexpr<\/strong>. When the declared variable is an object, constexpr<\/strong> mandates that the object must have static initialization and constant destruction and makes the object const-qualified<\/em>, however, constinit<\/strong> does not mandate constant destruction and const-qualification<\/em>. As a result, an object of a type which has constexpr<\/strong> constructors and no constexpr<\/strong> destructor (e.g. std::shared_ptr<T><\/strong>) might be declared with constinit<\/strong> but not constexpr<\/strong>.<\/p>\n\n\n\n
        Got that?<\/strong><\/p>\n<\/blockquote>\n\n\n\n
        The constinit<\/strong> specifier is used to mark variables that must be initialized with compile-time constant expressions or constant-initialized constructors and it also ensures that the initialization will be done during the static initialization phase. It prevents the variables with static storage duration to be initialized at runtime. The variables specified with constinit<\/strong> specifier need to be initialized with a constant expression.<\/p>\n\n\n\n
        \n
        \n
        <\/path><\/path><\/svg><\/span>
        \/\/<\/span><\/span>\n\/\/  main.cpp<\/span><\/span>\n\/\/  const, volatile, mutable<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 2\/10\/25.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\nconsteval<\/span> <\/span>int<\/span> <\/span>get_value<\/span>() <\/span><\/span>\n{<\/span><\/span>\n  <\/span>return<\/span> <\/span>42<\/span>; <\/span>\/\/ The "answer"<\/span><\/span>\n}<\/span><\/span>\n<\/span>\nconstinit<\/span> <\/span>int<\/span> <\/span>value1<\/span> = <\/span>get_value<\/span>(); <\/span>\/\/ OK: Initialized at compile time<\/span><\/span>\nconstexpr<\/span> <\/span>int<\/span> <\/span>value2<\/span> = <\/span>100<\/span>;<\/span><\/span>\nconstinit<\/span> <\/span>int<\/span> <\/span>value3<\/span> = <\/span>value2<\/span>; <\/span>\/\/ OK: Initialized at compile time using constexpr<\/span><\/span>\nconstinit<\/span> <\/span>constexpr<\/span> <\/span>int<\/span> <\/span>value4<\/span> = <\/span>value2<\/span>; <\/span>\/\/ Cannot combine with previous 'constinit' declaration specifier<\/span><\/span>\n<\/span>\n<\/span>\nint<\/span> <\/span>main<\/span>(<\/span>int<\/span> <\/span>argc<\/span>, <\/span>const<\/span> <\/span>char<\/span> * <\/span>argv<\/span>[])<\/span><\/span>\n{<\/span><\/span>\n  <\/span>static<\/span> <\/span>constinit<\/span> <\/span>int<\/span> <\/span>value5<\/span> = <\/span>123<\/span>; <\/span>\/\/ OK: static storage duration<\/span><\/span>\n  <\/span><\/span>\n  <\/span>return<\/span> <\/span>0<\/span>;<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
        <\/div>\n<\/div>\n","protected":false},"excerpt":{"rendered":"
        const, volatile, mutable, and More In C++, const, volatile, and mutable are type qualifiers that modify the behavior of variables. const const specifies that a variable’s value cannot be changed after initialization. Any attempt to modify a const variable will result in a compile-time error. volatile volatile indicates that a variable’s value can be changed […]<\/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-2258","page","type-page","status-publish","hentry"],"blocksy_meta":[],"_links":{"self":[{"href":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/index.php\/wp-json\/wp\/v2\/pages\/2258","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=2258"}],"version-history":[{"count":16,"href":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/index.php\/wp-json\/wp\/v2\/pages\/2258\/revisions"}],"predecessor-version":[{"id":2369,"href":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/index.php\/wp-json\/wp\/v2\/pages\/2258\/revisions\/2369"}],"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=2258"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}