C语言几个简单的入门demo

if

与if的配对规则( 在缺省{} )的时候:else总是与他前面最近的、且尚未与其他else配对的if配对;

c语言中的几个函数

  1. exit() 终止整个程序
  2. auto 存储类型
  3. extern 存储类型
  4. static 存储类型
  5. register 存储类型
  6. memset 函数赋值
  7. memcpy 函数拷贝

字符串长度定义方式

1
2
3
4
5
6
7
8
9
10
11
// 方法一
char *fei = NULL;
fei = (char *) malloc(sizeof(char));
scanf("%s", fei);
printf("%s", fei);
printf("\n\r ----------- \n\r");

// 方法二
char foo[] = "";
scanf("%s", foo);
printf("%s", foo);

数组

提示: C语言中无法一次输出整个数组,只能循环输出数组中每个值

数组初始化

1
2
3
4
5
6
7
8
9
int a[10] = {0, 1, 2, 3, 4};

char str[ ] = {'a', 'b', 'c', 'd', 'e' };

char str[10] = "abc_123"; // 字符数组
printf ("bar = %s ", str);

char *name = "abc_123"; // 利用指针变量输出字符串
printf ("bar = %s ", name);

C语言除了在定义数组变量时用初值列表对数组整体赋值以 外，无法再对数组变量进行整体赋值。

如果再想赋值,可以使用循环逐一赋值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// demo:  删除数组中下标为2的元素(本质是修改)
// 解释:第五个元素的内存还在,数组是一个连续的空间, 总长度不会变,只是把值改变了
// 初始化时内存空间已经申请下来了，就不会改变了
int i, b[5] = {99, 60, 75, 86, 92};
int n = 5;
for (i = 2; i < n - 1; i++) {
    b[i] = b[i + 1];
}
n = n - 1;

for ( i = 0; i < n; i++) {
    printf("%d ", b[i]);
}

printf("%d ", b[4]);
1
2
3
4
5
6
7
8
9
10
11
12
13
//demo: 利用数组,输出20以内可以被7整除的数
int a[20];
int j = 0;
for (int i = 0; i <= 20; i++) {
    if (i % 7 == 0) {
        a[j++] = i;
    }
}

// c语言中不能整个输出数组,只能循环输出数组中每个值
for (int i = 0; i < j; i++) {
    printf("%d ", a[i]);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
// demo: 数组练习
// 从键盘上输入6个数，计算均值，然后输出小于均值的
int a[6], s = 0;
for (int i = 0; i < 6; i++) {
    scanf("%d", &a[i]);
    s += a[i];
}
printf("这几个数的平均值为%.1f \n", s / 6.0);
printf("小于平均值的是: ");
for (int i = 0; i < 6; i++) {
    if (a[i] < s / 6.0) {
        printf("%d ", a[i]); // 小于平均值的是:
    }
}

二维数组

int a[2][3]; 表示 2行3列 的二维数组

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
// 1. 按行分段赋值, 定义一个2行3列的数组
int a[2][3]={ { 80,75,92 }, { 61,65,71 } };

for (int i = 0; i < 3; i++) { // 输出整个数组
    for (int j = 0; j < 3; j++) {
        printf("%d ", a[i][j]);
    }
    printf("\n");
}

// 2. 按行连续赋初值, 根据列数把数据依次分行
int a[2][3]={ 80,75,92 , 61,65,71 };

// 3. 二维数组赋初值时， { } 内写出个数的初值原则
// 初始值少则补0,初始值多则错误
// 3-2). 初始赋值的时候第一个[]里面数字可以省略,第二个[]里面的数组不能省略
// 		 既行数可以省略,列数不能省略
// demo1:
int a[3][3]={ { 80,75,92 }, { 61,65,71 } };
// 输出
// 80 75 92
// 61 65 71
// 0  0  0  ---------------这一行都是补0的

//demo2: 
int a[][3]={ 1,2,3,4,5,6,7,8,9 };
// 输出
// 1 2 3
// 4 5 6
// 7 8 9

//demo3
int a[][3]={1,2,3,4 };
// 输出
// 1 2 3
// 4 0 0    ---------------这一行部分是补0的

//demo4
int a[][3]={{1}, {2}, {3} };
// 输出     ---------------这个二维数组每行都有补0
// 1 0 0     
// 2 0 0
// 3 0 0

//demo5
int a[][3]={{1,6}, {2}, {3} };
// 输出
// 1 6 0
// 2 0 0
// 3 0 0

二维数组的应用demo

1
2
3
4
5
6
7
8
9
10
11
12
13
// 有一个2×3的矩阵，要求编程序求出其中值最大的那个元素的值，以及其所在的行号和列号
int a[2][3] = {61, 65, 71, 80, 75, 92};
int max = a[0][0], row = 0, colum = 0;
for (int i = 0; i < 2; i++) {
    for (int j = 0; j < 3; j++) {
        if (a[i][j] > max) {
            max = a[i][j];
            row = i;
            colum = j;
        }
    }
}
printf("最大值max=%d 行号row=%d 列号colum=%d", max, row, colum);

字符串数组

字符:
字符是用单引号括起来的单个字符，它在存储器中占1个字节。例如： ’A

字符串:

  1. 是用双引号括起来的一串字符，它在存储器中占n+1个字节，即字符 串的结束符’\0’也占1个字节的位置。例如， ”abc”
  2. 有效字符的个数称为字符串长度。 例如， ”abc”的长度为3，但占4 个字节 （ ’\0’一位）。

字符串是用字符型数组存放的

字符串的本质: 字符串是一种以 ‘\0’ 结尾的字符串数组
字符数组:

字符数组:

注意：
在用字符数组来存放某个字符串常量时,如果要指定字符数组的大小,
那么其大小要比字符串的长度大1(多定义一个单元用于存放 ‘\0’ )

demo:

使用%ns格式控制符 限制输入的字符个数

1
2
3
4
> char str[6];
> scanf("%5s", str); // 最多可读入5个非空格字符到str中
> printf("%s", str); // 只会输出 5个字符
>

gets scanf
输入的字符串中可包含空格字符 输入的字符串中不可包含空格字符
只能输入一个字符串 可连续输入多个字符串（使用%s%s…）
不可限定字符串的长度 可限定字符串的长度（使用%ns)
遇到回车符结束 遇到空格符或回车符结束

字符串长度

字符串长度:

1
2
3
4
> char str[ ]= "0123456789";
> printf ("%d", strlen(str)); //输出结果为10
> printf ("%d", strlen(&str[5])); //输出结果为5
>

常见字符函数

1
2
3
4
5
6
> // strcpy 函数    strcpy(字符数组1, 字符串2)
> // strncpy 函数   strncpy(字符数组1, 字符串2, 长度n)
> // strcmp 函数    strcmp(字符串1, 字符串2) 
> // strnicmp 函数
> // strcat 函数    strcat(字符数组1, 字符数组2) 
>

字符串数组使用

1
2
3
4
5
6
// 输出每个城市的名字
char city[][10] = {"BeiJing", "ShangHai", "TianJin", "GuangZhou", "WuHan"};
for (int i = 0; i < 5; i++) {
    printf("%s", city[i]);  // 或则使用 puts(&city[0]);
    printf("\n");
}

函数

写在main()函数之前

1
2
3
4
5
6
7
8
9
10
11
12
// 这个函数写在 main() 主函数之前,在 main() 中可以直接调用
int funMax(int x, int y) {
    return x > y ? x : y;
}

int main() {
    int a = 3, b = 5, res;
    res = funMax(a, b);
    printf("%d", res);

    return 0;
}

提前声明

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// 先声明  --------------↓↓↓↓
int funMax(int x, int y);

int main() {
    int a = 3, b = 5, res;
    res = funMax(a, b);
    printf("%d", res);

    return 0;
}

// 这个写在 main() 主函数之后,使用前需要先声明 -----↑↑↑
int funMax(int x, int y) {
    return x > y ? x : y;
}

使用前声明

1
2
3
4
5
6
7
8
9
10
11
12
13
int main() {
    int a = 3, b = 5, res;
    int funMax(int x, int y); // 提前声明函数
    res = funMax(a, b); // 这里才可以使用
    printf("%d", res);

    return 0;
}

// 这个写在 main() 主函数之后,使用前需要先声明
int funMax(int x, int y) {
    return x > y ? x : y;
}

函数没有返回值的写 void

1
2
3
void funPrt() {
    printf("我没有返回值,我只是打印");
}

数组函数

数组函数不需要返回值即可改变数组值,(数组是引用传递)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// 我不需要返回值,我就能改变数组的值
void funPrtArr(int arr2[]) {
    arr2[0] = 10;
    arr2[1] = 20;
}

int main() {
    int arr[2]={1,2};
    funPrtArr(arr);
    for (int i = 0; i < 2; i++) {
        printf("%d ", arr[i]); // 输出10 20
    }

    return 0;
}

指针

1
2
3
4
5
6
7
// 引用指针变量
int fei;
int *p = &fei; // p 指向fei
*p = 20; // 相当于 fei=20
fei++;
// 输出: fei=21,*p=21
printf("fei=%d,*p=%d", fei, *p);
1
2
3
4
5
6
7
// 引用指针变量
int fei;
int *p = &fei; // p 指向fei
*p = 20; // 相当于 fei=20
(*p)++;  // --------注意这里写法,有个括号
// 输出: fei=21,*p=21
printf("fei=%d,*p=%d", fei, *p);
1
2
char *name = "abc_123"; // 利用指针变量输出字符串
printf ("bar = %s ", name);

数组的指针

1
2
3
4
5
6
7
8
9
10
11
12
13
14
int a[5];
for (int i = 0; i < 5; i++) { // 数组下标
    a[i] = i;
}

int b[5];
for (int j = 0; j < 5; j++) { // 数组指针
	*(b + j) = j; // 注意 b+j == &b[j]   *(b+j) == b[j]
}

// 上面这2中写法效果一样
for (int n = 0; n < 5; n++) {
    printf("%d --- %d \n", a[n], b[n]);
}

利用数组指针,输出英文字母

1
2
3
4
5
6
7
8
9
10
11
12
13
14
char strA[5];
for (int i = 0; i < 5; i++) {
    strA[i] = 'A' + i;
}

char strB[5];
for (int j = 0; j < 5; j++) {
    *(strB + j) = 'A' + j;
}

// 上面这2中写法效果一样
for (int n = 0; n < 5; n++) { // 输出 ABCDE 英文字母
    printf("%c --- %c \n", strA[n], strB[n]);
}

指针作为函数的参数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// 传值引用
void funMax(int x) {
    x = 5;
}

int main() {
    int a = 3;
    funMax( a);

    // 输出 3
    printf("%d", a);

    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
// 传地址引用
void funMax(int *x) {
    *x = 5;
}

int main() {
    int a = 3;
    funMax( &a);

    // 输出 5
    printf("%d", a);

    return 0;
}

结构体

结构体struct

第一种方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
//需要引入的文件
#include<stdio.h>
#include<malloc.h>
void Chinese(){ // tip:哪里需要中文可以调用
    system("chcp 65001"); // process.h 这个库解决中文乱码
}

struct book { // 结构体类型
    char name[20];
    char author[20];
    int price;
};


int main() {
    Chinese();
    struct book foo = { "论语", "孔子", 100};
    printf("书名:%s 作者:%s 价格:%d ", foo.name, foo.author, foo.price);

    return 0;
}

第二种方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
//需要引入的文件
#include<stdio.h>
#include<malloc.h>
void Chinese(){ // tip:哪里需要中文可以调用
    system("chcp 65001"); // process.h 这个库解决中文乱码
}

struct book { // 结构体类型
    char name[20];
    char author[20];
    int price;
} foo = { "论语", "孔子", 100};


int main() {
    Chinese();
    printf("书名:%s 作者:%s 价格:%d ", foo.name, foo.author, foo.price);
    
    return 0;
}

第三种方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
//需要引入的文件
#include<stdio.h>
#include<malloc.h>
void Chinese(){ // tip:哪里需要中文可以调用
    system("chcp 65001"); // process.h 这个库解决中文乱码
}

struct { // 结构体类型
    char name[20];
    char author[20];
    int price;
} foo = { "论语", "孔子", 100};

int main() {
    Chinese();
    printf("书名:%s 作者:%s 价格:%d ", foo.name, foo.author, foo.price);

    return 0;
}

结构体指针

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
//demo1 ############## 
// 需要引入的文件
#include<stdio.h>
#include<malloc.h>
void Chinese(){ // tip:哪里需要中文可以调用
    system("chcp 65001"); // process.h 这个库解决中文乱码
}

struct { // 结构体类型
    char name[20];
    char author[20];
    int price;
    char *nickname;  //姓名( 结构体指针 )
} foo = { "论语", "孔子", 100, "孔仲尼"};
int main() {
    Chinese();
    printf("书名:%s ", foo.name);
    printf("作者:%s ", foo.author);
    printf("价格:%d ", foo.price);
    printf("别名:%s", foo.nickname);
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
// demo2 ############## 通常使用 -> 通常采用后面的写法
// 需要引入的文件
#include<stdio.h>
#include<malloc.h>
void Chinese(){ // tip:哪里需要中文可以调用
    system("chcp 65001"); // process.h 这个库解决中文乱码
}

struct { // 结构体类型
    char name[20];
    char author[20];
    int price;
    char *nickname;  //姓名( 结构体指针 )
} book = { "论语", "孔子", 100,"孔仲尼"}, *pBook = &book;

int main() {
    Chinese();

    printf("书名:%s ", (*pBook).name);
    printf("作者:%s ", (*pBook).author);
    printf("价格:%d ", (*pBook).price);
    printf("别名:%s", (*pBook).nickname);

    printf("\n\r 通常采用后面的写法");

    printf("书名:%s ", (pBook->name));
    printf("作者:%s ", (pBook->author));
    printf("价格:%d ", (pBook->price));
    printf("别名:%s", (pBook->nickname));
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
//demo3 ############## 
//需要引入的文件
#include<stdio.h>
#include<malloc.h>
void Chinese(){ // tip:哪里需要中文可以调用
    system("chcp 65001"); // process.h 这个库解决中文乱码
}

struct book{ // 结构体类型
    char name[20];
    char author[20];
    int price;
    char *nickname;  //姓名( 结构体指针 )
} books[] = {
        {"论语", "孔子", 100, "孔仲尼"},
        {"史记", "司马迁", 200, "子长"},
}, *pBook;



int main() {
    Chinese();
    //计算数组长度
    int len2 = sizeof(books) / sizeof(struct book);
    for(pBook=books; pBook<books+len2; pBook++){
        printf("书名:%s ", (pBook->name));
        printf("作者:%s ", (pBook->author));
        printf("价格:%d ", (pBook->price));
        printf("别名:%s", (pBook->nickname));
        printf("\n\r");
    }
    
    return 0;
}

底部

没有了