bool b = 42;		// b 为真
int i = b;			// i 的值为1
i = 3.14;			// i 的值为3
double pi = i;		// pi 的值为 3.0
unsigned char c = -1; 	// 假设 char 占8bit， c 的值为255
signed char c2 = 256;	// 假设 char 占8bit, c2 的值是未定义的

unsigned u = 10;
int i = -42;
std::cout << i + i << std::endl;   // 输出 -84
// u 转换成无符号的数，其值为4294967254
std::cout << u + i << std::endl;   // 如果 int 占 32bit，输出 4294967264

unsigned u1 = 42, u2 = 10;
cout << u1 - u2 << endl;
cout << u2 - u1 << endl;

for (int i = 10; i >= 0; --i)
    std::cout << i << std::endl;
// 错误： 变量u永远不会小于0，循环条件一直成立
for (unsigned i = 10; i >= 0; --i)
    std::cout << i << std::endl;

20		// 十进制
024		// 八进制
0x14	// 	十六进制

3.14159		3.14159E0		0.		0e0		.001

'a'		// 字符字面值
"Hello World!"  // 字符串字面值

L'a'		// 宽字符型字面值，类型是 wchar_t
u8"hi!"		// utf-8 字符串字面值
42ULL		// 无符号整型字面值，类型是 unsigned long long
1E-3F		// 单精度浮点型字面值，类型是 float
3.14159L	// 扩展精度浮点类型字面值，类型是 long double

bool test = false;

//变量定义并初始化
int a = 2;
//变量定义
int b;
//变量赋值
b = 1;

int val = 1;
int val = {0};
int val{0};
int val(0);

long double pi = 3.14;
int a{pi};	//错误，编译器会检查类型，无法通过编译

#include <iostream>
using namespace std;

int init;
struct A {
    int m;
    void print()
    {
        cout << m << endl;
    }
};

void test()
{
    int un_init;
    cout << un_init << endl;
}

void test01()
{
    A a;
    a.print();
}

int main()
{
    test01();
    cout << init << endl;
    return 0;
}

extern int i;	//声明i
extern int i = 1;	//错误，给i赋值extern失效
int j;		//声明并定义j

int val = 1024;
int val1 = 102;
int& refVal = val;		//refVal指向val
refVal = val1;			//refVal引用并没有改变，只是改变了refVal指向的变量val的值，val = val1
int &refVal2;			//错误，引用必须初始化

int i = 1024, i2 = 2048; 	// i和i2都是 int
int &r = i, r2 = i2;		// r是一个引用， 与i绑定在一起，r2是int
int i3 = 1024, &ri = i3;	// i3 是int，ri是一个引用，与i3绑定在一起
int &r3 = i3, &r4 = i2;		// r3和r4都是引用

// 类型必须一致
int &refVal4 = 10;		// 错误： 引用类型的初始值必须是一个对象
double dval = 3.14;
int &refVal5 = dval;	// 错误：此处引用类型的初始值必须是 int 型对象

int *p1, *p2;	// ip1和ip2都是指向int型对象的指针
double dp, *dp2;	//dp2实质性double型对象的指针，dp是double型对象

int ival = 42;
int *p = &ival;		// p 存放变量ival的地址，或者说p是指向变量ival的指针

double dval;
double *pd = &dval;
double *pd2 = pd;

int *pi = pd;		// 错误
pi = &dval;			// 错误

int ival = 42;
int *p = &ival;
cout << *p;		// 由符号 * 得到指针p所指向的对象，输出 42

*p = 0;			// 由符号 * 得到指针p所指向的对象，即可经由p为变量ival赋值
cout << *p;		// 输出0

int *p1 = nullptr;		// 等价于 int *p1 = 0;
int *p2 = 0;			// 直接将 p2初始化为字面常量0
// 需要首先 #include <cstdlib>
int *p3 = NULL;			// 等价于 int *p3 = 0;

int i = 42;
int *pi = 0;	// pi被初始化，但没有指向任何对象
int *pi2 = &i;	// pi2 被初始化，存有i的地址
int *pi3;		// 如果 pi3 定义于块内，则pi3的值是无法确定的

pi3 = pi2;		// pi3和pi2指向同一个对象
pi2 = 0;		// 现在pi2不执行任何对象

*pi = 0;	// ival 的值被改变，指针pi并没有改变

int ival = 1024;	
int *pi = 0;	// pi 合法，是一个空指针
int *pi2 = &ival;	// pi2是一个合法的指针，存放着ival的地址
if (pi)			// pi 的值是0，条件的值为false
    // ...
if (pi2)		// pi2 指向ival，它的值不为0， 条件的值是true
    // ...

double obj = 3.14, *pd = &obj;
					// 正确： void* 能存放任意类型对象的地址
void *pv = &obj;	// obj 可以是任意类型的对象
pv = pd;			// pv 可以存放任意类型的指针

int i = 42;
int *p;			//p是int型的指针
int *&r = p;	//r是一个对指针p的引用

r = &i;			//r是一个指针引用，因此给r赋值&i就是令p指向i
*r = 0;			//解引用r,就是解引用指针p,将p指向的变量i的值改为0

cont int bufSize = 512;		//用字面值常量初始化
cont int i = get_size();	//用函数返回值初始化， 运行时初始化
int j = 10;
cont int k = j;				//用其他变量初始化

const int ci = 1024;
const int &r1 = ci;		//正确，引用r1和ci都是常量
r1 = 42;				//错误， r1 是对常量的引用
int &r2 = ci;			//错误，不能让一个常量引用指向一个常量对象

int i = 42;
cont int j = 10;
const int &r1 = i;			//正确，允许将 const int&绑定到一个普通int对象
r1 = 10;					//错误，不能通过常量引用改变i的值
const int &r2 = 42;			//正确
const int &r3 = r1 * 2;		//正确
int& r4 = j;				//错误
int &r4 = r1 * 2;			//错误

int errNumb = 0;
int *const curErr = &errNumb;	//curErr将一直指向errNumb,不可以改变指向
const double pi = 3.14;
const double *const pip = π		//pip是一个指向常量对象的常量指针

const double *const pip = π		//pip是一个指向常量对象的常量指针
double const * const pip = π		// 和上面等价，但不建议这样写

int i = 0;
int *const p1 = &i;		//p1是指针，p1的指向不能改变，顶层
const int ci = 42;		//ci是普通变量，ci的值不能改变，顶层
const int *p2 = &ci;	//p2是一个指针，它必须指向 const int型的数据，但是本身的指向可以改变，底层
const int *const p3 = p2;	//第一个底层，第二个顶层
const int &r = ci;			//用于声明引用的const都是底层

const int *p1 = nullptr;
constexpr int *p2 = nullptr;
int *const p3 = nullptr;

constexpr const int *pi = nullptr;
// 等价定义
const int *const pi = nullptr;

typedef double wages;		//wages表示是double类型
typedef wages base, *p;		//base = wages = double, p = double*
//数组的别名
typedef int arrT[10];		//arrT是一个类型别名，他表示的类型是含有10个整数的数组
using arrT = int[10];		//和上面的等价

using SI = Sales_item;		//Sales_item是一个类类型， SI表示是该类的别名

typedef char* pstring;
const pstring cstr = 0;		//char *const cstr = 0;
const pstring *ps;			//char **const ps;

int val1 = 1, val2 = 3;
auto val = val1 + val2;		//编译器可以自动推出val为int类型
auto i = 0, *p = &i;		//正确，编译器通过字面值推出i为int,p为int*
auto sz = 0，pi = 3.14;		//错误，编译器无法推出类型， sz， pi类型不一致无法统一

decltype(f()) sum = x;		//sum的类型和f()的返回类型一样

const int ci = 0, &cj = ci;
decltype(ci) x = 0;		//const int x = 0
decltype(cj) y = 0;		//const int &y = 0;
decltype(cj) z;			//错误， const int &z;  引用必须初始化

int i = 42, *p = &i, &r = i;
decltype(r + 0) b;		//int b;
decltype(*p) c;			//错误， int &c; 引用需要初始化

decltype((i)) d;   	//错误， int& d; 引用类型需要初始化
decltype(i) e;		// int e;

class ClassName{
	//属性
	//方法
};

struct ClassName{
	//属性
	//方法
};