字面值：是一个不能改变的值，如数字、字符、字符串等。单引号内的是字符字面值，双引号内的是字符串字面值。
 
字面值类型（literal type）：算数类型、引用和指针等。
 

 
 
常量表达式（const experssion）：是指(1)值不会改变 并且 (2)在编译过程就能得到计算结果的表达式。字面量属于常量表达式，用常量表达式初始化的const对象也是常量表达式。
 
一个对象（或表达式）是不是常量表达式由它的数据类型和初始值共同决定。
 
 
const int a =1;		//常量表达式
cosnt int b=a+1;	//常量表达式
int c=2;		//初始值是字面值常量，当c数据类型是普通int。
const int d=fun();	//fun()值要在运行时得到，d不是字面值常量。

 
 
constexpr变量
 
C++11新标准规定，允许将变量声明为constexpr类型以便由编译器来验证变量的是否是一个常量表达式。
 
声明为constexpr的变量一定是一个常量，而且必须用常量表达式初始化。
 

 
 
constexpr函数
 
constexpr函数是指能用于常量表达式的函数。
 
应遵循的约定：函数返回类型及所有形参的类型都是字面值类型，而且函数体中必须有且只有一条return 语句。
 
constexpr函数体内可以有其他语句，只要这些语句在运行时不执行任何操作。（例如，空语句、类型别名和using声明等）
 
constexpr函数被隐式地指定为内联函数。
 

constexpr int fun(int a){ return a*10; }
 
若a是常量表达式，fun(a)就是常量表达式。若a不是常量表达式，fun(a)就是变成普通函数。 
 
当constexpr函数是常量表达式时可以用来初始化constexpr变量。
 
 

 constexpr和指针
 

 constexpr声明中定义了一个指针，限定符constexpr仅对指针对象有效，与指针所指的对象无关。
 

 
const int *p1=nullptr;		//p1是指向整形常量的指针
constexpr int *p2=nullptr;	//p2是指向整形的常量指针
(等效于 int *const p2=nullptr;)
  但constexpr声明的指针初始值只能是0、nullptr和存储于某个固定地址中的对象。因为它是常量表达式（常量表达式定义（2））。
 
 
 
 
 

 
 
 
 
 
 
 

 
 

const,默认情况下仅在文件内有效
 
const int i(12);
 
const引用:对常量的引用不能被用作修改它所绑定的对象
 
const int ci(5);
 
const int &rci(ci);
 
rci = 90;//错误 不能修改
 
 
 
允许常量引用绑定到非常量的对象、字面值或表达式上
 
int i = 20;
 
const int &ri(20);
 
const int &ri3(i + ri);
 
 
 
常量引用仅对引用可参与的操作作出了限定，对于引用的对象本身未做限定
 
int i(10);
 
const int &c(i);
 
i = 90;//i不是常量，可以改变值
 
c = 20;//错误，c是一个常量引用，const限定了c为常量不能修改，i的修改与c的限定无关。
 
cout << c << endl;//值为90
 
 
 
//指针和const
 
int iv(10);
 
int iv1(23);
 
const int * pci1(&iv);//指向常量的指针，限定了该指针的操作，pci1的值可以改变，pcil指向的值不能变
 
pci1 = &iv1;
 
iv = 30;
 
int * const pci2(&iv);//常量指针，把指针本身定位常量,pci2的值不能改变，pci2指向的值可以改变
 
*pci2 = 90;
 
 
 
cout << *pci1 << endl;//23
 
cout << *pci2 << endl;//90
 
 
 
顶层和底层
 
顶层：表示指针本身是个常量
 
底层：指针所指的对象是常量
 
小技巧：const int * p: const修饰的是*p，也就是*p不能变。
 
        int * const p: const修饰的是p,也就是p不能变。
 
 
 
 
 
字面值和constexpr
 
常量表达式：字面值是常量表达式，用常量表达式初始化的const对象也是常量表达式
 
const int ci = 20;//ci是常量表达式
 
const int cii = ci + 90;//cii是常量表达式
 
int iv = 30;//iv不是常量表达式
 
 
 
声明为constexpr的变量一定是常量，而且必须用常量表达式初始化
 
constexpr int cif = 23;
 
 
 
constexpr声明的指针，只对指针有效，与指针指向的对象无关
 
constexpr int cvi(12);//必须定义到函数体外部才能被cip使用
 
constexpr const int * cip(&cvi);
 
cout << *cip << endl;

常量表达式和运算符
 
通过学习了常量和运算符后，我感觉这些代码的解释和我们以前学过的数学相像，比如常量和变量，这些都是数学中常用的名词，学习了这些新知识后我总结了以下知识点：
 
JAVA中的常量
 常量就是指在程序执行期间其值不能发生变化的数据，常量是固定的。如整型常量123，实型常量
 1.23，字符常量’A’，布尔常量true等
 Java中的常量用final来实现，例如final double PI=3.14;注意声明常量的时候可以不赋值，而在构造器结
 构中赋初值，但是若在声明时同时进行了赋值，则不可以在初始化结构中赋值了。
 
final boolean out=true;
// out=false;语法报错的原因是out是常量，一旦赋值则不允许在运行期间进行修改
if(out)
 System.out.println("我的第一次输出");
System.out.println("其它的输出");
if(out)
 System.out.println("我的第二次输出");

 
表达式
 表达式就是运算符、操作数以及方法调用的序列，用来说明某个计算过程并返回计算结果
 按照运算符功能来分，基本的运算符分包括算术运算符、关系运算符、位运算符、条件运算符等
 
算术运算符 +、-、*、/、%、++、–
关系运算符 >、<、>=、<=、==、!=
逻辑运算符 &&、 ||、 !。注意：逻辑计算支持短路操作
位运算符 &、|、^、~、<< 、 >>、>>>。注意：为运算符不支持短路操作 [考点]
赋值运算符 =，+=，-=，*=，/=
三目条件运算符（？：）规则是完全一致的，使用的形式是： x ? y：z;
 算术运算符
 +、-、*、/、%、++、–
 整除：参与运算的双方都是整数 10/3=3而不是3.33333
 10./3=3.333…这里由于10.是浮点数，则3会自动转换为大类型并参与计算，所以最终是 10.0/3.0的计算结果
 
int kk=3;
int res=(kk/2); //没有语法错误，因为除数和被除数都是整数，所以计算结果为整数
System.out.println(res);
//如果需要计算小数部分，则除数或者被除数之一必须为非整数
3./2=1.5
double res=(1.*kk/2);  //因为1.是double类型的浮点数，所以计算结果一定是浮点数
 
计算次序为先乘除后加减，如果优先级一致，则自动从左向右进行计算 10+2*5=20
 %求余（取模） 10%3=1实际就是10除以3求余数
 
//假设总行数为10行，每页3行，如何计算需要多少页进行显示
int rowsNum = 12;// 总行数
int rowsPerPage = 3;// 每页行数
int pageNum = rowsNum / rowsPerPage;// 总页码数
System.out.println(pageNum);// 由于整除的问题，所以计算结果为3，这样就会有数据丢失
if(rowsNum%rowsPerPage!=0)
 pageNum=pageNum+1;
System.out.println("最终结果为："+pageNum);
 
++和–是单目运算符
 i++等价于i=i+1
 i–等价于i=i-1
 i++是先取值后计算，++i是先计算后取值
 
int k = 100;
 System.out.println(k++);//100 先获取k的当前值，然后再进行加1计算
 System.out.println(k);//101
------
int k = 100;
 System.out.println(++k);//101 先加1然后再取值
 System.out.println(k);//101
 
比较运算符
 
 
 
、<、>=、<=、==、!= 用于判断两个数据之间的大小关系，计算结果为boolean,如果成立返回为
 true，否则为false
 
 
boolean bb = 1 > 2;
 System.out.println(bb);
 System.out.println(1 <= 2);
 //=是赋值计算 ==是等值判定
 int kk;
 System.out.println(kk=3);
 System.out.println(kk==3);
 
==和=的区别：
 
k=100;这是赋值运算符，意思是将=右边的计算结果储存在=左边的变量中
 k100这是比较计算，意思是判断k是否值为100；如果是则返回true，否则false
 !=意思是判断是否不等于，表示如果相等时返回false，否则返回true
 由于浮点数无法精确存放，所以判断k1.0这个写法是错误的
 正确写法： a-b的绝对值小于1e-6
 逻辑运算符
 &&与、 ||或、 !非
 表达多个条件之间的关系。
 计算规则：
 
&& 同真则真，其余为假
|| 同假则假，其余为真
！ 非真则假，非假则真
 
注意：逻辑计算支持短路操作
 位运算符
 &按位与、|按位或、^按位异或、~按位取反、<<左移位 、 >>右移位，空位置补符号位上的值、>>>无
 符号右移位，空位置补0
 注意：为运算符不支持短路操作 [考点]
 
int a = -2;
 int b = 3;
 //因为++a>1值为false,所以b++<4并没有执行，这就是短路操作
 boolean bb = ++a > 1 & b++ < 4;
 System.out.println(bb);//false
 System.out.println(a + ":" + b);//-1:4
 
7&3=3
 7|3=7
 7^3=4
 ~3=-4
 赋值运算符
 =，+=，-=，*=，/=
 int k=100; 含义是将100赋值存储在k对应的存储单元中
 k=k+3可以简写为k+=3
 -= */ /=类似
 三目条件运算符
 规则是完全一致的，使用的形式是： x ? y：z;
 计算规则
 
x是一个条件表达式
如果x计算结果为true，则返回y表达式的结算结果
否则返回z表达式的计算结果
 
int a=5;
int b=3;
int res=++a>b--?a+++3:b---4;  
System.out.println(res);//9
System.out.println(a+":"+b);//7:2
 
运算符的优先级
 
运算符这里不用记忆，当不确定时，注意有个神器就是()小括号，可以使用它强制表达自己的编写意图

常量表达式主要是允许一些计算发生在编译时，即发生在代码编译阶段而不是代码运行阶段。这是很大的优化，因为如果有些事情可以在编译时做，那么它只会做一次，而不是每次程序运行时都计算。
 使用constexpr，你可以创建一个编译时的函数：
 
constexpr int getConst()
{
	return 3;
}
void test07()
{
	int arr[getConst()] = { 0 };
	enum {e1 = getConst(),e2 };
	const int num = getConst();
	cout << sizeof(arr) / sizeof(arr[0]) << endl;
	cout << num << endl;
}
 
constexpr函数的限制
 
函数中只能有一条return语句
函数必须有返回值
在使用前必须定义
return返回语句表达式中不能使用非常量表达式的函数、全局数据。只能是一个常量表达式
 
//函数中只能有一条return语句，在linux下编译失败，在vs2017上编译通过
constexpr int getconst()
{
	constexpr int i = 1;
	return i;
}
// 函数必须返回值，不能是void函数，因为函数必须有返回值，要不然该函数有什么用呢？
constexpr void getconst2()
{
	return;
}
constexpr int data2()
{
	// 一个constexpr函数，只允许包含一行可执行代码
	//但允许包含typedef、 using 指令、静态断言等。
	static_assert(1, "fail");
	return 100;
}
int a = 3;
constexpr int data3()
{
	return a;// return返回语句表达式中不能使用非常量表达式的函数、全局数据
}


int main(int argc, char ** argv)
{
	constexpr int func();//函数声明，定义放在main后面
	constexpr int c = func();// 无法通过编译，在使用前必须已经有定义
	system("pause");
	return 0;
}

 
常量表达式的构造函数有以下限制
 
函数体必须为空
初始化列表只能由常量表达式来赋值
 
struct Date
{
    constexpr Date(int y, int m, int d): year(y), month(m), day(d) {}

    constexpr int GetYear() { return year; }
    constexpr int GetMonth() { return month; }
    constexpr int GetDay() { return day; }

private:
    int year;
    int month;
    int day;
};

int main()
{
    constexpr Date PRCfound {1949, 10, 1};// 必须是常量表达式
    constexpr int foundmonth = PRCfound.GetMonth();// vs2017下失败了，linux下成功

    cout << foundmonth << endl;  // 10

    return 0;
}