Android string 资源中加空格 android字符串赋值

c语法7 - 数组与字符串

概述

定义：把具有相同类型的若干变量按有序形式组织起来称为数组。

C语言数组属于构造数据类型。一个数组可以分解为多个数组元素，这些数组元素可以是基本数据类型或是构造类型。因此按数组元素的类型不同，数组又可分为数值数组、字符数组、指针数组、结构数组等各种类别。

一维数组

数组的概念和定义

我们知道，要想把数据放入内存，必须先要分配内存空间。放入4个整数，就得分配4个int类型的内存空间：

int a[4];

int a[4];

这样，就在内存中分配了4个int类型的内存空间，共 4×4=16 个字节，并为它们起了一个名字，叫a。

我们把这样的一组数据的集合称为数组(Array)，它所包含的每一个数据叫做数组元素(Element)，所包含的数据的个数称为数组长度(Length)，例如int a[4];就定义了一个长度为4的整型数组，名字是a。

数组中的每个元素都有一个序号，这个序号从0开始，而不是从我们熟悉的1开始，称为下标(Index)。使用数组元素时，指明下标即可，形式为：

arrayName[index]

arrayName[index]

arrayName 为数组名称，index 为下标。例如，a[0] 表示第0个元素，a[3] 表示第3个元素。

接下来我们就把第一行的4个整数放入数组：

a[0]=20;
a[1]=345;
a[2]=700;
a[3]=22;

a[0]=20;
a[1]=345;
a[2]=700;
a[3]=22;

这里的0、1、2、3就是数组下标，a[0]、a[1]、a[2]、a[3] 就是数组元素。

下列实现一个输入多个数字，并存入数组输出：

#include 
int main(){
    int nums[10];
    int i;
    //从控制台读取用户输入
    for(i=0; i<10; i++){
        scanf("%d", &nums[i]); 
    }
    //依次输出数组元素
    for(i=0; i<10; i++){
        printf("%d ", nums[i]);
    }
    return 0;
}
#include 
int main(){
    int nums[10];
    int i;
    //从控制台读取用户输入
    for(i=0; i<10; i++){
        scanf("%d", &nums[i]); 
    }
    //依次输出数组元素
    for(i=0; i<10; i++){
        printf("%d ", nums[i]);
    }
    return 0;
}

数组的定义方式：

dataType  arrayName[length];

dataType  arrayName[length];

dataType 为数据类型，arrayName 为数组名称，length 为数组长度。例如：

char ch[9];  //定义一个长度为 9 的字符型数组
float m[12];  //定义一个长度为 12 的浮点型数组char ch[9];  //定义一个长度为 9 的字符型数组

char ch[9];  //定义一个长度为 9 的字符型数组
float m[12];  //定义一个长度为 12 的浮点型数组char ch[9];  //定义一个长度为 9 的字符型数组

需要注意的是：

1. 数组中每个元素的数据类型必须相同，对于int a[4];，每个元素都必须为 int。
2. 数组长度 length 最好是整数或者常量表达式，例如 10、20* 4 等，这样在所有编译器下都能运行通过；如果 length 中包含了变量，例如 n、4*m 等，在某些编译器下就会报错
3. 访问数组元素时，下标的取值范围为 0 ≤ index < length，过大或过小都会越界，导致数组溢出，发生不可预测的情况

数组内存是连续的

数组是一个整体，它的内存是连续的；也就是说，数组元素之间是相互挨着的，彼此之间没有一点点缝隙。下图演示了int a[4];在内存中的存储情形：

「数组内存是连续的」这一点很重要，所以我使用了一个大标题来强调。连续的内存为指针操作(通过指针来访问数组元素)和内存处理(整块内存的复制、写入等)提供了便利，这使得数组可以作为缓存(临时存储数据的一块内存)使用。大家暂时可能不理解这句话是什么意思，等后边学了指针和内存自然就明白了。

数组的初始化

上面的代码是先定义数组再给数组赋值，我们也可以在定义数组的同时赋值，例如：

int a[4] = {20, 345, 700, 22};

int a[4] = {20, 345, 700, 22};

数组元素的值由{ }包围，各个值之间以,分隔。

对于数组的初始化需要注意以下几点：

可以只给部分元素赋值。当{ }中值的个数少于元素个数时，只给前面部分元素赋值。例如：

int a[10]={12, 19, 22 , 993, 344};

int a[10]={12, 19, 22 , 993, 344};

表示只给 a[0]~a[4] 5个元素赋值，而后面 5 个元素自动初始化为 0。

当赋值的元素少于数组总体元素的时候，剩余的元素自动初始化为 0：

• 对于short、int、long，就是整数 0；
• 对于char，就是字符 '\0'；
• 对于float、double，就是小数 0.0。

我们可以通过下面的形式将数组的所有元素初始化为 0：

int nums[10] = {0};
char str[10] = {0};
float scores[10] = {0.0};

int nums[10] = {0};
char str[10] = {0};
float scores[10] = {0.0};

由于剩余的元素会自动初始化为 0，所以只需要给第 0 个元素赋值为 0 即可。

只能给元素逐个赋值，不能给数组整体赋值。例如给 10 个元素全部赋值为 1，只能写作：

int a[10] = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1};

int a[10] = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1};

而不能写作：

int a[10] = 1;

int a[10] = 1;

如给全部元素赋值，那么在定义数组时可以不给出数组长度。例如：

int a[] = {1, 2, 3, 4, 5};

int a[] = {1, 2, 3, 4, 5};

等价于

int a[5] = {1, 2, 3, 4, 5};

int a[5] = {1, 2, 3, 4, 5};

可以使用数组输出一个4x4的矩阵

#include 
int main(){
    int a[4] = {1, 2, 3, 4};
    int b[4] = {5, 6, 7, 8};
    int c[4] = {9, 10 ,11, 12};
    int d[4] = {13, 14, 15, 16161616};
    printf("%-9d %-9d %-9d %-9d\n", a[0], a[1], a[2], a[3]);
    printf("%-9d %-9d %-9d %-9d\n", b[0], b[1], b[2], b[3]);
    printf("%-9d %-9d %-9d %-9d\n", c[0], c[1], c[2], c[3]);
    printf("%-9d %-9d %-9d %-9d\n", d[0], d[1], d[2], d[3]);
    return 0;
}

#include 
int main(){
    int a[4] = {1, 2, 3, 4};
    int b[4] = {5, 6, 7, 8};
    int c[4] = {9, 10 ,11, 12};
    int d[4] = {13, 14, 15, 16161616};
    printf("%-9d %-9d %-9d %-9d\n", a[0], a[1], a[2], a[3]);
    printf("%-9d %-9d %-9d %-9d\n", b[0], b[1], b[2], b[3]);
    printf("%-9d %-9d %-9d %-9d\n", c[0], c[1], c[2], c[3]);
    printf("%-9d %-9d %-9d %-9d\n", d[0], d[1], d[2], d[3]);
    return 0;
}

数组元素逆序

#include

int main(void){
 int arr[] = {1, 6, 7, 5, 9, 4, 3};
 int i = 0; // 数组首元素下标
 int j = sizeof(arr)/sizeof(arr[0]) - 1; //数组最后一个元素下标
 int temp = 0;
 //打印原始数组
 for (size_t m = 0; m sizeof(arr) / sizeof(arr[0]); m++){
  printf("%d ", arr[m]);
 }
 printf("\n");
 
 while(i   temp = arr[i];
  arr[i] = arr[j];
  arr[j] = temp;
  i++;  j--;
 }
 for (size_t n = 0; n sizeof(arr) / sizeof(arr[0]); n++){
  printf("%d ", arr[n]);
 }
 printf("\n");
 return 0;
}

#include

int main(void){
 int arr[] = {1, 6, 7, 5, 9, 4, 3};
 int i = 0; // 数组首元素下标
 int j = sizeof(arr)/sizeof(arr[0]) - 1; //数组最后一个元素下标
 int temp = 0;
 //打印原始数组
 for (size_t m = 0; m sizeof(arr) / sizeof(arr[0]); m++){
  printf("%d ", arr[m]);
 }
 printf("\n");
 
 while(i   temp = arr[i];
  arr[i] = arr[j];
  arr[j] = temp;
  i++;  j--;
 }
 for (size_t n = 0; n sizeof(arr) / sizeof(arr[0]); n++){
  printf("%d ", arr[n]);
 }
 printf("\n");
 return 0;
}

sizeof(arr)获取到所有的数组元素的下标，而sizeof(arr)/sizeof(arr[0]) - 1获取到最后一位的元素下标

通过for循环打印数组

while进行数组前后元素的交换，并向中间递进。

冒泡排序

1、比较相邻的元素。如果第一个比第二个大(小)，就交换他们两个。

2、对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大(小)的数。

3、针对所有的元素重复以上的步骤，除了最后已经选出的元素(有序)。

4、持续每次对越来越少的元素(无序元素)重复上面的步骤，直到没有任何一对数字需要比较，则序列最终有序。

#include 

int main(void){
 
 int guo[] = { 4,554,48,49,487,56,12};
 int n = sizeof(guo) / sizeof(guo[0]); //数组元素个数
 int temp = 0; //临时变量
 
 for (size_t i = 0; i -1; i++){  // 控制行
  for (size_t j = 0; j -1-i; j++ ){ // 控制内层列
   if(guo[j] > guo[j+1]){
    temp = guo[j];
    guo[j] = guo[j+1];
    guo[j+1] = temp;
   }
  }
 }
    for (size_t i = 0; i      printf("%d ", guo[i]);
 }
 printf("\n");
 return 0;
}

#include 

int main(void){
 
 int guo[] = { 4,554,48,49,487,56,12};
 int n = sizeof(guo) / sizeof(guo[0]); //数组元素个数
 int temp = 0; //临时变量
 
 for (size_t i = 0; i -1; i++){  // 控制行
  for (size_t j = 0; j -1-i; j++ ){ // 控制内层列
   if(guo[j] > guo[j+1]){
    temp = guo[j];
    guo[j] = guo[j+1];
    guo[j+1] = temp;
   }
  }
 }
    for (size_t i = 0; i      printf("%d ", guo[i]);
 }
 printf("\n");
 return 0;
}

二维数组

二维数组概念与形式

二维数组定义的一般形式是：

dataType arrayName[length1][length2];

dataType arrayName[length1][length2];

其中，dataType 为数据类型，arrayName 为数组名，length1 为第一维下标的长度，length2 为第二维下标的长度。

我们可以将二维数组看做一个 Excel 表格，有行有列，length1 表示行数，length2 表示列数，要在二维数组中定位某个元素，必须同时指明行和列。例如：

int a[3][4];

int a[3][4];

定义了一个 3 行 4 列的二维数组，共有 3×4=12 个元素，数组名为 a，即：

a[0][0], a[0][1], a[0][2], a[0][3]
a[1][0], a[1][1], a[1][2], a[1][3]
a[2][0], a[2][1], a[2][2], a[2][3]

a[0][0], a[0][1], a[0][2], a[0][3]
a[1][0], a[1][1], a[1][2], a[1][3]
a[2][0], a[2][1], a[2][2], a[2][3]

如果想表示第 2 行第 1 列的元素，应该写作 a[2][1]。

也可以将二维数组看成一个坐标系，有 x 轴和 y 轴，要想在一个平面中确定一个点，必须同时知道 x 轴和 y 轴。

二维数组在概念上是二维的，但在内存中是连续存放的；换句话说，二维数组的各个元素是相互挨着的，彼此之间没有缝隙。那么，如何在线性内存中存放二维数组呢？有两种方式：

• 一种是按行排列， 即放完一行之后再放入第二行；
• 另一种是按列排列， 即放完一列之后再放入第二列。

在C语言中，二维数组是按行排列的。也就是先存放 a[0] 行，再存放 a[1] 行，最后存放 a[2] 行；每行中的 4 个元素也是依次存放。数组 a 为 int 类型，每个元素占用 4 个字节，整个数组共占用 4×(3×4)=48 个字节。

你可以这样认为，二维数组是由多个长度相同的一维数组构成的。

二维数组初始化

常规初始化

int arr [3][5] = {{ 2, 3, 54, 56, 7 },{2, 67, 4, 35, 9}, {1, 2, 3, 4, 5}}
int arr [3][5] = {{ 2, 3, 54, 56, 7 },{2, 67, 4, 35, 9}, {1, 2, 3, 4, 5}}

不完全初始化

int arr[3][5] = {{2, 3},{2, 3, 4},{1, 2, 3, 4}}
int arr[3][5] = {{2, 3},{2, 3, 4},{1, 2, 3, 4}}

未被初始化的赋值为0

int arr[10] = 0;
则该10个元素均被赋值为0
int arr[10] = 0;
则该10个元素均被赋值为0

同理

二维数组也可赋值为0

int arr[10][5] = {0}
int arr[10][5] = {0}

此时获取到50个0组成的二维数组

系统自动分配行列

int arr[3][5] = {1,2,3,4,5,6,7}
int arr[3][5] = {1,2,3,4,5,6,7}

无法使用下列形式的定义**

int arr[][] = {{1,2,3},{4,5,6}}
int arr[][] = {{1,2,3},{4,5,6}}

二维数组必须指定列值，可以不使用行值

int arr[][4] = {1, 3, 4, 6, 7};
int arr[][4] = {1, 3, 4, 6, 7};

输出

1   3

4   6

7   0

打印二维数组

#include

int main(void){
    int arr[5][3] = { {1,2,3},
         {4,5,6},
         {7,8,9},
       {10,11,12},
       {13,14,15} };
    int arr2[3][5] = {
         {1,2,3,4,5},
      {6,7,8,9,10},
      {11,12,13,14,15}};
    printf("第一个数组打印\n");
    for(size_t i = 0;i sizeof(arr)/sizeof(arr[0]); i++){
     for (size_t j = 0; j sizeof(arr[i])/sizeof(arr[i][0]);j++){
      printf("%d ",arr[i][j]);
  }
  printf("\n");
 }
 printf("第二个数组打印\n");
  for(size_t i = 0;i sizeof(arr2)/sizeof(arr2[0]); i++){
     for (size_t j = 0; j sizeof(arr2[i])/sizeof(arr2[i][0]);j++){
      printf("%d ",arr2[i][j]);
  }
  printf("\n");
 }
 return 0;
}

#include

int main(void){
    int arr[5][3] = { {1,2,3},
         {4,5,6},
         {7,8,9},
       {10,11,12},
       {13,14,15} };
    int arr2[3][5] = {
         {1,2,3,4,5},
      {6,7,8,9,10},
      {11,12,13,14,15}};
    printf("第一个数组打印\n");
    for(size_t i = 0;i sizeof(arr)/sizeof(arr[0]); i++){
     for (size_t j = 0; j sizeof(arr[i])/sizeof(arr[i][0]);j++){
      printf("%d ",arr[i][j]);
  }
  printf("\n");
 }
 printf("第二个数组打印\n");
  for(size_t i = 0;i sizeof(arr2)/sizeof(arr2[0]); i++){
     for (size_t j = 0; j sizeof(arr2[i])/sizeof(arr2[i][0]);j++){
      printf("%d ",arr2[i][j]);
  }
  printf("\n");
 }
 return 0;
}

二维数组输入输出

#include

int main(void){
 int scores[5][3];
 
 int row = sizeof(scores) / sizeof(scores[0]);
 int col = sizeof(scores[0]) / sizeof(scores[0][0]);
 
 for (size_t i = 0; i       for (size_t j = 0; j //            取地址输入
       scanf("%d", &scores[i][j]);
   }
 }
 for (size_t i = 0; i       for (size_t j = 0; j //            取地址输入
       printf("%d ", scores[i][j]);
   }
   printf("\n");
 }
 return 0;
}

#include

int main(void){
 int scores[5][3];
 
 int row = sizeof(scores) / sizeof(scores[0]);
 int col = sizeof(scores[0]) / sizeof(scores[0][0]);
 
 for (size_t i = 0; i       for (size_t j = 0; j //            取地址输入
       scanf("%d", &scores[i][j]);
   }
 }
 for (size_t i = 0; i       for (size_t j = 0; j //            取地址输入
       printf("%d ", scores[i][j]);
   }
   printf("\n");
 }
 return 0;
}

修改为输出按二维数组行成绩求和

#include
int main(void){
 int scores[5][3];
 int row = sizeof(scores) / sizeof(scores[0]);
 int col = sizeof(scores[0]) / sizeof(scores[0][0]);
 for (size_t i = 0; i       for (size_t j = 0; j        scanf("%d", &scores[i][j]);
   }
 }
 for (size_t i = 0; i   int sum = 0;
  for (size_t j = 0; j    sum += scores[i][j];
  }
  printf("第%d行求和为：%d\n", i+1, sum);
 }
 
 return 0;
}

#include
int main(void){
 int scores[5][3];
 int row = sizeof(scores) / sizeof(scores[0]);
 int col = sizeof(scores[0]) / sizeof(scores[0][0]);
 for (size_t i = 0; i       for (size_t j = 0; j        scanf("%d", &scores[i][j]);
   }
 }
 for (size_t i = 0; i   int sum = 0;
  for (size_t j = 0; j    sum += scores[i][j];
  }
  printf("第%d行求和为：%d\n", i+1, sum);
 }
 
 return 0;
}

修改为按列求和

#include

int main(void){
 int scores[5][3];

 int row = sizeof(scores) / sizeof(scores[0]);
 int col = sizeof(scores[0]) / sizeof(scores[0][0]);

 for (size_t i = 0; i       for (size_t j = 0; j //            取地址输入
       scanf("%d", &scores[i][j]);
   }
 }
 for (size_t i = 0; i   int sum = 0;
  for (size_t j = 0; j    sum += scores[j][i];
  }
  printf("第%d列总和：%d\n", i+1, sum);
 }
 return 0;
}

#include

int main(void){
 int scores[5][3];

 int row = sizeof(scores) / sizeof(scores[0]);
 int col = sizeof(scores[0]) / sizeof(scores[0][0]);

 for (size_t i = 0; i       for (size_t j = 0; j //            取地址输入
       scanf("%d", &scores[i][j]);
   }
 }
 for (size_t i = 0; i   int sum = 0;
  for (size_t j = 0; j    sum += scores[j][i];
  }
  printf("第%d列总和：%d\n", i+1, sum);
 }
 return 0;
}

多维数组

三维数组

行列层

【层】【行】【列】
【层】【行】【列】int arr[2][3][4]; // 两层三行四列
int arr[2][3][4]; // 两层三行四列

三维数组大小为  ：

层*行*列*类型大小

层*行*列*类型大小

三位数组打印与定义

#include

int main(void){
//  定义一个两层三行四列的三维数组
// int arr[2][3][4];
// {
//     { {11, 2, 3, 4}, {1, 2, 3, 4}, {1, 2, 3, 4} },
//     { {21, 2, 3, 4}, {1, 2, 3, 4}, {1, 2, 3, 4} },
//    { {31, 2, 3, 4}, {1, 2, 3, 4}, {1, 2, 3, 4} },
// }

    int arr[2][3][4] =
 {
     { {11, 2, 3, 4}, {1, 2, 3, 4}, {1, 2, 3, 4} },
     { {21, 2, 3, 4}, {1, 2, 3, 4}, {1, 2, 3, 4} }
 };
 // 打印维数组
 for (size_t i = 0; i 2; i++){
  for (size_t j = 0; j 3; j++){
   for(size_t k = 0;k 4; k++){
    printf("%d ",arr[i][j][k]);
   }
   printf("\n");
  }
  printf("换层\n\n");
 }
 return 0;
}

#include

int main(void){
//  定义一个两层三行四列的三维数组
// int arr[2][3][4];
// {
//     { {11, 2, 3, 4}, {1, 2, 3, 4}, {1, 2, 3, 4} },
//     { {21, 2, 3, 4}, {1, 2, 3, 4}, {1, 2, 3, 4} },
//    { {31, 2, 3, 4}, {1, 2, 3, 4}, {1, 2, 3, 4} },
// }

    int arr[2][3][4] =
 {
     { {11, 2, 3, 4}, {1, 2, 3, 4}, {1, 2, 3, 4} },
     { {21, 2, 3, 4}, {1, 2, 3, 4}, {1, 2, 3, 4} }
 };
 // 打印维数组
 for (size_t i = 0; i 2; i++){
  for (size_t j = 0; j 3; j++){
   for(size_t k = 0;k 4; k++){
    printf("%d ",arr[i][j][k]);
   }
   printf("\n");
  }
  printf("换层\n\n");
 }
 return 0;
}

特殊初始化

int arr[2][3][5] = {1,2,3,4,5,6,7,8,9,10,11};  //可自动化定义
int arr[][3][5];  //可省略层数

int arr[2][3][5] = {1,2,3,4,5,6,7,8,9,10,11};  //可自动化定义
int arr[][3][5];  //可省略层数

字符数组和字符串

字符数组

#include

int main(void){
 char str[5] = {'h', 'e', 'l', 'l', 'o'};
 
 printf("%s\n", str);
 
 return 0;
}

#include

int main(void){
 char str[5] = {'h', 'e', 'l', 'l', 'o'};
 
 printf("%s\n", str);
 
 return 0;
}

字符串

char str[5] = {'h', 'e', 'l', 'l', 'o', '\0'}; //最后一位可以自动补0
char str[] = "hello";

char str[5] = {'h', 'e', 'l', 'l', 'o', '\0'}; //最后一位可以自动补0
char str[] = "hello";

printf(“%s”) ==> 使用printf 打印字符串的时候必须碰到  **\0 **才结束,字符串和字符串数组自动补 \0

字符串数组输入

#include
int main(void){
 char str[100] = {0};
 
 for (size_t i = 0; i 10; i++){
  scanf("%c", &str[i]);
 }
 printf("str = %s\n",str);
 return 0;
}

#include
int main(void){
 char str[100] = {0};
 
 for (size_t i = 0; i 10; i++){
  scanf("%c", &str[i]);
 }
 printf("str = %s\n",str);
 return 0;
}

统计字符串中字符出现次数

#include

int main(void){
    int count[26] = {0};
 // 判断字符串中的每个次数
//     a：97
//     z: 123
// 通过给一个数组下标添加累计数量的方式，记录字符串的出现次数，通过asic码
   char str[11] = {0};
   for (size_t i = 0; i 10; i++){
    scanf("%c", &str[i]);
   }
   
   for (size_t i = 0; i 11; i++){
    int index = str[i] - 'a'; // 用户输入字符下标在count数组中的下标值
    count[index]++;
   }
   
   for (size_t i = 0; i 26; i++){
    if(count[i] != 0){
     printf("%c 字符在字符串中出现的次数%d\n", i+'a', count[i]);
    }
   }


 return 0;
}

#include

int main(void){
    int count[26] = {0};
 // 判断字符串中的每个次数
//     a：97
//     z: 123
// 通过给一个数组下标添加累计数量的方式，记录字符串的出现次数，通过asic码
   char str[11] = {0};
   for (size_t i = 0; i 10; i++){
    scanf("%c", &str[i]);
   }
   
   for (size_t i = 0; i 11; i++){
    int index = str[i] - 'a'; // 用户输入字符下标在count数组中的下标值
    count[index]++;
   }
   
   for (size_t i = 0; i 26; i++){
    if(count[i] != 0){
     printf("%c 字符在字符串中出现的次数%d\n", i+'a', count[i]);
    }
   }


 return 0;
}

字符串操作

字符串获取带空格的字符串

一般情况下：

• 获取字符串%s， 遇到空格和\n终止
• 用于存储字符串的空间必须足够大，防止溢出

若需要获取空格，需借助正则表达式

scanf("%[^\n]", str);
// 除换行之外的字符

scanf("%[^\n]", str);
// 除换行之外的字符

如下代码接收空格示例：

#include

int main(void){
 char str[100];
 scanf("%[^\n]s", str);
 printf("%s\n", str);
 return 0;
}

#include

int main(void){
 char str[100];
 scanf("%[^\n]s", str);
 printf("%s\n", str);
 return 0;
}

gets()函数

获取一个字符串，返回字符串的首地址

原型

char *gets(char *s);
char *gets(char *s);

输入参数，用来存储字符串的空间

返回一个字符串的首地址

#include
#include
#include


int main(void){
 char str[100];
 printf("获取字符串为：%s\n", gets(str));
 return 0;
}

#include
#include
#include


int main(void){
 char str[100];
 printf("获取字符串为：%s\n", gets(str));
 return 0;
}

注意:由于scanf()和gets()无法知道字符串s大小，必须遇到换行符或读到文件结尾为止才接收输入，因此容易导致字符数组越界(缓冲区溢出)的情况。不安全的。

fgets()

char *fgets(char *s, int size, FILE *stream);

char *fgets(char *s, int size, FILE *stream);

参数:获取一个字符串。

s ：存储字符串的空间地址

size ：描述空间大小，会预留**/0**的存储空间，使得输入不会越界

stream：读取字符串的位置，标准输入：stdin，表示键盘

返回值：返回实际获取到的字符串首地址。

使用方法：

#include
#include
#include


int main(void){
 char str[10];
 printf("获取字符串为：%s\n", fgets(str, sizeof(str), stdin));
 return 0;
}

#include
#include
#include


int main(void){
 char str[10];
 printf("获取字符串为：%s\n", fgets(str, sizeof(str), stdin));
 return 0;
}

puts()

将字符串写出屏幕

int puts(coust char *s);

int puts(coust char *s);

• 参数：待写出到屏幕的字符串
• 返回值：**成功：**非负数， 失败： -1
• puts函数会默认换行

#include
#include
#include


int main(void){
 char str[] = "hello plotycodon\n";
 int code = puts(str);
 printf("code = %d\n", code);
 return 0;
}

#include
#include
#include


int main(void){
 char str[] = "hello plotycodon\n";
 int code = puts(str);
 printf("code = %d\n", code);
 return 0;
}

fputs()

int fputs(const char *str, FILE *stream);

 int fputs(const char *str, FILE *stream);

参数：输出后不默认添加\n换行

str ：待输出的字符串

stream：输出位置(屏幕标准输出 ==> stdout)

返回：成功0， 失败-1

#include
#include
#include


int main(void){
 char str[] = "hello plotycodon";
 int code = fputs(str, stdout);
 printf("code = %d\n", code);
 return 0;
}

#include
#include
#include


int main(void){
 char str[] = "hello plotycodon";
 int code = fputs(str, stdout);
 printf("code = %d\n", code);
 return 0;
}

strlen()

求字符串的长度

size_t strlen(const char *s);

size_t strlen(const char *s);

参数

代求长度的字符串

返回一个有效的字符个数

碰到\0结束

#include
#include
#include


int main(void){
 char str[] = "hello \n plotycodon\n";
 printf("str = %s", str);
 printf("sizeof(str) = %u \n", sizeof(str));
 printf("strlen(str) = %u", strlen(str));
 return 0;
}

#include
#include
#include


int main(void){
 char str[] = "hello \n plotycodon\n";
 printf("str = %s", str);
 printf("sizeof(str) = %u \n", sizeof(str));
 printf("strlen(str) = %u", strlen(str));
 return 0;
}

实现strlen()函数

#include
#include
#include

//实现strlen()

int main(void){
 char str[] = "hello \n plotycodon\n";
 int i = 0;
 
 while(str[i] != '\0'){
  i++;
 }
 printf("strlen(str) == %d", i);
}

#include
#include
#include

//实现strlen()

int main(void){
 char str[] = "hello \n plotycodon\n";
 int i = 0;
 
 while(str[i] != '\0'){
  i++;
 }
 printf("strlen(str) == %d", i);
}

strcat()

拼接两个字符串

char*strcat(char* strDestination, const char* strSource);
char*strcat(char* strDestination, const char* strSource);

参数为两个需要拼接的字符串，其中第一个字符串将被覆盖成新的字符串

#include 
#include 
int main(){
    char str1[101] = { 0 };
    char str2[50] = { 0 };
    gets(str1);
    gets(str2);
    strcat(str1, str2);
    puts(str1);
    return 0;
}

#include 
#include 
int main(){
    char str1[101] = { 0 };
    char str2[50] = { 0 };
    gets(str1);
    gets(str2);
    strcat(str1, str2);
    puts(str1);
    return 0;
}

实现strcat

#include
#include
#include


int main(void){
 char str1[] = "guo";
 char str2[] = "jia";
 char str3[100] = {0};
 
 int i = 0;
 while (str1[i] != '\0'){
  str3[i] = str1[i];
  i++;
 }
 // 将str1 给str3
 printf("第一次循环结束的时候, i = %d, str3 == %s\n", i, str3);
 
 int j = 0;
 while(str2[j]){
  str3[i+j] = str2[j];
  j++;
 }
 printf("第二次循环结束的时候, i = %d, str3 == %s\n", i+j, str3);
 
 return 0;
}

#include
#include
#include


int main(void){
 char str1[] = "guo";
 char str2[] = "jia";
 char str3[100] = {0};
 
 int i = 0;
 while (str1[i] != '\0'){
  str3[i] = str1[i];
  i++;
 }
 // 将str1 给str3
 printf("第一次循环结束的时候, i = %d, str3 == %s\n", i, str3);
 
 int j = 0;
 while(str2[j]){
  str3[i+j] = str2[j];
  j++;
 }
 printf("第二次循环结束的时候, i = %d, str3 == %s\n", i+j, str3);
 
 return 0;
}

图 | 郭嘉

文 | 郭嘉