C语言基础精炼

1
2
3
4
5
6
7

#include<stdio.h>

int main(){
    /* 这是每个程序的开始 */
    printf("Hello World!\n");   //这是另一种注释方法
    return 0;
}

1

00000000 -- 11111111

1
2
3
4
5
6
7

00000000 --> -2^7=-128
00000001 --> -2^7+1=-127
        ···
10000000 --> 0
10000001 --> 1
        ···
11111111 --> 2^7-1=127

1

char 1 Byte（字节）范围 -2^7~2^7 即 -128~127

1
2
3
4
5
6

int 在64位下 大小为4Byte（字节）
4 Byte=4*8 bit=32bit
也就是32个二进制bit位
所以int型的范围可以表示为
-2^31~2^31-1
（有没有奇怪为森魔要-1？因为数字0的存在）

1
2

unsigned    中文释义：无符号
signed      中文释义：有符号

1
2

unsigned char x;
/* 如此声明的这个变量x的取值范围就会变成 0~2^8-1 即 0-255 */

1
2
3
4
5
6
7
8

#include<stdio.h>
void main(){
    printf("hello world");
    return;
}
/*
    还记得return吗，用于结束函数并向操作系统或者上级调用函数返回一个数值。如果这个函数是用void修饰的，列如这里的main()函数，这里return就不必返回一个数值（如果你还是写作return 0;还会报错）
*/

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

#include<stdio.h>
int func(void){
    printf("hallo world");
    return 0;
}
int main(){
    func();
    return 0;
}
//其实默认括号内为空就表示没有参数，即void是可以省略的

1
2
3
4
5
6
7
8

//所有基本数据类型均可以定义对应常量
#define N 100
#define Good true
#define x 1.2345
#define newline '\n'

//你也可以使用那个const关键字定义常量
const double x=0.123456;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

#include<stdio.h>
int main(){
    int i;      //声明整形变量i
    int x,y;    //声明整形变量x，y
    float a;
    double b;
    char ch;    //声明字符变量ch

    scanf("%d",&i);         //从键盘输入数字i
    scanf("%d %d",&x,&y);   //从键盘同时输入数字x,y
    scanf("%f %lf",&a,&b);
    scanf("%c",&ch);        //从键盘读入一个字符ch

    printf("hallo world\n");  //打印固定字符串
    printf("%d\n",i);         //打印单个数字
    printf("你输入的x=%d,y=%d\n",x,y);//格式化输出
    printf("单精度a=%f;双精度b=%.3lf",a,b);//打印输出浮点类型，并限制位数
    printf("%c",ch);//打印单个字符
    return 0;
}

1
2
3

10
2 3
1.234 3.141592654

1
2
3
4

hallo world
10
你输入的x=2,y=3
单精度a=1.234000;双精度b=3.142

1

fflush(stdin);

  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
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137

    #include<stdio.h>
    int main(){
        int x=0;
        printf("%d\n",x++);
        printf("%d\n",x);
        printf("%d\n",--x);
        printf("%d\n",x);
        return 0;
    }
    ```

    样例输出

    ```text
    0
    1
    0
    0
    ```
    * 当这两个运算符出现在程序语句中时
    * 如果位于变量前，则先执行自增（或自减）再执行程序语句
    * 如果位于变量之后，则先执行程序语句，再进行自增（或自减）

    除此之外c语言还支持如下的写法简化：

    ```c
    i=i+1;  可以写作 i+=1;
    i=i*10; 可以写作 i*=10;
    i=i/2;  可以写作 i/=2;
    i=i-5;  可以写作 i-=5;
    ```

---

### 关系运算符

这里假设A=10，B=20

| 运算符 | 描述                                                           | 实例              |
| :----- | :------------------------------------------------------------- | :---------------- |
| ==     | 检查两个操作数的值是否相等，如果相等则条件为真。               | (A == B) 不为真。 |
| !=     | 检查两个操作数的值是否相等，如果不相等则条件为真。             | (A != B) 为真。   |
| >      | 检查左操作数的值是否大于右操作数的值，如果是则条件为真。       | (A > B) 不为真。  |
| <      | 检查左操作数的值是否小于右操作数的值，如果是则条件为真。       | (A < B) 为真。    |
| >=     | 检查左操作数的值是否大于或等于右操作数的值，如果是则条件为真。 | (A >= B) 不为真。 |
| <=     | 检查左操作数的值是否小于或等于右操作数的值，如果是则条件为真。 | (A <= B) 为真。   |

---

### 逻辑运算符

这里假设A=10，B=20

| 运算符 | 描述                                                                               | 实例             |
| :----- | :--------------------------------------------------------------------------------- | :--------------- |
| &&     | 称为逻辑与运算符。如果两个操作数都非零，则条件为真。                               | (A && B) 为假。  |
| \|\|   | 称为逻辑或运算符。如果两个操作数中有任意一个非零，则条件为真。                     | (A \|\| B) 为真。 |
| !      | 称为逻辑非运算符。用来逆转操作数的逻辑状态。如果条件为真则逻辑非运算符将使其为假。 | !(A && B) 为真。 |

---

### 按位运算符

位运算符作用于位，并逐位执行操作。&、 | 和 ^ 的真值表如下所示：

| p   | q   | p & q | p \| q | p ^ q |
| --- | --- | ----- | ------ | ----- |
| 0   | 0   | 0     | 0      | 0     |
| 0   | 1   | 0     | 1      | 1     |
| 1   | 1   | 1     | 1      | 0     |
| 1   | 0   | 0     | 1      | 1     |

假设如果 A = 60，且 B = 13，现在以二进制格式表示，它们如下所示：

```text
    A = 0011 1100
    B = 0000 1101
    -----------------
    A&B = 0000 1100
    A|B = 0011 1101
    A^B = 0011 0001
    ~A  = 1100 0011
    ```

    * c语言中实际的位运算符

    | 位运算符 | 描述                                                                                        | 实列                                                             |
    | :------- | :------------------------------------------------------------------------------------------ | :--------------------------------------------------------------- |
    | &        | 按位与操作，按二进制位进行"与"运算。                                                        | (A & B) 将得到 12，即为 0000 1100                                |
    | \|       | 按位或运算符，按二进制位进行"或"运算。                                                      | (A \| B) 将得到 61，即为 0011 1101                               |
    | ^        | 异或运算符，按二进制位进行"异或"运算。                                                      | (A ^ B) 将得到 49，即为 0011 0001                                |
    | ~        | 取反运算符，按二进制位进行"取反"运算。                                                      | (~A ) 将得到 -61，即为 1100 0011，一个有符号二进制数的补码形式。 |
    | <<       | 二进制左移运算符。将一个运算对象的各二进制位全部左移若干位（左边的二进制位丢弃，右边补0）。 | A << 2 将得到 240，即为 1111 0000                                |
    | >>       | 二进制右移运算符。将一个数的各二进制位全部右移若干位，正数左补0，负数左补1，右边丢弃。      | A >> 2 将得到 15，即为 0000 1111                                 |

---

## 条件选择语句

* **c语言把任意非零，非空的值定义为true，把零或null定义为false**

### 基本if语句

```c
#include<stdio.h>
int main(){
    if (1) printf("hallo ");

    if (true) {
        printf("world");
    }

    int x=10;
    if (x) printf("\n");

    //求a,b,c种的最大值
    int a=5,b=2,c=3;
    int ans;
    if (a>b){
        ans=a;
    }
    else{
        if (b>c){
            ans=b;
        }
        else{
            ans=c;
        }
    }
    printf("a=%d,b=%d,c=%d\nMax=%d\n",a,b,c,ans);

    //    &&且    ||或
    if (a>b && b>c) printf("a\n");
    if (a>b || b>c) printf("b\n");

    return 0;
}

1
2
3
4

hallo world
a=5,b=2,c=3
Max=5
b

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

#include<stdio.h>
int main(){
    int a=1,b=2,c=3;

    if (a>b && ++a) printf("Yes\n");
    //这里由于a>b不成立，所以a++不会被执行，所以a的值仍然为1,当然prinft语句也不会被执行
    if (a<b && ++a) printf("%d\n",a);
    //这里由于a<b成立，所以a++也会被执行，这里会运行输出a数值2

    if (b<c || ++b) printf("%d\n",b);
    // ||也是如此，由于b<c成立，于是b++也不会被执行，输出b的数值为2
    return 0;
}

1
2

2
2

1
2
3
4
5
6
7
8

#include<stdio.h>
int main(){
    int n;
    printf("请输入一个数字：");
    scanf("%d",&n);
    (n>0)?printf("正数\n"):printf("负数\n");
    return 0;
}

1

请输入一个数字：12

1

正数

1
2
3
4
5
6

if (n>0) {
    printf("正数");
}
else {
    printf("负数");
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

#include<stdio.h>
int main(){
    int n;
    printf("请输入一个数字：");
    scanf("%d",&n);
    switch (n){
        case 1: printf("this is case 1\n");
        case 2: printf("this is case 2\n"); break;
        default:
            printf("this is default\n");
    }
    return 0;
}

1

1

1
2

this is case 1
this is case 2

1

2

1

this is case 2

1

3

1

this is default

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

#include<stdio.h>
int main(){
    //  统计1加到100的和
    int i;
    int ans=0;
    for (i=0;i<=100;i++){
        ans=ans+i;
    }
    printf("%d\n",ans);
    return 0;
}

1

5050

1
2
3
4

for ( init; condition; increment )
{
    statement(s);
}

1

[Error] 'for' loop initial declarations are only allowed in C99 or C11 mode

1
2
3

for (int i=0;i<=100;i++) {
    ans=ans+1;
}//并且，这里的i变量在循环体结束之后就会被释放销毁，即你在循环体之外是无法再次使用i变量的。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

//求1~100内奇数的和
#include<stdio.h>
int main(){
    int i=1;
    int ans=0;
    while (i<=100){
        ans+=i;
        i+=2;
    }
}

1
2
3
4

while(condition)
{
    statement(s);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

//计算100以内偶数的和
#include<stido.h>
int main(){
    int i=2;
    int ans=0;
    do{
        ans+=i;
        i+=2;
    }while(i<=100)
}

1
2
3
4
5

do
{
    statement(s);

}while( condition );

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

返回值类型 函数名(参数类型 参数1,参数类型 参数2 ···){
    函数主体
}

实列：
//求a，b中的最大值，并返回该最大值
int Max(int a,int b){
    int ret;
    (a>=b)?ret=a:ret=b;//还记的这个三元运算符吗？
    return ret;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

#include<stdio.h>
int Max(int a,int b) {
    int ret;
    (a>=b)?ret=a:ret=b;
    return ret;
}

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

1

20

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

#include<stdio.h>
//函数作用：交换ab的值，这是交换两个数常用写法。
void swap(int a,int b){
    int t;
    t=a;
    a=b;
    b=t;
}
int main(){
    int a=10,b=20;
    printf("a=%d,b=%d\n",a,b);
    swap(a,b);
    printf("a=%d,b=%d\n",a,b);
    return 0;
}

1
2

a=10,b=20
a=10,b=20

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

#include<stdio.h>
void swap(int *a,int *b){
    int t=*a;
    *a=*b;
    *b=t;
}
int main(){
    int a=10,b=20;
    printf("a=%d,b=%d\n",a,b);
    swap(&a,&b);
    printf("a=%d,b=%d\n",a,b);
    return 0;
}

1
2

a=10,b=20
a=20,b=10

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

#include<stdio.h>
//全局变量
int g=10;

void func1(int g){
    printf("in func1 g=%d\n",g);
    return;
}

void func2(){
    printf("in func2 g=%d\n",g);
    return;
}

int main(){
    //局部变量
    int x=20,g=30;
    printf("in main x=%d,g=%d\n",x,g);
    func1(x);//我们把x=20的值赋值给形式参数g
    func2();
    return 0;
}

1
2
3

in main x=20,g=30
in func1 g=20
in func2 g=10

1

in main x=20,g=30

1

in func1 g=20

1

in func2 g=10

1

数据类型 数组名称[数组大小];

1
2
3
4

int a[100];
/*
这个实例里我们就定义了一个长度为100的数组，可以存储100个int型数据
*/

1
2
3
4
5
6
7
8
9

int a[10]={0};
//声明一个大小为10的整形数组，并初始化所有元素为0
//还记得吗，下标从0开始哦，0~9

double a[]={0.0,1.1,2.2,3.3}
//你也可以为数组里每个元素单独初始化，如果你这么做的话还可以省略方括号里的数组大小（这个数组大小为4）

int a[10]={0,1,2,3}
//如果规定了数组大小但是没有把每个元素单独赋值，未赋值部分依据上面提到的默认初始化规则初始化。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

#include<stdio.h>
int main(){
    //声明一个大小为100的int型数组并初始化所有值为0
    int a[100]={0};

    //将数组所有元素赋值为1~100
    for (int i=0;i<100;i++){
        //我们通过 数组名[下标] 的方式访问数组元素
        a[i]=i+1;
    }

    //我们计算数组里所有元素的累加和，即1-100的累加和
    int ans=0;
    for (int i=0;i<100;i++){
        ans+=a[i];
    }
    //样例输出5050
    printf("%d\n",ans);
    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

#include<stdio.h>
//计算a数组内所有元素的平均值
double func(int* a,int size){
    double average=0;
    for (int i=0;i<size;i++)
        average+=a[i];
    return average/(double)size;
}
/*
    其实你可以发现数组传参的方法就是一个"引用传参"
    所以数组使用这种方法进行函数传参是可以修改数组元素的

    数组函数传参还有别的写法，但是这里只讲解这一种。
    希望你养成一个好习惯，数组传参务必带上数组大小
*/

int main(){
    //声明初始化一个数组a
    int a[5]={1,2,3,4,5};
    //打印平均值
    printf("%lf\n",func(a,5));
    return 0;
}

1

int a[10]={0}

1
2
3
4
5
6
7

#include<stdio.h>
int main(){
    int a[10]={0};
    for(int i=0;i<=10;i++)
        printf("%d ",a[i]);
    return 0;
}

1

0 0 0 0 0 0 0 0 0 0 1

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

    /*
    还记的\0吗，截止符
    字符数组内存储的字符串的末尾必须有截止符！
    */
    char name[6]={'h', 'e', 'l', 'l', 'o', '\0'};

    //你还可以用这个写法.
    char greeting[]="hello";
    //初始化部分元素也是可以滴
char name[20]="xiaoming";

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

char str[]="hello world";
for (int i=0;str[i]!=0;i++){
    ···
}

int i=0;
while(str[i]!=0){
    ···
    i++;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

char str[100];
//输入字符串
gets(str);
scanf("%s",&str);

//输出字符串
puts(str);
printf("%s\n",str);

/*
之前说到在数组处理，越界并不会被报错
所以这里的输入都存在着极大的安全隐患，于是在Visual studio的最新版本里，出于安全考虑
在默认情况下不允许使用以上函数读取字符串。下面提到的C语言字符串处理函数也是一样，都存在了越界问题
因而在最新的VS中默认不允许使用，这也是我不推荐使用最新版本的VS的原因
*/

1
2
3
4
5
6
7
8

#include<stdio.h>
#include<string.h>
int main(){
    char name[]="xiaoming";
    printf("size of name=%d\n",sizeof(name));
    printf("strlen of name=%d\n",strlen(name));
    return 0;
}

1
2

size of name=9
strlen of name=8

1
2
3
4
5
6
7
8

#include<stdio.h>
#include<string.h>
int main(){
    char name[20]="xiaoming";
    printf("size of name=%d\n",sizeof(name));
    printf("strlen of name=%d\n",strlen(name));
    return 0;
}

1
2

size of name=20
strlen of name=8

 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

#include<stdio.h>
int main(){
    //首先定义一个结构体DATE来存储出生年月
    struct DATE{
        short year; //年
        short month;//月
        short day;  //日
    };

    //定义学生信息结构体StudentInfo
    struct StudentInfo{
        char name[20]={0};  //姓名
        DATE date;  //出生年月，对!结构体也可以嵌套定义
    };

    //对，我们要存储一个班的学生，50人
    StudentInfo student[50];

    for (int i=0;i<50;i++){
        printf("输入第%d个学生信息：\n",i+1);
        //我们使用结构体名称加"."的方式来访问结构体内部元素
        printf("学生姓名："); scanf("%s",&student[i].name);
        printf("学生出生年月日：");
        scanf(
            "%d-%d-%d",
            &student[i].date.year,
            &student[i].date.month,
            &student[i].date.day
        );
    };

    for (int i=0;i<50;i++){
        printf("%s\n",student[i].name);
        printf(
            "%d-%d-%d",
            student[i].date.year,
            student[i].date.month,
            student[i].date.day
        );
    };
    return 0;
}

1
2
3

输入第1个学生信息：
学生姓名：xiaoming
学生出生年月日：1992-12-21

1
2

xiaoming
1992-12-21

1
2
3
4
5

struct 结构体类型名{
    基本数据类型 变量名;
    基本数据类型 变量名;
    ...
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

    //如此我们在声明一个DATE结构体类型的同时，声明了一个date的结构体实体变量
    stuct DATE{
        int year;
        int month;
        int day;
    }date;

    //如果我们并不打算在别的地方使用这种结构体类型，只是单纯的为了声明这样一个结构体实体变量，还可以省略结构体类型名称
    struct{
        int year;
        int month;
    }date1;

    //这个还是定义一个结构体类型DATE
typedef stuct{
    int year;
    int month;
}DATE;

 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

    enum WEEK{
        Monday=1,
        Tuesday,
        Wednesday,
        Thursday,
        Friday,
        Saturday,
        Sunday
    }

    WEEK day;
    /*
    你也可以使用这种写法多写一个单词
    enum WEEK day;

    当然也可以像结构体一样声明枚举类型，到实体化枚举变量一气呵成
    enum WEEK{
        Monday=1,
        Tuesday,
        Wednesday,
        Thursday,
        Friday,
        Saturday,
        Sunday
    } day;
    */

1

enum season {spring, summer=3, autumn, winter};

1

基础数据类型 *变量名

1
2
3
4
5

int *p0;
short *p1;
long *p2;
char *p3;
float *p4;

1
2
3
4

struct TEST{
    int a,b;
};
TEST* p0;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

#include<stdio.h>
int main(){
    int *p=NULL; //声明指针变量，并初始化为NULL（即0）NULL是C语言里约定的空指针值
    int a;  //声明一个正常整形变量

    a=1;    //将a赋值为1
    p=&a;  //将a的地址赋值给指针变量
    //& 符号，取变量的地址

    printf("a=%d\np=%p\n*p=%d",a,p,*p);
    a=22;   //改变a的值
    printf("\na=%d\np=%p\n*p=%d",a,p,*p);
    return 0;
}

1
2
3
4
5
6
7

a=1                 //a的值
p=000000000062FE44  //p的值，即a的地址
*p=1                //p所指向的地址所存储的值，即a的值

a=22
p=000000000062FE44  //同上
*p=22

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

FILE *f=NULL;   //声明一个文件指针
char buff[100]; //声明一个字符串数组
char ch;        //声明一个字符变量
int x;          //声明一个整形变量

f=fopen("test.txt","wr");   //打开文件，"wr"指定可读可写
ch=fgetc(f);                //从文件中读取单个字符赋值给ch
fscanf(f,"%s",buff);        //从文件中读取字符串赋值给buff字符串数组
fscanf(f,"%d",&x);          //从文件中读取一个整形变量
fgets(buff,100,f);          //从文件中读取字符串，并存放到buff中，指定最大长度100
fprintf(f,"%s\n",buff);     //向文件中写入字符串数组

fputc(ch,f);                //向文件中写入单个字符
fputs(buff,f);              //向文件中写入字符串