04.C(数组字符串和函数)

1.水仙花数

#include<stdio.h>
int main() {
    int i;
    for ( i = 100; i < 1000; i++)
    {
        int i1 = i % 10;
        int i2 = i / 10 % 10;
        int i3 = i / 100;
        if ((i1*i1*i1 + i2*i2*i2 + i3*i3*i3) == i)
            printf("%d\n",i);
    
    }
    return 0;
}

2.二维数组

#include<stdio.h>

int main()  
    int arrary[2][3];
    printf("%d\n", sizeof(arrary));  //6个元素，6个int元素，每个int 4个字节，所以答案是24
    return 0;
}

3.二维数组赋值

#include<stdio.h>

int main() {
    int arrary[2][3];
    printf("%d\n", sizeof(arrary));
    arrary[0][0] = 0;//给第0行第0列的元素赋值
    arrary[0][1] = 0;//给第0行第1列的元素赋值
    return 0;
}

#include<stdio.h>

int main() {
    int arrary[2][3] = { {1,2,3},{2,3,4} };//创建的同时赋值
    return 0;
}

#include<stdio.h>

int main() {
    int arrary[2][3]=0;//将数组中每一个元素都赋值为0
    return 0;
}

4.输出二维数组的值

#include<stdio.h>

int main() {
    int arrary[2][3] = { {1,2,3},{4,5,6} };
    int i;
    int j;
    for ( i = 0; i < 3; i++)
    {
        for ( j = 0; j < 4; j++)
        {
            printf("array[%d][%d] = %d\n",i,j,arrary[i][j]);
        }
    }
    return 0;
}

这里存在数组越界的情况，但是c 与 Java不同，不会崩溃，只是越界位置输出的值毫无章法可言

输出结果

array[0][0] = 1
array[0][1] = 2
array[0][2] = 3
array[0][3] = 4
array[1][0] = 4
array[1][1] = 5
array[1][2] = 6
array[1][3] = -858993460
array[2][0] = -858993460
array[2][1] = 4193644
array[2][2] = 15343566
array[2][3] = 1

5.冒泡排序

#include<stdio.h>

int main() {
    int array[10]{34,32,67,18,23,90,56,82,39};
    int i;
    int j;

    for ( i = 0; i < 9; i++)                  //控制数据个数
    {
        for ( j = 0; j < 9 - i-1; j++)        //控制每次比较的次数，-1是为了防止最后一个数组越界
        {
            if (array[j] > array[j+1])        //前一个数字和后一个数字比较大小
            {
                int temp = array[j];
                array[j] = array[j + 1];
                array[j+1] = temp;
            }
        }

    }

    for ( i = 0; i < 9; i++)
    {
        printf("%d\n", array[i]);
    }
    return 0;
}

简单解释冒泡排序的含义：一组数字，从第一个开始一次跟后便的数字比较大小，大的放后边，小的放前边，
第一次比较第一个和第二个比较，如果第一个大于第二个，交换两者位置，否则不变，直到比较到最后一个数字，此时，最大的值已经排在了最后边
第二次比较，第一个和第二个比较，重复第一步的操作，此时结果第二大的数字排在了右数第二个位置
。。。
直到最后一次比较

6.int arr [2][3][4][5]..支持多维数组，但是不建议使用，理解难度大。

7.字符数组和字符串

#include<stdio.h>

int main() {
    char array[1000] = {'a','b','c','d'};
    printf("%s\n",array);
    return 0;
}

结果：abcd

#include<stdio.h>

int main() {
    char array[] = "abcd";
    printf("%s\n",array);
    printf("%d\n",sizeof(array));
    return 0;
}

结果：
abcd
5 //字符串默认以0结尾，所以末尾还有个零，sizeof 为5
请按任意键继续. . .

#include<stdio.h>

int main() {
    char array[100] = "abcd";
    printf("%s\n",array);
    printf("%d\n",sizeof(array));
    return 0;
}

结果：
abcd
100 //字符数组为abcd 大小为100
请按任意键继续. . .

C语言中数组长度这样表示sizeof(arrary)

8.c语言编译器不会检查数组脚标是否越界

9.c语言中字符串是一个在内存中以0结尾的字符数组，必须以0结尾，否则不是字符串

比如下边这个不是字符串

#include<stdio.h>
int main() {
    char s[5] = { 0 };
    s[0] = 'a';
    s[1] = 'b';
    s[2] = 'c';
    s[3] = 'd';
    s[4] = 'e';
    return 0;
}

下边这个是字符串，因为char数组最后一个值默认为0

#include<stdio.h>
int main() {
    char s[5] = { 0 };
    s[0] = 'a';
    s[1] = 'b';
    s[2] = 'c';
    s[3] = 'd';
    printf("%s\n",s);
    return 0;
}

打印结果为abcd ，注意后边是有0的，c语言不同于Java的一个地方，如果打印Java中一个数组的话，得到的是地址值，而C语言直接就把字符串打印出来了

10.英文倒叙打印

#include<stdio.h>
int main() 
{
    char buf[100] = "hello world";
    int len = 0;
    while (buf[len++]) {};
    len--;
    int min = 0;
    int max = len - 1;
    while (min < max)
    {
        int temp = buf[min];
        buf[min] = buf[max];
        buf[max] = temp;
        min++;
        max--;
    }
    printf("%s\n",buf);
    return 0;
}

11.中文倒叙打印
汉字倒叙打印不同于英文，跟存储方式有关，直接使用以上方式会出现乱码现象
一个汉子为两个字节，一个英文字母为一个字节，正确交换的方式是第一个字节和倒数第二个字节交换
第二个字节和最后一个字节交换，这样就达到了将第一个汉字和最后一个汉字交换，以此类推。
这是windows系统下，如果是linux系统下汉字使用的是utf8的编码，每个汉字占三个字节

#include<stdio.h>
int main() 
{
    char buf[100] = "你好世界";
    int len = 0;
    while (buf[len++]) {};
    len--;    //char默认以0字符结尾，这样做是去掉了0的长度
    int min = 0;
    int max = len - 1;
    while (min < max)
    {
        char temp = buf[min];
        buf[min] = buf[max-1];
        buf[max-1] = temp;

        temp = buf[min + 1];
        buf[min + 1] = buf[max];
        buf[max] = temp;

        min += 2;
        max -= 2;
    }
    printf("%s\n",buf);
    return 0;
}

12.中英混合打印
a.求中英混合长度（一个汉字占一个）

#include<stdio.h>
    int main()
    {
        char buf[100] = "你好世界abc";
        int len = 0;
        int i = 0;
        while (buf[i]) 
        {
            if (buf[i] < 0)  //如果是汉字的话，满足小于0的条件，英文大于0，如果0表示是汉字，所以向前跳一个位置
                i++;        
            i++;
            len++;
        }
        printf("%d\n",len);
        return 0;
    }

#include<stdio.h>
int main() 
{
    char s[100] = "hello world";
    s[4] = 0;
    printf("%s\n",s);
    return 0;
}

输出结果hell char默认以0结尾，将数组中的第四个设置为0相当于在那个位置结尾了，后边就没了

14.去除字符串尾部的空格

#include<stdio.h>
int main() 
{
    char s[100] = "hello world  ";
    int len = 0;
    while (s[len++]);                  //这里的分号必不可少，不然有问题，可以运行试试
        len--;
    for (int i = len - 1; i >= 0; i--) //从后往前找，当找到一个不是空格的字符时，将其后的一个位置设置为0，就相当于在此作为尾部
    {
        if (s[i] != ' ')
        {
            s[i + 1] = 0;
            break;
        }
    }
    printf("(%s)\n",s);            //（%ｓ）表示将打印的用括号括起来
    return 0;
}

１５.去除字符串头部的空格
ａ．

#include<stdio.h>
int main() 
{
    char s[100] = "    hello";
    int len = 0;
    while (s[len++] == ' ');
        len--;            ／／得到空格的数量
    printf("%d\n", len);
    int i = len;            ／／从第一个不是空格的位置开始，将这个位置的字符移动到第一个位置
    while (s[i])
    {
        s[i-len]=s[i];
        i++;
    }
    printf("(%s)\n",s);
    return 0;
}

结果为(helloello)　 ／／由于将字符串整体前移后，还需要将后边遗留的字符去掉，所以如下程序
ｂ．

#include<stdio.h>
int main() 
{
    char s[100] = "    hello";
    int len = 0;
    while (s[len++] == ' ');
        len--;
    printf("%d\n", len);
    int i = len;
    while (s[i])
    {
        s[i-len]=s[i];
        i++;
    }
    s[i - len] = 0;　　　　　　　　　／／将最后一位设置为尾部，置０去除多余字符
    printf("(%s)\n",s);
    return 0;
}

16.随机数产生函数 rand 和 srand，可以对比java中的random函数学习 需要引入stdlib.h

#include<stdio.h>    //没有引用stdlib.h但是也没有出错，？
int main() 
{
    int i = 0;
    for ( i = 0; i < 10; i++)
    {
        int value = rand();
        printf("%d\n",value);
    }
    return 0;
}

产生了随机数，但是每次得到的随机数都是相同的，所以rand称为伪随机数生成器，要生成每次不同的怎么做呢？

使用srand函数，设置种子值

#include<stdio.h>
#include<stdlib.h>    //经测试在vs中即使不引用这两个头文件，同样可以运行
#include<time.h>
int main() 
{
    time_t tm = time(NULL);  //得到系统时间
    srand(tm);          //种子发生器，只要每次修改srand函数的参数，就可一达到每次产生不同随机数的效果
    int i = 0;
    for ( i = 0; i < 10; i++)
    {
        int value = rand();
        printf("%d\n",value);
    }
    return 0;
}

17。字符串的输入操作

#define  _CRT_SECURE_NO_WARNINGS

#include<stdio.h>
int main() 
{
    char s[100] = {0};  //将数组大小设置为2048，就可以防止键盘输入溢出了
    scanf("%s",s);      //输入一个字符串，以回车键作为输入完成的标识，但是回车键本身不会作为字符串的一部分
    printf("%s\n",s);    //scanf存在安全问题，加入用户在键盘输入的内
                        //容超过scanf参数中的数组长度，就会内存溢出，发生奔溃
                        //这也就是微软在使用scanf函数时需要加上顶部#define  _CRT_SECURE_NO_WARNINGS的原因
    return 0;
}

18.字符串的结束标识
scanf将回车空格都当作字符串结束的标志
继续使用以上的程序，运行输入
abc ddd
输出结果是：abc
请按任意键继续. . .
可见空格后的ddd没有了

19.gets函数（用这个可以实现输出带空格的字符串，但是gets也存在缓冲区溢出的问题）gets参数只能接受一个数组

#include<stdio.h>
int main() 
{
    char s[100] = {0};
    //scanf("%s",s);    
    gets(s);
    int i = 0;
    for ( i = 0; i < 10; i++)
    {
        printf("%d\n",s[i]);
    }
                    
    return 0;
}

运行输入hello world
输出
hello world
104
101
108
108
111
32
119
111
114
108
请按任意键继续. . .
可见，gets函数解决了scanf的问题，gets函数是以回车为尾部标识的

20.gets实现整数加法

#include<stdio.h>
#include<stdlib.h>
int main() 
{
    char a[100] = { 0 };
    char b[100] = {0};
    gets(a);
    gets(b);
    int i1 = atoi(a);
    int i2 = atoi(b);
    printf("%d\n",i1+i2);
    return 0;
}

由于gets无法接收整数作为参数，只能接收数组，所以使用atoi函数将字符串转化为一个整数 后实现加法
gets不能用类似“%d”或者“%s”之类的字符串转义

21.fgets函数

#include<stdio.h>
int main() 
{
    char a[10] = { 0 };
    fgets(a,10,stdin); 
    //fgets(a, sizeof(a), stdin);        //第一个参数是char的数组，第二个参数是数组的大小，单位：字节，第三个参数stdin
    printf("%s\n",a);                    //代表标准输入，fget是安全的，不存在缓冲区溢出的问题，只要能保证第二个参数小                                    //于（不能等于（也不是绝对的，最好小于），char以0结尾）数组实际的大小
    return 0;
}

22.puts函数

#include<stdio.h>
int main() 
{
    char a[10] = { 0 };
    fgets(a,10,stdin); 
    puts(a);                              //只能打印字符串，并且会在输出完成后再后边打印一个'\n'(换行)
    return 0;
}

输出结果

hello //输入后回车，可以看到换了两行
hello

请按任意键继续. . .

23.字符串操作函数（需要包含头文件 #include<string.h>）

a.获取有效长度

#include<stdio.h>
#include<string.h>
int main() 
{
    char a[100] = "hello world";
    int len = strlen(a);    //得到字符串长度，返回一个字符串中有效字符的数量(不包含字符串结尾的0)，sizeof是获取到数组的大小，概念是不同的
    printf("%d\n", len);
    return 0;
}

b.字符串的追加

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>
int main() 
{
    char a[100] = "hello world";
    char a2[100] = "abcd";
    strcat(a, a2);                //将两个字符串合并，结果放在第一个参数里边，存在缓冲区溢出的问题（当第一个数组不够大                            //到足以装的下两个数组中的东西的时候，所以需要第一个数组容量足够大）
    printf("%s\n", a);
    return 0;
}

安全追加

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>
int main() 
{
    char a[100] = "hello world";
    char a2[100] = "abcd";
    strncat(a, a2,3);                //合并的时候可以限制追加多少个字符，可以防止溢出
    printf("%s\n", a);
    return 0;
}

c.字符串的比较

#include<stdio.h>
#include<string.h>
int main() 
{
    char a[100] = "abcd";
    char a2[100] = "abcd";
    //if (a == a2);                错误的模型，字符串不能通过==比较
    if (strcmp(a, a2) == 0)    //这个函数比较的是ASCII码，如果第一个参数的码值小于第二个
                                //返回值为-1，反之则返回值为1
    {
        printf("相同\n");
    }
    else
    {
        printf("不相同\n");
    }
    return 0;
}

只比较指定数量的字符

#include<stdio.h>
#include<string.h>
int main() 
{
    char a[100] = "abcd";
    char a2[100] = "abcdef";
    //if (a == a2);                错误的模型，字符串不能通过==比较
    if (strncmp(a, a2,5) == 0)  //只比较前5个字符
    {
        printf("相同\n");
    }
    else
    {
        printf("不相同\n");
    }
    return 0;
}

d.字符串的拷贝

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>
int main() 
{
    char a[100] = "abcd";
    char a2[100] = "abcdef";
    strcpy(a, a2);                //将a2的内容拷贝到a中，注意缓冲区溢出的问题
    printf("%s\n", a);
    return 0;
}

拷贝指定数量的字符

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>
int main() 
{
    char a[100] = "kkjedftk";
    char a2[100] = "abcdef";
    strncpy(a, a2,3);                //将a2的内容拷贝到a中，注意缓冲区溢出的问题
    printf("%s\n", a);
    return 0;
}

结果：
abcedftk
请按任意键继续. . .

e.sprintf函数，格式化字符串

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>
int main() 
{
    char a[100] = {0};
    int i = 200;
    sprintf(a,"i = %d",i);    //将格式化后的字符串输出到第一个参数中去
    printf("%s\n", a);
    return 0;
}

f.字符串和整数的转换
整数转字符串 atoi函数
字符串转整数 （itoa函数不是标准的C语言库函数），可以使用sprintf就可以转换了

g.sscanf函数

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>
int main() 
{
    char a[100] = "56+98=";
    int c = 0;
    int b = 0;
    sscanf(a, "%d+%d", &c, &b);                    //从一个字符串中接收内容，对比scanf函数学习
    printf("%d\n", c+b);
    return 0;
}

h.strchr 查找字符

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>
int main() 
{
    char a[100] = "56+98=";
    int c = 0;
    int b = 0;
    strcpy(a, "hello world");                //当一个字符数组已经初始化后，重新给他复制不能直接使用=
                                            //，而应该使用这种方式
    
    const char *buf = strchr(a, 'o');        //在都吐个参数a中查找指定字符，找到后返回从这个字符开始的知道结尾的字符
                                            //找不到返回null

    printf("%s\n",buf);
    return 0;
}

输出结果

o world
请按任意键继续. . .

i.strstr函数，原理同上，只不过查找的内容换成了字符串

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>
int main() 
{
    char a[100] = "56+98=";
    int c = 0;
    int b = 0;
    strcpy(a, "hello world");
    const char *buf = strchr(a, 'o');
    buf = strstr(a, "wor");
    printf("%s\n",buf);
    return 0;
}

j.strtok字符串分割函数

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>
int main() 
{
    char a[100] = "abc_12345_efg";
    const char *buf = strtok(a, "_");
    printf("%s\n", buf);
    buf = strtok(NULL, "_");              //没调用一次回得到第一个符合要求的字符串，从第二个开始参数要穿NULL
    printf("%s\n", buf);
    buf = strtok(NULL, "_");
    printf("%s\n", buf);
    return 0;
}

以循环的方式分割得到所有

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>
int main() 
{
    char a[100] = "abc_12345_efg";
    const char *buf = strtok(a, "_");
    while (buf)        1                    //如果找不到buf，会返回null，如果以此为循环结束条件
    {
        printf("%s\n", buf);
        buf = strtok(NULL, "_");
    }
    return 0;
}

k.字符串转换为其他类型(stdlib.h)
a. atoi -> int
b. atof -> float
c.atol -> long

24.C语言自定义函数标准使用方式

第一种方式

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>

int getMax(int a, int b)                //自定义函数在main函数的上方定义，也就是在使用之前就定义
{                                        //在vs中，将自定义函数放在main函数的后边也是可以，但是会有警告  
                                        // warning C4013: “getMax”未定义；假设外部返回 int
    int c = a > b ? a : b;
    return c;
}

int main() 
{
    int a = 10;
    int b = 20;
    int d = getMax(a, b);
    printf("%d\n", d);
    return 0;
}

第二种方式

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>

int getMax(int a,int b);                //先声明自定义函数，然后在后边定义函数结构，不会有警告，

int main() 
{
    int a = 10;
    int b = 20;
    int d = getMax(a, b);
    printf("%d\n", d);
    return 0;
}

int getMax(int a, int b)
{
    int c = a > b ? a : b;
    return c;
}

如果C语言一个函数没有明确的返回类型，那么默认是int

在C语言中实参与形参的数据传递是“值传递”，即单向传递，只有实参传递给形参，不能有形参传递给实参，如果参数是数组，那么是可以通过形参传递给实参的，和java中的基本数据类型传递和引用数据类型传递相同

24.size_t的类型（表示unsigned int 是一种无符号整数，不是c语言的关键字，很多函数，如果确认不会返回负数，都可以用size_t类型接收）

#include<stdio.h>
#include<string.h>

_ main() 
{
    char s[100] = "hello world";
    size_t len = strlen(s);
    printf("%d\n", len);
    return;
}

25.将一个正数或者一个负数在不借助于C语言库函数的条件下转换为字符串

#include<stdio.h>
#include<string.h>

void int2String(int n,char s[])
{
    int status = 0;  //0 = 正数，1 = 负数
    if (n<0)  
    {
        status = 1;
        n = 0 - n;            //如果是负数，先把他转化为正数
    }
    else
    {
        status = 0;
    }
    int i = 0;
    while (n)
    {
        int a = n % 10;
        char c = a + '0';
        s[i] = c;
        i++;
        n /= 10;
    }
    int min = 0;
    int max = i - 1;
    while (min < max)
    {
        char temp = s[min];
        s[min] = s[max];
        s[max] = temp;
        min++;
        max--;
    }

    if (status == 1) 
    {
        for (int a = i-1; a >=0; a--)
        {
            s[a + 1] = s[a];
        }
        s[0] = '-';
    }
    printf("%s\n", s);
}

int main() 
{
    char sa[100] = { 0 };
    int2String(1234567890, sa);
}

26.#include 与#define的意义

#include就是简单的文件内容替换，使用这个引入头文件，在预编译阶段会将头文件中的内容替换到这个文件中
#define就是简单的文本替换，假设你定义了一个常量代表一个数字，那么在预编译的阶段，会直接将这个常量表示的值替换到文件中

27.#ifndef与#ebdif

#ifndef的意思就是条件预编译如果#ifndef后面的条件成立，那么就预编译从ifndef开始到#endif之间的代码，否则不会去预编译这段代码 ，在一个头文件中都是这样的格式：是为了防止头文件被重复引用，如果不加这三行，那么如果重复引用了就会在预编译的时候引入好几次，造成不必要

#ifndef RZM (宏的名字，由自己定义，保持唯一性，不与别的宏重复)
#define RZM (这两句就是如果没有定义这个宏，那么就在本行定义一下)

。。。

#endif

28.多文件编译

第一种方式：创建一个a.c,里面定义一个方法

    #include<stdio.h>

                int print(int num) {
                    printf("%d\n", num);
                }

            在主函数中调用这个方法

                #include<stdio.h>

                int print(int num);  //将函数进行声明然后使用

                int main() 
                {
                    print(10);
                }

第二种方式：通过头文件的方式调用函数（推荐这种方式）

            同样创建一个a.c,里面定义一个方法

                #include<stdio.h>

                int print(int num) {
                    printf("%d\n", num);
                }

                创建一个b.h头文件

                #ifndef __RZM__
                #define __RZM__

                int print(int num);    //在头文件中进行函数的声明

                #endif

                在主函数中调用这个方法，只需要引入这个头文集即可

                #include<stdio.h>

                #include "b.h"            //引入这个头文集

                int main() 
                {
                    print(10);
                }