常用字符串处理函数：

1. 字符串连接函数：（strcat）

   char * strcat (char destination[], const char source[]);
   //功能:将参数2的字符串连接到第1个参数字符串的末尾
   //返回值:第一个字符串的首地址
   //注意:要保证参数1的空间开辟长度足够参数1和2的字符串长度存储，否则内存溢出
   
   //举个栗子:
   char des[50] = "hello "; //保证des的空间足够大
   char src[] = "cctry.com";
   strcat(des, src);
   cout << "des = " << des << endl;	//des = hello cctry.com
   

2. 字符串拷贝函数：（strcpy）

   char * strcpy( char destination[], const char source[]);
   //功能:将第2个参数的字符串拷贝到第1个参数的字符数组中
   //返回值:第一个字符串的首地址
   //注意:要保证第1个参数的字符数组大小够用;第2个参数的结束符 '\0' 也会被拷贝。
   
   //举个栗子:
   char des[50] = {0};
   char src[] = "cctry.com";
   strcpy(des, src);
   cout << "des = " << des << endl;	//des = ccrty.com
   

3. 字符串比较函数：（strcmp）

   int strcmp (const char str1[], const char str2[]);
   //功能:对比第1个和第2个参数的字符数组字符串，逐个字母比对，直到字符串结束
   //返回值:当第1个参数大于第2个参数，返回 > 0 的数，当第1个参数小于第2个参数，返回 < 0 的数，当第1个参数和第2个参数相等，返回0
   
   //举个栗子:
   char des[50] = "hello";
   char src[] = "cctry.com";
   int iret = strcmp(des, src);
   cout << "iret = " << iret << endl;	//iret = 1
   

4. 字符串求长度函数：（strlen）

   size_t strlen (const char str[]);
   //功能:求得参数字符串的长度
   //返回值:返回字符串长度
   
   //举个栗子:
   char des[50] = "hello";
   int len = strlen(des);
   cout << "len = " << len << endl;	//len = 5
   

5. 字符串的长度和占用字节数的区别：

   1. 举个栗子：

      char des[50] = "Hello";
      //字符串长度strlen()
      int len = strlen(des);	//len = 5
      //占用字节数
      int size = sizeof(des);	//size = 50
      

   2. 栗子说明：

      1. 字符串长度：

         只是由字符串开始到出现第一个 ‘\0’ 的字符长度。

      2. 占用字节：

         指的是占用内存的字节大小，是被申请的，即是内存什么都没存储，内存是依然被占用的。

地址与指针:

1. 地址：变量存放的地方，变量的地址

2. 指针：用于存储地址的特殊类型变量

   char* p;	//定义什么类型的指针，就在类型的后面加上一个*，代表是指针类型变量的意思
   int a = 5;	//变量a的内容是5;	&a是变量a的地址
   int* pa = &a;	//'&'是取地址符，此处即为取'a'的地址
   /*注意理解:
   指针也是一种变量，只是它存的是地址而已，并没有多么特殊;
   既然是变量，那么，它就同“int a = 5”一样有内容(存储的是a的地址——&a)，也有地址(放变量pa本身的地址（地方）&pa);
   */
   

   指针变量也是变量，他也有内容和地址。其他类型变量的值或者说内容都是反应自身的。但是指针变量里面的值或者内容是反应其他变量的。

3. 变量与指针：

   1. 变量----->地址：

      int a = 5;
      int* pa = &a;	//将a的地址（&a）存入指针变量pa内
      

   2. 地址----->变量：

      int a = 5;
      int* pa = &a;
      int b = *pa;	//对pa存的地址取值，赋给b;
      

   说明：

   在指针变量的前面加上一个*就能得到指针指向的变量自身。
   所以对一个变量的修改，既可以通过该变量自身（直接修改），也可以通过指针/地址来实现修改（间接修改）。

4. 指针变量的定义与初始化：

   ①指针变量的定义格式如下：

   ​ 基类型 * 指针变量名;
   ②符号* 既可以靠近基类型，也可以靠近指针变量名，例如：
   ​ int* p; 和 int *p; 都是正确的。
   ③指针变量可以在定义的时候就初始化，也可以先定义后初始化，也可以在以后的任意一个时间去指向某个变量的地址：

   int a = 5;
   int *pa;
   pa = &a;
   int *pb = &a;
   

   ④基类型就是该指针变量指向的变量的类型。例如:
   int* pa; 这个指针变量的定义，就是定义了一个指向int类型的指针变量pa；就不能把一个float类型的变量地址赋给他。例如：
   int* pa;
   float a = 2.6;
   pa = &a;
   这种写法是 错误 的。
   ⑤指针变量可以指向同一类型的变量，例如：

   int a = 5, b = 6;
   int *p = &a;
   p = &b;
   

   即：指针变量p既可以指向变量a的地址，也可以指向变量b的地址。

   即：指针变量p既可以指向变量a的地址，也可以指向变量b的地址。

5. 练习：

   1. 实现交换两个参数的值：

      #include<iostream>
      using namespace std;
      
      void swap(int* pa ,int* pb)
      {
          *pa = *pa+*pb;
          *pb = *pa-*pb;
          *pa = *pa-*pb;
      }
      
      int main()
      {
          int a = 1 ,b = 2;
          swap(&a ,&b);
          return 0;
      }
      

   2. 实现一个函数，作用是获取一个数组中的最大值和最小值，函数声明如下：
      void get_min_max(int src[], int* max_v, int* min_v)
      {
      //函数代码写在这个下面
      }

      #include<iostream>
      using namespace std;
      
      void get_min_max(int src[], int* max_v, int* min_v)
      {
          int size_ary = sizeof(src);
          for(int i=0;i<size_ary;i++)
          {
              *max_v = src[i] > *max_v ? src[i] : *max_v;
              *min_v = src[i] < *min_v ? src[i] : *min_v;
          }
      }
      int main()
      {
          int src[] = {1,4,5,9,3,0,-6};
          int max_v = src[0] ,min_v = src[0];
          get_min_max(src, &max_v, &min_v);
          cout << "The max of the array is : " <<max_v<<"\r\nThe min of the array is : "<<min_v <<endl;
          return 0;
      }