Memorial Sea

1
00000000 -- 11111111

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

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

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

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

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

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

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

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

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

1
fflush(stdin);

1
    #include<stdio.h>
2
    int main(){
3
        int x=0;
4
        printf("%d\n",x++);
5
        printf("%d\n",x);
6
        printf("%d\n",--x);
7
        printf("%d\n",x);
8
        return 0;
9
    }
10
    ```
11

12
    样例输出
13

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

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

26
    ```c
27
    i=i+1;  可以写作 i+=1;
28
    i=i*10; 可以写作 i*=10;
29
    i=i/2;  可以写作 i/=2;
30
    i=i-5;  可以写作 i-=5;
31
    ```
32

33
---
34

35
### 关系运算符
36

37
这里假设A=10，B=20
38

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

48
---
49

50
### 逻辑运算符
51

52
这里假设A=10，B=20
53

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

60
---
61

62
### 按位运算符
63

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

66
| p   | q   | p & q | p \| q | p ^ q |
67
| --- | --- | ----- | ------ | ----- |
68
| 0   | 0   | 0     | 0      | 0     |
69
| 0   | 1   | 0     | 1      | 1     |
70
| 1   | 1   | 1     | 1      | 0     |
71
| 1   | 0   | 0     | 1      | 1     |
72

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

75
```text
76
    A = 0011 1100
77
    B = 0000 1101
78
    -----------------
79
    A&B = 0000 1100
80
    A|B = 0011 1101
81
    A^B = 0011 0001
82
    ~A  = 1100 0011
83
    ```
84

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

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

96
---
97

98
## 条件选择语句
99

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

102
### 基本if语句
103

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

109
    if (true) {
110
        printf("world");
111
    }
112

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

116
    //求a,b,c种的最大值
117
    int a=5,b=2,c=3;
118
    int ans;
119
    if (a>b){
120
        ans=a;
121
    }
122
    else{
123
        if (b>c){
124
            ans=b;
125
        }
126
        else{
127
            ans=c;
128
        }
129
    }
130
    printf("a=%d,b=%d,c=%d\nMax=%d\n",a,b,c,ans);
131

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

136
    return 0;
137
}

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

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

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

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

1
2
2
2

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

1
请输入一个数字：12

1
正数

1
if (n>0) {
2
    printf("正数");
3
}
4
else {
5
    printf("负数");
6
}

1
#include<stdio.h>
2
int main(){
3
    int n;
4
    printf("请输入一个数字：");
5
    scanf("%d",&n);
6
    switch (n){
7
        case 1: printf("this is case 1\n");
8
        case 2: printf("this is case 2\n"); break;
9
        default:
10
            printf("this is default\n");
11
    }
12
    return 0;
13
}

1
1

1
this is case 1
2
this is case 2

1
2

1
this is case 2

1
3

1
this is default

1
#include<stdio.h>
2
int main(){
3
    //  统计1加到100的和
4
    int i;
5
    int ans=0;
6
    for (i=0;i<=100;i++){
7
        ans=ans+i;
8
    }
9
    printf("%d\n",ans);
10
    return 0;
11
}

1
5050

1
for ( init; condition; increment )
2
{
3
    statement(s);
4
}

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

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

1
//求1~100内奇数的和
2
#include<stdio.h>
3
int main(){
4
    int i=1;
5
    int ans=0;
6
    while (i<=100){
7
        ans+=i;
8
        i+=2;
9
    }
10
}

1
while(condition)
2
{
3
    statement(s);
4
}

1
//计算100以内偶数的和
2
#include<stido.h>
3
int main(){
4
    int i=2;
5
    int ans=0;
6
    do{
7
        ans+=i;
8
        i+=2;
9
    }while(i<=100)
10
}

1
do
2
{
3
    statement(s);
4

5
}while( condition );

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

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

1
#include<stdio.h>
2
int Max(int a,int b) {
3
    int ret;
4
    (a>=b)?ret=a:ret=b;
5
    return ret;
6
}
7

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

1
20

1
#include<stdio.h>
2
//函数作用：交换ab的值，这是交换两个数常用写法。
3
void swap(int a,int b){
4
    int t;
5
    t=a;
6
    a=b;
7
    b=t;
8
}
9
int main(){
10
    int a=10,b=20;
11
    printf("a=%d,b=%d\n",a,b);
12
    swap(a,b);
13
    printf("a=%d,b=%d\n",a,b);
14
    return 0;
15
}

1
a=10,b=20
2
a=10,b=20

1
#include<stdio.h>
2
void swap(int *a,int *b){
3
    int t=*a;
4
    *a=*b;
5
    *b=t;
6
}
7
int main(){
8
    int a=10,b=20;
9
    printf("a=%d,b=%d\n",a,b);
10
    swap(&a,&b);
11
    printf("a=%d,b=%d\n",a,b);
12
    return 0;
13
}

1
a=10,b=20
2
a=20,b=10

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

5
void func1(int g){
6
    printf("in func1 g=%d\n",g);
7
    return;
8
}
9

10
void func2(){
11
    printf("in func2 g=%d\n",g);
12
    return;
13
}
14

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

1
in main x=20,g=30
2
in func1 g=20
3
in func2 g=10

1
in main x=20,g=30

1
in func1 g=20

1
in func2 g=10

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

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

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

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

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

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

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

12
    //我们计算数组里所有元素的累加和，即1-100的累加和
13
    int ans=0;
14
    for (int i=0;i<100;i++){
15
        ans+=a[i];
16
    }
17
    //样例输出5050
18
    printf("%d\n",ans);
19
    return 0;
20
}

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

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

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

1
int a[10]={0}

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

1
0 0 0 0 0 0 0 0 0 0 1

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

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

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

6
int i=0;
7
while(str[i]!=0){
8
    ···
9
    i++;
10
}

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

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

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

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

1
size of name=9
2
strlen of name=8

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

1
size of name=20
2
strlen of name=8

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

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

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

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

32
    for (int i=0;i<50;i++){
33
        printf("%s\n",student[i].name);
34
        printf(
35
            "%d-%d-%d",
36
            student[i].date.year,
37
            student[i].date.month,
38
            student[i].date.day
39
        );
40
    };
41
    return 0;
42
}

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

1
xiaoming
2
1992-12-21

1
struct 结构体类型名{
2
    基本数据类型 变量名;
3
    基本数据类型 变量名;
4
    ...
5
}

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

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

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

1
    enum WEEK{
2
        Monday=1,
3
        Tuesday,
4
        Wednesday,
5
        Thursday,
6
        Friday,
7
        Saturday,
8
        Sunday
9
    }
10

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

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

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

1
基础数据类型 *变量名

1
int *p0;
2
short *p1;
3
long *p2;
4
char *p3;
5
float *p4;

1
struct TEST{
2
    int a,b;
3
};
4
TEST* p0;

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

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

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

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

5
a=22
6
p=000000000062FE44  //同上
7
*p=22