int** arr_pp new int* [row_num];// 定义一个存储指针的数组的指针 行数
	for(i = 0; i < row_num; ++i)
	    arr_pp[i] = new int[col_num];// 一个一个new 指针每一行是一个行向量的指针

	vector<vector<int>> v_i2(row_num,vector<int>(col_num,0));//初始化为一个0矩阵
	vector<int> m;  
        m.reserve(1000);//提前保留1000的内存
	//使用 reserve 避免不必要的重新分配 

int val = 1024;//整形变量
int &refVal = val;// 整形引用 refVal 指向 val ，是val的另一个名字，
                 // 引用必须被初始化，引用不是对象，只是为所存在的对象起的一个别名。
refVal = 2;       // 把2 赋值给refVal 也就是 赋值给了 val
int i = refVal;   // 相当于 i = val; 
int &refVal2 = 10;// 错误，非常量引用只能绑定(bind)在对象向,
                  // 不能与字面值或某个表达式的计算结果绑定在一起, 且引用的类型 必须和 对象的类型一致
const int &rci = 10;// 常量引用可以绑定到 字面值 非常量 一般表达式
double dval = 3.14;// 浮点数
int &refVal3 = dval; // 错误，引用的类型 和 对象 必须一致

int ival = 42;  // 整数
int *p = &ival; // 指针定义 p存放 ival对象存放的地址，也即是 p 指向 变量 ival的指针   &ival 为取的 ival变量的 存储地址
double dval = 3.14; // 浮点数
double *pd = &dval; // double 类型 指针
double *pd2 = pd;   // pd存放 的是 dval存放的地址

int *pi = pd;     // 错误， 指针pi 的类型 和 右边指针对象 类型 不匹配
pi = &dval;   // 错误， 视图把 double 类型对象的地址 给 int类型的指针 错误  左右两边类型 必须匹配

int ival = 42; //整形 变量
int *p = &ival;//指针变量定义初始化， p 存放着 变量ival 在内存中的地址
std::cout << *p;// 表达式里 *p 为 解引用 取的p存放的地址 指向的值
int &ref_i = ival; // 引用声明定义， ref_i 是一个引用
int *p; //指针声明定义，p是一个指针
p = &ival;// 表达式 p为指针（地址），&val 为取的 val 地址
*p = ival;   //表达式  *p 相当于 ival *是一个解引用
int &ref_i2 = *p;// &ref_i2 为引用定义 *p 相当于 ival， *是一个解引用

int *p1 = nullptr;// 等价于 int *p1 = 0; 空指针  p1 不指向 任何 对象
int *p2 = 0; // 空指针     等价于 int *p1 = 0;
int *p3 = NULL;// 空指针   等价于 int *p1 = 0;
int zero = 0;
int *p4 = zero;// 错误，不能把 int 变量直接赋值 给指针

int i = 42;
int *pi1 = 0; // pi1 被初始化为空指针，但没有指向 任何对象
int *pi2 = &i;// pi2 被初始化，存有 i 的地址
int *pi3;// 定义 未初始化
pi3 = pi2;// pi3 和 pi2指向同一个 对象 i
pi2 = 0; // 现在 pi2 被赋值为 空指针 不指向任何对象  指针被改变， 指向的对象不变
pi2 = &i;// 现在 pi2 又指向 i
*pi2 = 0;// 指针pi2 没变 , *pi2 被改变 即pi2指向的对象 i 发生了变化

double obj = 3.14, *pd = &obj; // double 类型 的变量 double类型的指针
void *pv = &obj; // obj 可以是任意类型的对象
pv = pd; // pv 可一存放任意类型的指针（地址）
double *pd = (double*)(pv);// void* 类型的指针 强制转化成  double* 类型的指针

int i = 1024， *p = &i, &r = i;//i是整形变量 p是一个整形指针 r是一个整形引用
int* p1, p2;// * 仅仅修饰 p1 ，即p1是 指向整形的指针 p2是整形变量
int *p1, *p2;// p1 和 p2 都是指向 整形的指针

int ival = 1024;
int *pi = &ival; //指向整形变量的指针
int **ppi = π //指向整形指针的指针  ppi ---> pi ------> ival
std::cout << ival << "\n"// 直接输出 变量值
      << *pi  << "\n"// 1次解引用 得到变量值
      << **ppi<< "\n";//2次解引用 的到变量值

int i = 42;//整形对象
int *p;//指向整形类型的指针
int *&r_p = p;//引用r_p的类型为 整形的指针引用int*&，r_p 是指针p的一个别名 
           //从右向左 离变量最近的符号为 & 即为 引用，* 引用的为 指针类型
r_p = &i;// 相当于 p = &i p 指向 i
*r_p = 0;// 相当于 *p = 0 即 i =0 改变了指针指向对象的值  
         // 这里 *p *解引用指针的类型其实相当于 原变量的别名 引用

const int bufSize = 512;//初始化常量 一旦创建后就不能被修改
bufSize = 1024;// 错误，常量不能被赋值
const int i = get_size();// 一个函数赋值 运行时初始化
const int j = 42;//编译时初始化
const int k;//错误，常量定义式必须初始化
double dvel = 3.14;//  也可以由其他类型变量 强制转换成 常量
const int ci = dvel;// 由double类型变量 强制转换成 整形常量 3
extern const int bufSize = 1024;//定义了一个变量，想在其他文件也使用 bufSize 必须在定义之前 加extern
extern const int bufSize;// 另一个文件中 声明 bufSize 后 就可以使用了

        const int c_i = 1024;   // 常整数
        const int &r_c_i = c_i; // 常整数 c_i 的 引用（别名）
        r_c_i = 42;// 错误r_c_i 是常量引用 不能被修改
        int &r_c_i2 = c_i;//错误 常整数 不能赋值给 int变量 左右两边类型必须一样

const double pi = 3.14;//双精度 浮点型 常量
double *ptr_d = π// 错误，浮点型变量指针 不能绑定一个 常量的存储地址
const double *ptr_d_c = π// 双精度常量 针 ptr_d_c  指向一个 双精度常量
*ptr_d_c = 42;// 不能给 pi 赋值 指向常量的指针的解引用相当于 绑定的常量 ，因此不能赋值
doubel dvel = 3.14;//双精度变量
ptr_d_c = &dvel;//允许 常量指针ptr_d_c 指向一个变量dvel 但是不能通过 常量指针ptr_d_c 修改变量dvel

int errNumber = 0;//
int *const conpErr = &errNumber;// * 可变指针  *const 常量指针不可变 
                               // 指向整形的 常量指针，conpErr 一直指向 errNumber
*conpErr = 3;//相当于 errNumber = 3
const double pi = 3.14;//
const double *const cd_cp = π//指向 常量的常量指针，
                               // 即 指针本身cd_cp不能变， 其指向的值 *cd_cp也不能变

const int *p = nullptr;// 指向整形常量 的指针
constexpr int *p = nullptr;// 指向整形变量的 常量指针 
                           // constexpr 声明中出现 指针 仅仅说明 指针为常量指针
int *const p =nullptr;//指向 整形变量的 常量指针
const int *const p = nullptr;// 指向 整形常量 的常量指针
constexpr const int *p = nullptr;// 指向 整形常量 的常量指针

constexpr int ci = 42; // ci 是整形常量
int j = 0;
constexpr int *pci = &j; // 指向整形的 常量指针

typedef double wages;   // wages 是double类型的 同义词
typedef wages base, *p; // base 也是double类型的 同义词。 p是double * 的同义词
wages d_money = 1.00;//等有价于 double d_money = 1.00
p p_dmoney =   &d_money;//等价于 double *p_dmoney =   &d_money;
cout << p_dmoney << endl; 
 // 别名声明 alias declaration
using SI = Sales_Item; // SI 是 Sales_Item 的 同义词
SI item;//等价于 Sales_Item item;
 // 指针、常量const 类别别名
typedef char *pstring;// pstring等价于 char *  指向char 的指针（是指针）
const pstring cstr = 0;// cstr是指向 char 的 常量指针 
                       // ！！！！不是指向常量字符的 指针 不能直接替换 const修饰的主语是指针
const pstring *ps;     // ps是一个指针 它指向的对象 是 指向char的常量指针

auto item = val1 +val2;//item 初始化为 val1 和 val2相加的结果 类型 相同
// 一条语句定义多个变量时，各变量类型必须一致
auto i=0, *p = &i;//正确 i是整数， p是指向整形的指针
auto sz = 0, pi = 3.4;// 错误 sz 和 pi 类型不一致

// 引用 指针 常量 与 auto
int i = 0, &r = i;//r是i的别名 int类型
auto a = r;// a 是一个整形数

// auto 会忽略掉 顶层const
const int ci = i, &cir = ci;// 常整数
auto b = ci;  // b是一个整数，ci的顶层 const(最外层修饰 为顶层)特性被忽略
auto c = cir; // c是一个整数，ci的顶层 const特性被忽略
auto d = &i;  // d是一个指向整形的指针
auto e = &ci; // e是一个指向整形常量的指针 const 
              // 外又被 取地址符号修饰，所以这里的 const是 底层const 不被忽略

// 如果希望 auto 推断出的类型是 一个顶层 const，需要在其前面 明确指出
const auto f = ci; // ci的推演类型是 int ，f是 const int

// 将引用设置为 auto 还按之前的初始化规则  保留 顶层 const
auto &g = ci; // g 是一个 整形常量的 引用 （别名）
auto &h = 42; // 错误，非常量 引用 不能绑定 到 字面值
const auto &j = 42; // 正确， 常量引用可以绑定到 字面值

// 将 指针设置为 auto， 也按之前的初始化规则 保留顶层 const
auto *k = &ci; // k为指向 整形常量的 指针
auto *l = 0;   // l为空指针
const auto *m = &ci; // m 为 指向整形常量的 常量指针

int i = 1024;
const int c_i = i;
auto b = c_i; // b是一个 整数 ,c_i的 顶层 const被忽略
auto e = &c_i;// e 是一个 指向 整形常量的引用  这里的const是底层const 不被忽略
auto k = c_i, &ll = i;// k 是整数， ll 是一个整数引用
auto k = c_i, &o = c_i;// 错误，k 是整数变量 o是一个整数常量引用 类型不一致
auto &m =c_i, *p = &c_i;//正确 m是整数常量引用，p是指向整数常量的指针
auto n = &c_i, *p = &c_i;// 正确 n是整数常量 引用(底层const，不被忽略) p是指向整数常量的指针

decltype(f()) sum = x; // sum 的类型为 函数 f() 的返回值类型 初始化为 x 就像 int sum = x; 一样
const int ci = 0, &cj = ci;// ci 整形常量  cj 整形常量的引用
decltype(ci) x = 0; // x的类型 同ci 是 整形常量 const int 不忽略 顶层 const
decltype(cj) y = x; // y的类型 同cj 是 整形常量的引用 const int &  y绑定到x上
decltype(cj) z;     // 错误 z是一个 引用 ，必须初始化

// decltype和引用 指针
int i =42, j=12, *p = &i, &r = i;
decltype(r) a = j;// a的类型和r的类型一致，为整数的引用 int& a绑定到j上
decltype(r + 0) b;//正确 加法的结果为 整形 int 因此 b为整形， 这里只定义 没有初始化
decltype(*p) c; // 错误 其实*p 解引用指针 相当于i的别名 也就是引用 
              //  所有这里 c的类型为 整数引用 int &，是个引用，必须初始化

// decltype 的表达式如果 加上括号，得到的结果将是引用
decltype(i) e; // e 是一个未初始化的 整形变量
decltype((i)) d = e; // d是一个 整数的引用 绑定到 整形变量 e上  双层引用括号 的结果 永远都是 

// 赋值表达式 也会产生 引用 引用的类型就是 等式左边变量的类型 如果 i是int i = x的类型是 int&

string str("some string");
for (auto c : str)// auto自动推断类型
cout << c << endl; 
// 范围for 引用 改变 内容
string s("Hello World!!!");
for (auto &c : s)// c是 字符串中每个元素的一个别名
c = toupper(c);//变成大写
cout << s << endl;

// 第一个字符改为大写
string s("some string");
if(!s.empty())
	s[0] = toupper(s[0]);//第一个字符改为大写  在 cctype头文件中
// 第一个单词改为大写
for(decltype(s.size()) index = 0;
    index != s.size() && !isspace(s[index]; ++index))
	s[index] = toupper(s[index]);

// 初始化方式
vector<int> ivec(10,-1);// 直接初始化 10个元素 全为 -1
vector<int> ivec2 = ivec;//拷贝初始化
vector<int> ivec3{10};//一个元素 10 
vector<int> ivec3{10，1};//两个元素 10  和 1
vector<string> svec{"a","an","the"};//列表初始化 直接方式
vector<string> svec2 = {"a","an","the"};//列表初始化 拷贝方式

// 默认初始化 
vector<int> ivec(10);    // 10个元素，每个值都是0 
vector<string> svec(10); // 10个元素，每个值都是空 string 对象
vector<string> svec2{10};// 10个元素，每个值都是空 string 对象
vector<string> svec3{10, "hi"};// 10个 "hi"元素
vector<string> svec3(10, "hi");// 10个 "hi"元素

// 使用 .push_back() 添加元素
vector<int> ivec2; //空vec对象
for(int i = 0; i != 100; ++i)
ivec2.push_back(i);// 一次把整数值 放到 ivec2尾部 结束后 ivec2有100个元素 0~99

// 实时添加 string 元素
string word;
vector<string> text;//空对象
while (cin >> word) 
text.push_back(word);// 把word添加到 text 后面

//使用范围for  + 引用 访问 并改变vector元素
vector<int> iv{1,2,3,4,5,6,7,8,9};// 列表直接初始化
for (auto &i : v)// 对于v中每个 元素的 引用 需要改变其值
i *= i;      // 变成原来值 的 平方
for (auto i : v) // 仅读取其中的变量
cout << i << " ";
cout << endl;

// vector 对象大小 类型为size_type
vector<int>::size_type se = iv.size();

// 使用索引[] 访问 计算vector对象元素索引   统计各个分数段上 出现的 成绩个数
// 索引不能添加元素
vector<unsigned> scores(11,0);//11个分数段， 0~9，10~19，...,90~99，100 计数值全部初始化为0
unsigned grade;
while (cin >> grade){
if(grade <= 100) ++scores[grade/10];
}    

// cin 读入一组词 改成大写 存入 vector中  #include <cctype> 使用toupper()
vector<string> sv;
string word1 = "qwe";
cout << word1 << endl; 
while(cin >> word1){
	for (auto &c : word1) c = toupper(c);
	sv.push_back(word1); 	
	cout << word1 << endl; vector  
}

// 修改 字符串 第一个元素为大小字符
string s("some string");
if (s.begin() != s.end()){//确保 s非空
  auto it = s.begin();// it 指向 s的第一个字符 类似指针 的作用
  *it = toupper(*it);// 将当前字符改写成大写形式  *it 解引用迭代器 得到其所指向的 对象  是其指向对象的别名 引用
}

// 字符串的第一个单词 改写成大写
for (auto it = s.begin(); it != s.end() && !isspace(*it); ++it)
	*it = toupper(*it);

// 迭代器类型  iterator (具有读写功能)  const_iterator 具有 读功能  不具有写功能
// 对象为常量 只具有常量类型的迭代器 const_iterator  对象为变量具有 iterator 和 const_iterator
vector<int>::iterator it;// 迭代器 it 可以读写 vector<int> 类型容器 的元素
 string::iterator it2;   // it2 可以读写  string对象 中的字符
 vector<int>::const_iterator it3;//it3只能读元素，不能写元素
 string::const_iterator it4;     //it4只能读字符，不能写字符

 // cbegin()   cend() 返回 常量 迭代器 仅能读取 容器元素 不能修改
 vector<int> iv;        // 变量
 const vector<int> civ; // 常量
 auto it1 = iv.begin(); //  it1的类型为 vector<int>::iterator  能读写iv的元素
 auto it2 = iv.cbegin(); // it2的类型为 vector<int>::const_iterator  能读iv的元素 不能修改 iv的元素
 auto it3 = civ.begin(); // it3的类型为 vector<int>::const_iterator  能读civ的元素 不能修改 civ的元素

  // 访问 容器元素对象的 成员函数   (*it).empty  等同于 it->empty()  解引用 和成员访问
  vector<string> text;
  for (auto it = text.cbegin(); it !=text.cend() && !it->empty(); ++it)
	cout << *it << endl;

  // 迭代器 运算
  auto mid = iv.begin() + iv.size()/2; //指向容器的中间位置
  if (it < mid) // 处理前半部分元素

// 两个迭代器相减 得到的类型为 带符号整数  difference_type

// 常规二分查找算法
// 升序数组 查找的元素  范围开始  结束 
int BinarySearch(int *array, int key, int low, int high)
{
    int mid;
    while (low <= high)//  缩小范围 
    {
	mid = (low + high) / 2;//更新中间元素的 下标 
	if (key == array[mid])//中间元素是否 等于所查找的元素 
	    return mid+1;//相等 返回元素下标  
	else if (key < array[mid])//所查元素 比 中间元素小  则在 前区间查找 
	    high = mid - 1;//将区间 右侧 退后 到 中间元素下标前一个元素  搜索 范围为  low，mid-1
	else//所查元素 比 中间元素大 则 在后区间查找 
	    low = mid + 1;//将区间  左测 提至  中间元素下标后一个元素    搜索 范围 mid+1，high
    }
    return 0;
}

// 使用迭代器完成二分查找
 vector<int> text// 升序容器
 auto b = text.begin(), e = text.end();//起始 结束位置
 auto mid = b + (e - b)/2;//中间位置
 while(low <= end && *mid != key){
	if(key < *mid) e = mid - 1;//所查元素 比 中间元素小  则在 前区间查找
	else b = mid + 1;// 所查元素 比 中间元素大 则 在后区间查找
	mid =  b + (e - b)/2;//更新 中间位置
 }

// 使用索引[] 访问 计算vector对象元素索引   统计各个分数段上 出现的 成绩个数
// 索引不能添加元素
vector<unsigned> scores(11,0);//11个分数段， 0~9，10~19，...,90~99，100 计数值全部初始化为0
unsigned grade;
while (cin >> grade){
if(grade <= 100) ++scores[grade/10];
} 
// 使用迭代器 访问 计算vector对象元素索引   统计各个分数段上 出现的 成绩个数
vector<unsigned> scores(11,0);//11个分数段， 0~9，10~19，...,90~99，100 计数值全部初始化为0
unsigned grade;
auto it0 = scores.begin();
while (cin >> grade){
	auto it = it0 +  grade/10;
	if(grade <= 100) ++*it;
} 

constexpr unsigned sz = 42;//constexpr修饰，常量表达式
int arr[10];  //字面值常量初始化  含有10个整数的数组
int arr2[sz]; //常量表达式初始化 含有42个个整数的数组
int *parr[sz];//常量表达式初始化 含有42个指向整数的指针的数组

定义时必须指定数组类型，不能由auto来推断
不存在引用的数组，引用不是对象！！！
string nums[] = {"one", "two", "three"};// 数组元素是string对象
string *sp = &nums[0];// p指向nums的第一个元素
string *sp2 = nums;   // 等价于 string *sp2 = &nums[0]

auto sp3(nums); //sp3 是一个string指针，指向nums的第一个元素
// 而decltype关键字 声明的 不发生上述转换
 decltype(nums) sa = {"two", "three", "four"};//sa 是一个 含有3个string对象的 数组

const unsigned sz = 3;//
int ia1[sz] = {0, 1, 2};//列表初始化 含有3个元素
int ia2[] = {0, 1, 2};//维度为3
int ia3[5] = {0, 1, 2};//等价于 {0, 1, 2, 0, 0}

// 字符数组
char ca1[] = {'C', 'P', 'P'};//列表初始化
char ca2[] = {'C', 'P', 'P', '\0'};//含有显式的 空字符
char ca3[] = "CPP";//字符串字面值初始化 自动添加表示字符串结束的空字符

// string 对象初始化 字符数组
string s("Hello World");
const char *str = s.c_str();// 用string对象初始化 字符数组 需要使用 c_str() 方法 最好再重新拷贝一份

// 数组  初始化 vector 对象
int i_arr[] = {1, 2, 3, 4, 5, 6};
vector<int> ivec(begin(i_arr), end(i_arr));//全部副本
vector<int> sub_ivec(i_arr + 1, i_arr + 4);// 包含 {2, 3, 4, 5}四个元素

// 不允许拷贝和赋值
char ca4 = ca3;// 错误

// 复杂的数组声明定义
int *parr[10];// 是数组，包含10个整形指针的数组
int &rarr[10]=?;//错误，不存在 引用数组，引用不是对象
int (*Parray)[10] = &arr;//是指针，指向一个含有10个整数的数组
int (&Rarray)[10] = arr;//是引用，引用一个含有10个整数的数组	

//下标访问修改元素
unsigned score[11];//11个分数段
unsigned grade;
while(cin >> grade){
    if(grade <= 100) ++score[grade/10];//对应段 计数+1
}
// 范围for 访问修改所有元素
for( auto i:score)//可以设置为 引用就可以修改元素了
    cout << i << " ";
cout << endl;

// 指针访问数组
int iarr[] = {0,1,2,3,4};//含有5个元素
int *pi = iarr;//指向第一个元素的指针 iarr[0]
int *pi2 = iarr + 2;//指向第三个元素的指针 iarr[2]
auto num = end(iarr) - begin(iarr); // num的值是5 就是iarr包含元素的数量 
                               // ptrdiff_t 类型 是signde类型 结果可能为负
++pi;//指向第二个元素 iarr[1]
j = pi[1];   // 等价于 *(p+1),就是 iarr[2], 就是 2
k = pi[-1];  // 等价于 *(p-1),就是 iarr[0], 就是 0
pi + 3;//指向最后一个元素
*pi;//第二个元素 4
int last =  *(iarr + 4);// 等价于 last = iarr[4];
int *end = &iarr[6];//指向尾后的位置 到达不了    不能执行解引用运算！！！！！
// 使用 for 
fot(int *begin = arr; begin != end; ++begin)
	cout << *begin  << endl;//输出每一个元素
// 使用 while
while(begin<end){//指针指向相关的对象 可以比较大小（单位（间隔）一样大）
	cout << *begin  << endl;//输出每一个元素
	++begin;
}

//标准库函数 begin() end() 函数得到指针
int iarr = {0,1,2,3,4};//函数5个元素
int *beg = begin(iarr);//首元素指针
int *end = end(iarr);//尾后指针                 不能执行解引用运算！！！！！
while(beg != end && *beg >=0) ++beg;//找第一个负值元素

constexpr size_t row =3, col = 4;
int iarr[row][col];//定义未初始化

//下标运算符（size_t 类型） for 循环初始化
for(size_t i = 0; i != row; ++i){
	for(size_t j = 0; j != col; ++j){
		iarr[i][j] = i * col + j;//元素索引为其 值
		cout << iarr[i][j] << ' '; // 访问输出  数组元素
		}
	 cout << endl;	
}

// 范围for 初始化
size_t cnt = 0;
for (auto &row1 : iarr)//每一行 引用  int (&row1)[4] 是引用 引用一个含有4个整数的数组
 {	
	for (auto &col1 : row1){// int &col1 每一行的每一个元素 引用  可以读写 除去最内层外 其它必须使用 引用
	col1 = cnt;//赋值
	cout << col1 << ' ';// 访问 输出数组元素
	++cnt;
	}
	cout << endl;
 }	

// 指针访问
int (*p)[4] = iarr;//p 指向一个含有4个整数的数组 iarr的 第一行   圆括号必不可少
p = &iarr[2]; // iarr的 第3行
// for 循环访问
for( auto p = ia; p != ia + row; ++p){// 相当于定义 int (*p)[4] = iarr; p 指向 含有4个整数的数组
	 for( auto q = *p; q != *p + col; ++q) 
	     // *p 为含有4个元素的数组 q指向数组的首元素，即指向一个整数 int *q = *p
		cout << *q << ' ';
	 cout << endl;
}
// 使用 标准库函数 begin() 和 end()
for( auto p = begin(ia); p != end(ia); ++p){
               // 相当于定义 int (*p)[4] = iarr; p 指向 含有4个整数的数组
	 for( auto q = begin(*p); q != end(*p); ++q) 
	       // *p 为含有4个元素的数组 q指向数组的首元素，即指向一个整数 int *q = *p
		cout << *q << ' ';
	 cout << endl;
}	
// 使用类型别名
using int_arr_tpye = int[4];// int_arr_tpye为包含4个元素的整形数组
typedef int int_arr_tpye[4];// 效果同上
for( int_arr_tpye *p = ia; p != ia + row; ++p){// 相当于定义 int (*p)[4] = iarr; p 指向 含有4个整数的数组
	 for( int *q = *p; q != *p + col; ++q) // *p 为含有4个元素的数组 q指向数组的首元素，即指向一个整数
		cout << *q << ' ';
	 cout << endl;
}

int fact(int val){
	int ret = 1;
	while(val >1) ret *= val--;
	return ret;// 返回主调函数 结束函数调用
}

int main(){
int j = fact(5);// 实参5 初始化 形参（int val）
cout << "5! = " << j << endl;
return 0;
}

// 定义
int count_call(void){
 int c =0;        //局部自动对象 每一次调用都初始化为 0  
 static int sc =0;//局部静态变量 第一次调用初始化为0 以后每次调用在前一次值上 +1 
 cout << ++sc << "   " << ++c << endl; 
}
// 调用
int main(){
 for(int i =0; i<10; ++i)  count_call(); //sc 输出 1 2,...10，c 输出一直是1
 return 0;
}

// 源文件 fact.cc
#include "fact.h"
int fact(int val){
	int ret = 1;
	while(val >1) ret *= val--;
	return ret;// 返回主调函数 结束函数调用
}
// 函数声明头文件 fact.h
#ifndef FACT_H
#define FACT_H
int fact(int val);// 函数声明 
#endif
// 主函数调用 fact_main.c
#include <iostream>
#include "fact.h"
using namespace std;
int main(){
int j = fact(5);// 实参5 初始化 形参（int val）
cout << "5! = " << j << endl;
return 0;
}
// 编译
gcc fact_main.c fact.cc -o main

int n=0;
int i = n;// n拷贝给i
i = 42;//i的值改变， n的值不变    函数对形参做的所有操作 都不会影响实参 例如 fact(i) 不会改变i的值

int n = 0;
int &r_i = n;//r_i 是 n 的引用 即别名 同一个变量
r_i = 42;//r_i 和 n 都变成 42    

int n=0, i =42;
int *p_n = &n, *p_i = &i;// 指针
*p_n = 100;// n 的值 变为100 指针p_n（变量你存储的地址） 不变
p_n = p_i;// 现在 p_n  和  p_i 都指向了 i

// 指针形参 函数
void reset(int *pi){
 *ip = 0;//改变了指针 pi 所指向的对象的值
 ip = 0;// 值改变了 形参ip的值 实参未被改变
}

// 调用
int i = 42;
cout << "address of i =" << &i <<endl;
reset(&i);// i 的值改变为0
cout << "i = " << i << endl;// i 的值改变为0
cout << "address of i =" << &i <<endl;// i 的存储地址未改变

// C 程序中 通常使用 指针类型的形参 来访问和改变 函数外部的对象
// C++ 程序中，建议使用引用类型的形参代替 指针形参，这样会更安全，也省时间（引用 无拷贝操作）

// 使用 引用避免拷贝 拷贝大的类对象或容器 都比较低效 费时

 void reset(int &i){
  i = 0;// 改变了i所引用的对象
 }
 // 调用
 int j = 42;
 reset(j);// 采样传 引用方式，它的值被改变 调用时 形参i 只是 实参j的一个别名，在函数reset内部对i的操作，即对j的使用
 cout << "j = " << j << endl;

// 比较两个字符串的长度
bool isShorter(const string &rs1, const string &rs2){
	return rs1.size() < rs2.size();
}

// 函数返回多个值 返回字符在某个字符串中第一次出现的位置，并返回出现的 总次数
string::size_type find_char(const string &crs, char c, string::size_type &occurs){
				// 字符串        查找的字符      出现的次数
	auto ret = crs.size();//初始化 第一次出现的位置
	occurs = 0;//初始化 出现的次数
	for(decltype(ret) i = 0; i != crs.size(); ++i){
	  if(crs[i] == c){// 出现字符 c
	    if (ret == crs.size())//位置 还未改变 为  第一次出现 
	    ret  = i;//记录第一次出现的位置
	    ++occurs;//出现次数 +1  通过形参引用间接返回 出现的次数
	  }
	}  
	return ret;//返回第一次出现的位置
}

// 调用
string s("some string");
string::size_type count = 0;
auto index = find_char(s, 'o', count);

// 判断 string对象是否是 一个句子
 bool is_sentence(const string &crs){
	  // 如果 find_char() 的string参数 必须为 string & 那么不能直接把 const string & 带入
	  // 需要再定义一个 string对象， 另其为 crs 的副本，再带入
	 string::size_type count = 0;
	 return (find_char(crs, '.', count) == (crs.size() - 1)) &&  count == 1;
 }

// 三个函数等价 形参 都是 const int * 类型
void print(const int*);
void print(const int[]);
void print(const int[10]);// 这里的维度表示期望数组含有多少元素，实际不一定
//调用
int i = 0;
j[2] = {0, 1};
print(&i); //&i 是int *类型 可以赋值给 const int *类型
print(j);  //j 为 &j[0] 是 int * 类型

// C风格字符串 带有一个空字符
void print(const char *cp){
  if(cp)// 确定 cp 不是一个空指针
    while(*cp) // 只要 指针所指的字符不是 空字符
       cout << *cp++;// 打印 字符
}

void print(const int *beg, const int *end){
  while(beg != end) 
    cout << *beg++ << endl;//输出当前元素 并将指针向前移动一个位置
}
// 调用
int j[2] =  {0, 1};
print(begin(j), end(j));// 使用标准库 begin() 和 end() 函数

void print(const int ia[], size_t size){
  for (size_t i = 0; i != size; ++i) 
     cout << ia[i] << endl;// 等价于 cout << *(ia+i) << endl;
}
// 调用
int j[2] =  {0, 1};
print( j, end(j) - begin(j) );// 使用标准库 begin() 和 end() 函数 做差来得到数组的大小

void print(int (&r_arr)[10]){ // 注意形式 int (&r_arr)[10]   而 int &arr[10] 成了 包含引用的数组（还不存在，引用不是对象）
  for (auto elem : r_arr)// 变量数组每个元素  范围for
    cout << elem << endl;
}
// 调用 调用时 必须是 大小为10的整形 数组作为实参才可以
int k[10] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
print(k);// 大小必须为10 多一点 少一点 都不行

void print(int (*p_arr)[10], int rowSize){}// 形参是 指向 一个含有10个整数的指针

// argc：argument counter 参数计数,argv：argument vector 参数 字符串 容器
int main(int argc, char *argv[]){}
int main(int argc, char **argv){}//第二个参数为 字符串数组 即数组的数组 指针的指针   argv 指向 char*
//程序执行 program -d -o outfile data0
则 argc = 5
argv[0] = "program"; // 程序名
argv[1] = "-d";      // 第一个参数 开始
argv[2] = "-o";      // 第二个参数
argv[3] = "outfile"; // 第三个参数
argv[4] = "data0";   // 第四个参数  最后一个指针
argv[5] = 0;   // 最后一个指针之后 的元素为0

// initializer_list 提供的操作
initializer_list<T> lst;// 默认初始化 T类型元素的空列表 模实际需要指定模板T的 具体类型
initializer_list<T> lst{a, b, c...};// 列表中的元素是 const 常量
lst2(lst); // 拷贝一个initializer_list对象，不会新建，原始列表 和 副本 共享元素
lst2 = lst;// 同上
lst.size();// 列表 中的元素
lst.begin();//返回指向lst中首元素的指针
lst.end();  //返回指向lst中尾元素下一个位置的指针
// 因为有 begin() 和 end()对象可以使用 范围for 遍历参数

// 具体
initializer_list<string> ls ;//initializer_list 的元素类型是 string
initializer_list<int> li ;   //initializer_list 的元素类型是 int
// 和vector不同的是 initializer_list中的元素是常量 不能被修改

// 定义函数
void error_msg(initializer_list<string> ls){
	 for(auto beg = ls.begin(); beg != ls.end(); ++beg)
	   cout << *beg << " ";
	 cout << endl;
}
//调用函数
//expected 和 actual 是string 对象
if (expected != actual)
	error_msg({"function", expected, actual});
else
	error_msg({"function", "okey"});
// 传递了一个含有不同数量元素的 initializer_list

// 定义函数 包含 ErrCode
void error_msg(ErrCode e, initializer_list<string> ls){
	 cout << e.msg() << ": "
	 for(const auto &elem : ls )//范围for 遍历
	  cout << elem << " ";
	 cout << endl;
} 

void foo(param_list, ...)//
void foo(param_list...)//
void foo(...)//

// 交换两个值的函数
void swap(int &r_i1, int &r_i2){
   if (r_i1 == r_i2)// 两个值相等 无需交换
      return;
   // 若 执行 到这里，说明还需要继续完成下面的功能 
   int temp = r_i1;//
   r_i1 = r_i2;
   r_i2 = temp;
   // 此处 无需 显示的 return 语句   会隐式指向 return
}

// 两个 string 对象是否 最短的部分 是相同的
bool str_subrange(const string &str1, const string &str2){
 if (str1.size() == str.size())
     return str1 == str2; // 之间判断 相同长度间的部分是否相同
 auto size = (str1.size() < str2.size()) ? str1.size() : str2.size(); //得到最短 字符串的 长度
 for(decltype(size) i = 0; i != size; ++i){
   if ( str1[i] != str2[i])// 如果 有 不相等的 字符 返回 false
    return false;// 有 不相等的 字符 返回 false
  }
 return true; // 否者 相等 返回 true
}

// 不要 返回 函数内部 临时变量的 引用
string temp("glo");
const string &mainip() {
	 string ret("Empty"); // 函数内部临时变量
	 return ret; // 错误 ，不能返回 临时变量 作为 函数返回值的 引用
	 // return temp;// 返回 一个调用函数之前就出现的 变量 的引用     或者  参数 为引用类型的参数也可以
}

// 返回 两个字符串中 短的那个
const string &shortString(const string &s1, const string &s2){// 返回 s1 或者 s2的引用
	return s1.size() < s2.size() ? s1 : s2;//返回 两个字符串中 短的那个
}

// 函数返回类型 为 标准库 类类型 可以直接调用 其成员函数
auto sz = shortString(s1, s2).size()// 得到最短字符串 的长度

// 返回 非常量的引用 可以作为 左值 被赋值  
char &get_char(string &str, string::size_type id){
	return str[id];// 获取指定位置的 字符
}
// 调用
string s("a value");
cout << s << endl;// a value
get_char(s, 0) = 'A';// 将s第一个位置上的字符 替换为 大写的 A
cout << s << endl;// A value
// 而返回为 常量引用 的不能被赋值
shortString("hi", "bye") = "X"; // 错误 函数返回值是个 常量引用 不能被赋值

vector<string> process(){
	if(expected.empty())
	  return {};// 返回一个 空vector对象
	else if (expected == actual)
	  return {"function", "okey"};
	else 
	  return {"function", expected, actual};
}

// 计算阶乘的函数
int factorial( int val){
	if(val > 1)
	   return val * factorial(val-1);
	else 
	    return 1;
}
// 递归 返回一个vector的元素函数
void print_vec(vector<int> vi){
	auto it = vi.begin();
	if(vi.size() > 1)
	 {
	   cout << *it <<endl;
	   vi.erase(it);
	   print_vec(vi);
	}
	else 
	   cout << *it <<endl;
}

// 使用类别别名
typedef int arrT[10];// arrT是一个类别别名 表示一个 含有 10个整数 的 数组
using arrT = int[10];// 同上
arrT* func(int i);   // 函数func 返回一个 指向 10个整数的数组的 指针

//直接声明
int arr[10]; //arr 是一个 含有 10个整数的数组
int *arr_p[10]; //arr_p 是一个数组   含有 10个指整形针 的 数组
int (*p2)[10] = &arr; // p2 是一个指针， 指向一个含有 10个整数的 数组 arr
// 函数声明 类似
Type (*function_name(parameter_list))[dimension]
int ( *func(int i) )[10];// 声明一个函数 其形参为 int i ,返回类型 为 指针 ，指向 一个 含有 10个整数的 数组

// 函数指针数组
多个函数可以像数组一样被调用
int (*fun_p_a[])(char *tmp); //函数指针数组

// 使用 auto 和 尾置返回类型
auto func(int i) -> int(*)[10];// 声明一个函数 其形参为 int i ,返回类型 为 指针 ，指向 一个 含有 10个整数的 数组

// 使用 decltype 知道返回数组  类似类别别名 声明 定义
int odd[] = {1, 3, 5, 7, 9};
int even[] = {0, 2, 4, 6, 8};
decltype(odd) *arrPtr(int i){ //使用decltype(odd) 表面类型与 odd类似
 return (i%2) ? &odd : &even;// 返回一个指向数组的指针
}

// 声明一个 返回 引用 一个 含有10个string对象的数组 的函数
string ( &func_r(string str) )[10];// 直接声明
  // 使用类别别名
typedef string arrS[10];// 类别别 含有10个string对象的数组
using arrS = string[10];// 同上
arrS &func(string str);   // 函数func 返回一个 指向 10个整数的数组的 指针
  // 使用 auto 和 尾置返回类型
auto func(string str) -> string(&)[10];
  // 使用 decltype 知道返回数组  类似类别别名 声明 定义
string str_arr[] = {"a string", "two"};
decltype(str_arr) &arrPtr(string str);

// 打印 数组元素的 几个 同名函数
void print(const char *cp);//出入参数为 带有结束符的