C++学习笔记九：值，常量，常表达式和常初始化

1. 值：

Literal: Data that is directly represented in code without going through some other variable stored in memory.

值： 直接在代码中表示的数据，无需通过内存中存储的其他变量。值不在内存中进行存储，而是直接在二进制的可执行文件中产生。

1.1 整型

//Literal types : u and l combinations for unsigned and long.（大小写都可）
unsigned char unsigned_char {53u};// 555U would fail because of narrowing

//2 Bytes
short short_var {-32768} ; //  No special literal type for short)
short int short_int {455} ; //  No special literal type for short
signed short signed_short {122}; // No special literal type for short
signed short int signed_short_int {-456}; // No special literal type for short
unsigned short int unsigned_short_int {5678U };

// 4 Bytes
const int int_var {55} ;            //
signed signed_var {66};             //
signed int signed_int {77};         //
unsigned int unsigned_int {555U};       //

//4 or 8 Bytes
long long_var {88L}; // 4 OR 8 Bytes
long int long_int {33L};
signed long signed_long {44l};
signed long int signed_long_int {44l};
unsigned long int unsigned_long_int {555ul};

//8 Bytes
long long long_long {888ll};// 8 Bytes
long long int long_long_int {999ll};
signed long long signed_long_long {444ll};
signed long long int signed_long_long_int{1234ll};

//Grouping Numbers : C++14 and onwards
unsigned int prize  {1'500'00'0u};
std::cout << "The prize is : " << prize << std::endl;
std::cout << " signed_long_long_int : " << signed_long_long_int << std::endl;

//Narrowing errors
//Possible narrowing errors are cought by the braced initializer method.
//Assignment and functional don't catch that.
//unsigned char distance {555u}; //Error [0~255]
//unsigned int game_score {-20}; //Error

1.2 十六进制赋值：

//With number systems - Hex : prefix with 0x
unsigned int hex_number{ 0x22BU}; // Dec 555
int hex_number2 {0x400};// Dec 1024
std::cout << std::hex <<  "The hex number is : " << hex_number << std::endl;
std::cout << std::dec <<  "The hex number2 is : " << hex_number2 << std::endl;
//review: direct output only gives devimal number, use std::hex to get hex output
//Representing colors with hex
int black_color {0xffffff};
std::cout << "Black color is : " << std::dec << black_color << std::endl;

1.3 八进制赋值：

//Octal literals : prefix with 0
int octal_number {0777u}; // 511 Dec
std::cout << std::oct << "The octal number is : " << octal_number << std::endl;
//!!BE CAREFUL NOT TO PREFIX YOUR INTEGERS WITH 0 IF YOU MEAN DEC
int error_octal {055};// This is not 55 in memory , it is 45 dec
std::cout << "The erronous octal number is : " << error_octal << std::endl;

1.4 二进制赋值

//Binary literals
unsigned int binary_literal {0b11111111u};// 255 dec
std::cout << "The binary literal is : " << binary_literal << std::endl;

1.5 其他类型赋值

char char_literal {'c'};
int number_literal {15};
float fractional_literal {1.5f}; //不加f默认只是double类型
std::string string_literal {"Hit the road"};

2. 常量

const: A read only variable. Cannot assign data to it.

常量：是一个只读值，不能赋值，CPU并没有常量的概念，是程序层在constant对变量修饰后导致变量只读的属性。一般用于定义在整个程序运行周期内都不想被改变的量。常量在声明的时候必须赋值。

const int age {34};
const float height {1.67f};

//age = 55; // Can't modify
//height = 1.8f;

3. 常表达式

constexpr: A constant that has the potential to be evaluated at compile time

3.1 程序的产生过程：

IDE Code -> Compile time（从代码生成二进制可执行文件） -> Run time

如果可能的话，把复杂的计算放到编译中去做(Compile time computations)，一旦编译完成，在运行时可以直接调用编译生成的结果。c++11之后引入的特性。

可执行二进制文件的一般执行过程：

initialization->Constexpr computation->Runtime computation

改进后：

initialization->Runtime computation

3.2 举例：

constexpr int SOME_LIB_MAJOR_VERSION {1237};
constexpr int eye_count {2};
constexpr double PI {3.14};
//eye_count = 4;  //error
std::cout << "eye count : " << eye_count << std::endl;
std::cout << "PI : " << PI << std::endl;

// int leg_count {2}; // Non constexpr
// leg_count is not known at compile time
// constexpr int arm_count{leg_count}; // Error, cannot initialize a compile
// time variable with a runtime variable

constexpr int room_count{10};
constexpr int door_count{room_count};// OK
const int table_count{5};
constexpr int chair_count{ table_count * 5};// Works

static_assert( SOME_LIB_MAJOR_VERSION == 123); //compile time check
// int age = 5;
// static_assert( age == 5); //不能检查非constant变量

std::cout << "App doing its thing..." << std::endl;

4. 常初始化（C++20特性）

constinit: A variable that should be initialized with a constant or literal at compile time

指定变量必须拥有静态初始化，即零初始化与常量初始化，否则程序非良构。这种变量必须是静态的或者是全生命周期的variables with static or thread storage duration。

什么是静态变量：When you declare a variable in a function, the static keyword specifies that the variable retains its state between calls to that function. When you declare a data member in a class declaration, the static keyword specifies that one copy of the member is shared by all instances of the class.

可以帮助解决在主函数外的初始化问题。必须初始化。const和constinit可以结合使用，const和constexpr不可以结合使用。const init不说明变量是常量，只是说明编译器强制其在编译过程中初始化。

#include <iostream>

const int val1 {33};
constexpr int val2{34};
int val3 {35}; // Run time value

constinit int age = 88; // This is initialized at compile time
const constinit int age1 {val1}; // const and constinit can be combined
constinit int age2 {age1}; // Initializing with age would lead to a compiler error
                                 // age is not const
//constinit int age3 {val3}; // Error : val3 is evaluated at run time
                           // can't const initialize age3                           
const constinit double weight {33.33};
//constexpr constinit double scale_factor{3.11};// Can't combine constexpr and constinit

int main(){
    //constinit double height{1.72}; //compiler error, not static or thread storage duration
    std::cout << "age : " << age << std::endl;
    std::cout << "age1 : " << age1 << std::endl;
    std::cout << "age2 : " << age2 << std::endl;
    age =33; // Can change a const init variable
    std::cout << "age : " << age << std::endl;
    //Combining const and constinit
    std::cout << "weight : " << weight << std::endl;
    //weight = 44.44; // Compiler error
    return 0;
}