1 补充：局部变量、全局变量、静态全局变量和静态局部变量之间的区别
2 
3 　　　　（1）局部变量，指的是在代码块中（大括号之间）声明的变量，在执行这些块的时候，计算机将为这些变量分配内存；在函数结束的时候，计算机将释放这些变量占用的内存。如果局部变量的名称和全局变量的名称一致，在包含该局部变量的代码块中，声明局部变量之后的代码中局部变量优先；如过要在声明局部变量后面的代码中要使用相同名字的全局变量，需要在变量前加上::。
4 
5 　　　　（2）全局变量，指的是在代码块（包括函数）之外声明的变量，全局变量能够被该文件中的所有函数反问并修改，并且在其他文件中使用了extern声明的也可以访问该全局变量。
6 
7 　　　　（3）静态局部变量，静态局部变量和局部变量的区别在于其生命周期。局部变量的声明周期时包含该局部变量的块的声明周期，而静态局部变量的生命周期时整个程序。
8 
9 　　　　（4）静态全局变量，静态全局变量和全局变量的区别在于其作用域。全局变量的作用域是声明该变量的文件以及其他使用了extern声明的文件；而静态全局变量的作用域被限制在声明该变量的文件中，其他文件无权访问。

 1 （1）、
 2 　　对静态数组名进行sizeof运算时，结果是整个数组占用空间的大小；
 3 　　因此可以用sizeof(数组名)/sizeof(*数组名)来获取数组的长度。
 4 　　int a[5]; 则sizeof(a)=20,sizeof(*a)=4.因为整个数组共占20字节，首个元素（int型）占4字节。
 5 　　int *a=new int[4];则sizeof(a)=sizeof(*a)=4,因为地址位数为4字节，int型也占4字节。
 6 （2）、
 7 　　静态数组作为函数参数时，在函数内对数组名进行sizeof运算，结果为4，因为此时数组名代表的指针即一个地址，占用4个字节的内存(因为在传递数组名的参数时，编译器对数组的长度不做检查)。对动态数组的函数名，无论何时进行sizeof运算，得到的结果都是4.
 8 （3）、
 9 　　new还需要你delete，是在堆分配空间，效率较低；而静态数组直接在栈上分配，会自动释放，效率高，但是栈空间有限。
10 （4）、通过函数返回一个数组的问题
11 　　函数声明的静态数组不可能通过函数返回，因为生存期的问题，函数调用完其内部变量占用的内存就被释放了。如果想通过函数返回一个数组，可以在函数中用new动态创建该数组，然后返回其首地址。　　
12 　　其原因可以这样理解，因为静态数组是在栈中申请的，而函数中的局部变量也是在栈中的，而new动态数组是在堆中的分配的，所以函数返回后，栈中的东西被自动释放，而堆中的东西如果没有delete不会自动释放。

 1 #include <iostream>
 2 
 3 using namespace std;
 4 
 5 int *getStaticArr();
 6 int *getActivityArr();
 7 int main(int argc, const char * argv[]) {
 8 
 9     int *arr = getStaticArr();
10     for (int i = 0; i < 4;  i++) {
11         cout <<"arr["<< i << "] is "<< arr[i]<< " at " << &arr[i] << endl;
12     }
13     cout << endl << endl;
14     arr = getActivityArr();
15     for (int i = 0; i < 4;  i++) {
16         cout <<"arr["<< i << "] is "<< arr[i]<< " at " << &arr[i] << endl;
17     }
18     delete [] arr;
19     return 0;
20 }
21 
22 int *getStaticArr(){
23     int arrn[4] {1,2,3,4};
24     for (int i = 0; i < 4; i ++) {
25         cout << "arrn[" <<i <<"] is " << arrn[i] << " at " << &arrn[i] << endl;
26     }
27     return arrn;
28 }
29 int *getActivityArr(){
30     int *arrm = new  int[4]{2,3,4,5};
31     for (int i = 0;  i < 4; i++) {
32         cout << "arrm[" <<i <<"] is " << arrm[i] << " at " << &arrm[i] << endl;
33     }
34     return arrm;
35 }
36 
37 输出结果：
38 arrn[0] is 1 at 0x7fff5fbff750
39 arrn[1] is 2 at 0x7fff5fbff754
40 arrn[2] is 3 at 0x7fff5fbff758
41 arrn[3] is 4 at 0x7fff5fbff75c
42 arr[0] is 1958675192 at 0x7fff5fbff750
43 arr[1] is 32767 at 0x7fff5fbff754
44 arr[2] is 7977 at 0x7fff5fbff758
45 arr[3] is 1 at 0x7fff5fbff75c
46 
47 
48 arrm[0] is 2 at 0x100200000
49 arrm[1] is 3 at 0x100200004
50 arrm[2] is 4 at 0x100200008
51 arrm[3] is 5 at 0x10020000c
52 arr[0] is 2 at 0x100200000
53 arr[1] is 3 at 0x100200004
54 arr[2] is 4 at 0x100200008
55 arr[3] is 5 at 0x10020000c

 1 #include <iostream>
 2 
 3 using namespace std;
 4 
 5 char *getEnter();
 6 int main(int argc, const char * argv[]) {
 7     char *str = getEnter();//返回的得到的是一个动态数组的第一个元素的地址
 8     cout << str << endl;
 9     delete [] str;//使用完后，需要将动态数组释放掉，避免内存泄漏
10     return 0;
11 }
12 char *getEnter(){
13     char enter[100];
14     cout << "请输入一段字符:\n";
15     cin >> enter;
16     char *str = new char[strlen(enter) + 1];//根据输入的长度来创建一个刚好能够保存输入数据的动态数组，＋1是为了保存字符串结尾的空字符。
17     strcpy(str, enter);
18     return str;
19 }
20 
21 输出结果：
22 请输入一段字符:
23 WhatIsYourMother'sName?//用户输入
24 WhatIsYourMother'sName?

 1 #include <iostream>
 2 
 3 using namespace std;
 4 
 5 int getEnter(int *arr,int max);
 6 int main(int argc, const char * argv[]) {
 7     int arr[5]{0};
 8     int m = getEnter(arr,sizeof(arr)/sizeof(*arr));
 9     cout << "m :" << m << endl;
10     for (int i = 0; i < sizeof(arr)/sizeof(*arr); i++) {
11         cout << "arr[" << i << "] is " << arr[i] << endl;
12     }
13     return 0;
14 }
15 int getEnter(int* arr, int max){
16     double num;
17     int i;
18     for (i = 0 ; i < max; i++) {
19         cout << "Enter value ＃" << (i + 1) << ":\n";
20         cin >> num;
21         if (!cin) {
22             cin.clear();
23             while (cin.get() != '\n')
24                 continue;
25             cout << "Bad input;input process terminated.\n";
26             break;
27         }
28         else if(num < 0){
29             break;
30         }
31         arr[i] = num;
32     }
33     return i ;
34 }
35 
36 输出结果：
37 Enter value ＃1:
38 90
39 Enter value ＃2:
40 45
41 Enter value ＃3:
42 123
43 Enter value ＃4:
44 221
45 Enter value ＃5:
46 1001
47 m :5
48 arr[0] is 90
49 arr[1] is 45
50 arr[2] is 123
51 arr[3] is 221
52 arr[4] is 1001

 1 #include <iostream>
 2 
 3 using namespace std;
 4 
 5 void showArr(const int *begin, const int *end);
 6 int main(int argc, const char * argv[]) {
 7     int arr[6] = {16,21,45,23,80,100};
 8     showArr(arr, arr+sizeof(arr)/sizeof(*arr));
 9     return 0;
10 }
11 void showArr(const int *begin, const int *end){
12     const int *ps;//可以将一个常量赋给一个变量，但是不能将一个指向常量的指针赋给一个指向变量的指针；const int *begin表示begin是一个指向常量的指针。
13     for (ps = begin; ps != end; ps++) {//循环条件
14         cout << "The value at " << ps << " is " << *ps << endl;
15     }
16 }
17 
18 输出结果：
19 The value at 0x7fff5fbff7f0 is 16
20 The value at 0x7fff5fbff7f4 is 21
21 The value at 0x7fff5fbff7f8 is 45
22 The value at 0x7fff5fbff7fc is 23
23 The value at 0x7fff5fbff800 is 80
24 The value at 0x7fff5fbff804 is 100

 1  #include <iostream>
 2  
 3  using namespace std;
 4  
 5  void showArr(const int *begin, const int *end);
 6  int main(int argc, const char * argv[]) {
 7      int m = 10;
 8      const int n = 15;
 9      const int * ptr = &m;
10      //int *pts = &n;不将常量的地址赋给一个指向变量的指针，这样是矛盾的；只能将常量的地址赋给一个指向常量的指针
11      const int *pts = &n;
12      //*ptr = 19; 指向常量的指针，并不意味着指向的一定就是一个常量，只是对于这个指针而言指向的是一个常量，即不能通过该指针来修改指向的内容
13      cout << "修改变量m前*ptr的值：" << *ptr << endl;
14      m = 19;
15      cout << "修改变量m后*ptr的值："<< *ptr << endl;
16      
17      return 0;
18  }
19  
20 输出结果：
21 修改变量m前*ptr的值：10
22 修改变量m后*ptr的值：19

 1 #include <iostream>
 2 
 3 using namespace std;
 4 
 5 int sum(int (*arr)[4], int size);
 6 int main(int argc, const char * argv[]) {
 7     int num[3][4] = {{12,22,32,10},{11,45,34,18},{89,21,42,16}};
 8     cout << sum(num, 3) << endl;
 9     
10     return 0;
11 }
12 int sum(int (*arr)[4], int size ){
13     int sum = 0;
14     for (int i = 0; i < size; i ++) {
15         for (int m = 0 ; m < 4; m ++) {
16             sum += arr[i][m];
17         }
18     }
19     return sum;
20 }
21 
22 输出结果：
23 352

 1 #include <iostream>
 2 
 3 using namespace std;
 4 
 5 unsigned int c_in_str(const char *str, char ch);//由于不需要函数对字符串做出修改，所以将指针声明为const
 6 int main(int argc, const char * argv[]) {
 7     char str[] = "aidfionifeoiaosdf";
 8     cout << "在字符串str中有"<< c_in_str(str, 'f')<<"个字符f." << endl;
 9     return 0;
10 }
11 unsigned int c_in_str(const char *str, char ch){
12     unsigned int num = 0;
13     while (*str) {//通过检查字符是不是空字符来作为字符串结尾条件
14         if (*str == ch) {
15             num ++;
16         }
17         str +=1;
18     }
19     return num;
20 }
21 
22 输出结果：
23 在字符串str中有3个字符f.

 1 #include <iostream>
 2 
 3 using namespace std;
 4 
 5 char *getStr();
 6 int main(int argc, const char * argv[]) {
 7     char *str = getStr();
 8     cout << "获得的字符串："<< str << endl;
 9     delete [] str;
10     return 0;
11 }
12 char *getStr(){
13     char str[100];
14     cout << "请输入一个字符串：\n";
15     cin >> str;
16     char *str1 = new char[strlen(str) + 1];
17     strcpy(str1, str);
18     return str1;//不能返回字符数组，因为常规数组保存在栈区，为自动变量
19 }
20 
21 输出结果：
22 请输入一个字符串：
23 adfadse
24 获得的字符串：adfadse

 1 #include <iostream>
 2 
 3 using namespace s