├── .github └── ISSUE_TEMPLATE │ └── -----.md ├── .vscode └── launch.json ├── 18-C-Train-L.md ├── 18-C-Train-W ├── 18-C-Train-T.md ├── 18-C-Train-W-1.md ├── 18-C-Train-W-2.md ├── Pictures │ ├── train.jpg │ ├── train.png │ ├── train10.png │ ├── train11.jpg │ ├── train12.jpg │ ├── train13.png │ ├── train14.png │ ├── train15.png │ ├── train16.png │ ├── train17.jpg │ ├── train19.gif │ ├── train2.png │ ├── train20.png │ ├── train21.png │ ├── train22.png │ ├── train23.png │ ├── train24.png │ ├── train25.png │ ├── train3.jpg │ ├── train4.png │ ├── train5.jpg │ ├── train6.jpg │ ├── train7.png │ ├── train8.png │ └── train9.png └── code.md ├── C-语言-考核题目.md ├── README.md └── img ├── 1.jpg ├── 2.jpg ├── 3.jpg └── 4.jpg /.github/ISSUE_TEMPLATE/-----.md: -------------------------------------------------------------------------------- 1 | --- 2 | name: 名字 题目 3 | about: 为了统一 issue 格式，请将“名字 题目”进行替换，表示你完成的题目～ 4 | 5 | --- 6 | 7 | # 题目名称 8 | 9 | ```C 10 | // Your code here 11 | ``` 12 | 13 | [提示]:tips "为了统一 issue 格式，大家最好按格式填写和替换～" 14 | [提示]:tips "当然，最优雅的方式就是开一个 issue，多次提交你的代码，格式同上，那么 title 就只写你的名字就好了～" 15 | -------------------------------------------------------------------------------- /.vscode/launch.json: -------------------------------------------------------------------------------- 1 | { 2 | // 使用 IntelliSense 了解相关属性。 3 | // 悬停以查看现有属性的描述。 4 | // 欲了解更多信息，请访问: https://go.microsoft.com/fwlink/?linkid=830387 5 | "version": "0.2.0", 6 | "configurations": [ 7 | { 8 | "name": "(Windows) Launch", 9 | "type": "cppvsdbg", 10 | "request": "launch", 11 | "program": "enter program name, for example ${workspaceFolder}/a.exe", 12 | "args": [], 13 | "stopAtEntry": false, 14 | "cwd": "${workspaceFolder}", 15 | "environment": [], 16 | "externalConsole": true 17 | } 18 | ] 19 | } -------------------------------------------------------------------------------- /18-C-Train-L.md: -------------------------------------------------------------------------------- 1 | > 本次培训采用C99标准 2 | # Hello World 3 | - #### 你好，世界！ 4 | ``` C 5 | #include // 包含另一个文件 6 | 7 | /* 这是一个简单的演示程序 */ 8 | int main() // 函数名 9 | { // 函数体开始 10 | int num; // 声明 11 | num = 1; // 赋值表达式语句 12 | printf("Hello World\n"); // 调用函数 13 | return 0; // return 语句 14 | } // 结束 15 | ``` 16 | - #### 程序细节 17 | - `#include`：这行代码是C语言预编译指令 18 | - `int main()函数`：C语言程序一定是从`main()`函数开始执行，并且一个项目只能有一个`main`函数。 19 | - `void main()`：注意，一些编译器允许这样写，但是所有的标准都未认可这种写法。而`int main()`是标准写法，使用标准写法，在将程序从一个编译器切换到另一个编译器时一般不会出现什么问题。 20 | - `/* ... */`：这是C语言中的注释，它允许同时注释多行。对于单行注释也可使用`//`。 21 | - `{ ... }`：这是花括号，一般而言，所有C函数都要使用花括号标记函数体的开始和结束。 22 | - `int num`：这是声明，声明一个变量一般形式是`关键字 标识符`，例如`char str`。 23 | - `num = 1`：赋值表达式语句。 24 | - `printf()`：这是C语言的一个标准输出函数。括号中的`Hello World\n`是这个函数的`实际参数`。 25 | - `return 0`：C语言标准中，要求main()函数返回0。但如果省略不写这一句呢？程序在运行至最外面的右花括号时会返回0。因此，可以省略main()函数的`return`语句，但是不要在其他有返回值的函数中漏掉它。强烈建议读者养成在main()函数中保留`return`语句的好习惯。 26 | 27 | - #### 代码编写规范 28 | - 标识符命名规范：标识符只能由字母、数字和下划线组成，并且第一个字符必须是字母或下划线 29 | - 变量名应该有具体含义 30 | - 每条语句占一行 31 | - 对齐缩进4个空格字符 32 | - ... 33 | 34 | 35 | # 数据类型 36 | - #### C数据类型 37 | ![type](https://github.com/android-nuc/17-C-Train/raw/master/image/c_language.png) 38 | 39 | - #### 什么是位、字节和字 40 | > 位、字节和字是描述计算机数据单元或存储单元的术语。
41 | > 最小的存储单元是位(bit)，可以储存0或1.虽然1位储存的信息有限，但是计算机中位的数量十分庞大。位是计算机内存的基本构建块。
42 | > 字节(byte)是常用的计算机存储单位。对于几乎所有的机器，1字节均为8位。这是字节的标准定义，至少在衡量存储单位时是这样。既然1位可以表示0或1，那么8位字节就有256（2的8次方）种可能的0、1组合。通过二进制编码（仅用0和1便可表示数字），便可表示0~255的整数或一组字符。
43 | > 字(word)是设计计算机时给定的自然存储单位，对于8位的微型计算机（如，最初的苹果机），1个字长只有8位。从那以后，个人计算机字长增至16位、32位，直到目前的64位，计算机的字长越大，其数据转移越快，允许的内存访问也快的多。
44 | > ————《C Primer Plus》 45 | 46 | `注意：C语言把1字节定义为char类型占用的位(bit)数。通常，char类型被定义为8位的存储单元。` 47 | 48 | - #### 整数类型 49 | 50 | |类型|存储大小|值范围| 51 | |-|-|-| 52 | |`char`|1 byte|`-128 到 127 或 0 到 255`| 53 | |unsigned char|1 byte|0 到 255| 54 | |signed char|1 byte|-128 到 127| 55 | |int|2 或 4 bytes|-32,768 到 32,767 或 -2,147,483,648 到 2,147,483,647| 56 | |unsigned int|2 或 4 bytes|0 到 65,535 或 0 到 4,294,967,295| 57 | |short|2 bytes|-32,768 到 32,767| 58 | |unsigned short|2 bytes|0 到 65,535| 59 | |long|4 bytes|-2,147,483,648 到 2,147,483,647| 60 | |unsigned long|4 bytes|0 到 4,294,967,295| 61 | 62 | 不同平台上数据类型的取值范围有所差异，为了得到某个类型或某个变量在特定平台上的准确大小，可以使用`sizeof`运算符，得到对象或类型的存储字节大小。 63 | 64 | ``` C 65 | #include 66 | 67 | int main() 68 | { 69 | printf("Storage size for int : %d \n", sizeof(int)); 70 | return 0; 71 | } 72 | ``` 73 | 输出： 74 | ``` 75 | Storage size for int : 4 76 | ``` 77 | 按照1个字节8位计算，那4个字节能够存储$2^{4*8}$，即$2^{32} = 4294967296$，正负数各分一半，也就是-2,147,483,648 到 2,147,483,647。 78 | 79 | 80 | 81 | - #### 浮点类型 82 | 83 | 类型|存储大小|值范围|精度 84 | |-|-|-|-| 85 | float|4 byte|1.2E-38 到 3.4E+38|6 位小数 86 | double|8 byte|2.3E-308 到 1.7E+308|15 位小数 87 | long double|10 byte|3.4E-4932 到 1.1E+4932|19 位小数 88 | 89 | - #### 基本数据类型所占字节数与三个方面因素有关 90 | - CPU位宽（即你的CPU是多少为的） 91 | - 操作系统位宽（笼统说就是操作系统位数，操作系统位宽取决于CPU位宽） 92 | - 编译器类型和版本 93 | 94 | - #### 整型溢出 95 | 96 | 97 | - EX.1
98 | 计算机中的计算只有二进制加法。因此，计算机在计算时实际上是取它们的补码进行加法运算。 99 | ``` C 100 | unsigned int a; 101 | int b = -1; 102 | a = b; 103 | printf("a=%u",a); 104 | ``` 105 | 输出： 106 | ``` 107 | a=4294967295 108 | ``` 109 | 让我们来分析一下，
110 | 首先int型的-1，对应二进制
111 | 取原码：`1000000000000000000000000000001`
112 | 取反码：`1111111111111111111111111111110`
113 | 取补码：`1111111111111111111111111111111`
114 | 而`unsigned int`型最大值对应的补码也是它，因此在赋值给`a`后，就得到了它的最大值。 115 | 116 | - EX.2
117 | 如果整数超出了相应类型的取值范围会怎样？ 118 | ``` C 119 | #include 120 | 121 | int main() 122 | { 123 | int i = 2147483647; 124 | unsigned int j = 4294967295; 125 | printf("%d %d %d\n", i, i+1, i+2); 126 | printf("%u %u %u\n", j, j+1, j+2); 127 | 128 | return 0; 129 | } 130 | ``` 131 | 输出： 132 | ``` 133 | 2147483647 -2147483648 -2147483647 134 | 4294967295 0 1 135 | ``` 136 | 从输出结果不难发现，当达到它们能表示的最大值时，会重新从起点开始。只不过`unsigned int`最小值为0，而`int`型最小值为-2147483648。 137 | 138 | [关于原码、反码和补码更多介绍](https://www.cnblogs.com/zhangziqiu/archive/2011/03/30/ComputerCode.html) 139 | 140 | # 明示常量：#define 141 | 编译时，在预处理阶段，预处理器会查找一行中以`#`号开始的预处理指令。预处理指令从`#`号开始执行，到后面的第一个换行符为止。也就是说，指令的长度仅限于一行（逻辑行）。 142 | 143 | - **类对象宏** 144 | ![obj](img/1.jpg) 145 | 146 | 宏的名称同样需要遵守C变量的命名规则：只能使用字符、数字和下划线，且首字符不能是数字。
147 | 可以把它看做是一种记号，程序在编译时会把记号替换为它对应的值。 148 | 149 | 例子： 150 | ``` C 151 | #include 152 | #define WORD "Hello World!" 153 | #define OP 6+6 154 | #define LINE 10 155 | 156 | int main() 157 | { 158 | char str[15] = WORD; 159 | int sum = OP; 160 | 161 | for(int i = 0; i < LINE; i++) 162 | { 163 | printf("%d\t%s\t%d\n", i, str, sum); 164 | } 165 | 166 | return 0; 167 | } 168 | ``` 169 | 170 | - **类函数宏**
171 | 类函数宏可以像函数那样传入参数，它的组成如下 172 | 173 | ![2](img/2.jpg) 174 | 175 | 例子： 176 | ``` C 177 | #include 178 | #define MEAN(X,Y) ((X)+(Y))/2 179 | 180 | int main() 181 | { 182 | int mean = MEAN(10, 20); 183 | printf("%d", mean); 184 | 185 | return 0; 186 | } 187 | ``` 188 | - 注意：`预处理器不做计算、不求值、只替换字符序列`！！ 189 | 190 | ``` C 191 | #include 192 | #define SQUARE(X) X*X 193 | 194 | int main() 195 | { 196 | int x = 5; 197 | printf("%d\n", SQUARE(x)); 198 | printf("%d\n", SQUARE(x+2)); 199 | printf("%d\n", 100/SQUARE(2)); 200 | 201 | return 0; 202 | } 203 | ``` 204 | 预处理器仅仅是在编译时替换了字符序列，所以在写替换体时，一定要注意参数的作用范围。此处出现的问题可以通过添加括号解决：`(X)*(X)`。 205 | 206 | - **常用的宏** 207 | ``` C 208 | #define MAX(X,Y) ((X) > (Y) ? (X) : (Y)) 209 | #define ABS(X) ((X) < 0 ? -(X) : (X)) 210 | #define ISSIGN(X) ((X) == '+' || (X) == '-' ? 1 : 0) 211 | ``` 212 | 再次强调，宏只是在程序编译时，替换掉记号位置的字符序列。 213 | 214 | # 常用运算符 215 | - 常用运算符 216 | 217 | 赋值|自增自减|算术|逻辑|比较|成员访问|其他 218 | |:-:|:-:|:-:|:-:|:-:|:-:|:-:| 219 | a = b
a += b
a -= b
a *= b
a /= b
a %= b
a &= b
a |= b
a ^= b
a <<= b
a >>= b|++a
--a
a++
a--
|+a
-a
a + b
a - b
a * b
a / b
a % b
~a
a & b
a | b
a ^ b
a << b
a >> b
|!a
a && b
a || b
|a == b
a != b
a < b
a > b
a <= b
a >= b
|a[b]
*a
&a
a->b
a.b
|a(...)
a, b
(type) a
? :
sizeof
_Alignof (C11 起) 220 | 221 | [关于C运算符优先级](https://zh.cppreference.com/w/c/language/operator_precedence) 222 | - 位运算符 223 | 224 | |运算符|含义|描述| 225 | |-|-|-| 226 | |&|按位与|如果两个相应的二进制位都为1，则该位的结果值为1，否则为0| 227 | |||按位或|两个相应的二进制位中只要有一个为1，该位的结果值为1| 228 | |^|按位异或|若参加运算的两个二进制位值相同则为0，否则为1| 229 | |~|取反|~是一元运算符，用来对一个二进制数按位取反，即将0变1，将1变0| 230 | |<<|左移|用来将一个数的各二进制位全部左移N位，右补0| 231 | |>>|右移|将一个数的各二进制位右移N位，移到右端的低位被舍弃，对于无符号数，高位补0| 232 | 233 | 234 | - `i++`与`++i` / `i--`与`--i` 235 | - ++ 在前面叫做前自增（例如 ++a）。前自增先进行自增操作，再进行其他操作。 236 | - ++ 在后面叫做后自增（例如 a++）。后自增先进行其他操作，再进行自增操作。 237 | - 自增自减完成后，会用新值替换旧值，并将新值保存在当前变量中。 238 | - 自增自减只能针对变量，不能针对数字。 239 | 240 | 例子： 241 | ``` C 242 | #include 243 | 244 | int main() 245 | { 246 | int a = 5; 247 | printf("%d\n", ++a); 248 | printf("%d\n", a++); 249 | 250 | return 0; 251 | } 252 | ``` 253 | - `sizeof` 254 | - 它以字节为单位返回运算对象的大小。 255 | - 对于实值，可省略括号，其他情况不能省略括号。 256 | - 根据代码的一致性，建议在所有情况下都不要省略括号。 257 | ``` C 258 | #include 259 | 260 | int main() 261 | { 262 | int a = 5; 263 | printf("%d\n", sizeof a); 264 | printf("%d\n", sizeof int); // 报错 265 | printf("%d\n", sizeof(int)); 266 | 267 | return 0; 268 | } 269 | ``` 270 | 271 | # printf()和scanf() 272 | 这两个函数都采用格式化输入输出，每种数据类型都要使用它对应`转换说明`才能正常输入输出。例如整数要用`%d`，字符要用`%c`。这些符号称为`转换说明`，它们指定了如何把数据转换成可显示的格式。 273 | 274 | ### printf() 275 | - 转换说明及其打印的输出结果 276 | 277 | 转换说明|输出 278 | |-|-| 279 | %a,%A|浮点数、十六进制数和p计数法(C99/C11) 280 | %c|一个字符 281 | %d|有符号十进制数 282 | %e,%E|浮点数,e计数法 283 | %f|浮点数，十进制计数法 284 | %g,%G|根据数值不同自动选择%f或%e, %e格式在指数小于-4或者大于等于精度时使用 285 | %i|有符号十进制整数(与%d相同) 286 | %o|无符号八进制整数 287 | %p|指针 288 | %s|字符串 289 | %u|无符号十进制数 290 | %x,%X|使用十六进制数0f的无符号十六进制整数 291 | %%|打印一个百分号 292 | 293 | - 有时字符串比较长，需要放在多行 294 | ``` C 295 | #include 296 | 297 | int main() 298 | { 299 | printf("Do not believe what is passed from mouth; \ 300 | Do not believe rumors ; Do not believe the \ 301 | infallibility of texts") ; 302 | 303 | return 0; 304 | } 305 | ``` 306 | 307 | ### scanf() 308 | scanf()函数使用空白（换行符、制表符和空格）把输入分成多个字段。在依次把转换说明和字段匹配时跳过空白。 309 | > `%c转换说明`:它是一个例外，它会读取每个字符，包括空白。 310 | 311 | - #### 格式字符串中的普通字符 312 | scanf()函数允许把普通字符放在格式字符串中，这个时候要求，除空格字符外的普通字符必须与输入字符串严格匹配。例如 313 | ``` C 314 | printf("%d,%d,%d", &a, &b, &c); 315 | ``` 316 | 那么它对应的输入必须是这种格式 317 | ``` 318 | 1,2,3 319 | ``` 320 | 321 | - #### 细化scanf()输入 322 | ![4](img/4.jpg) 323 | - 假设scanf()根据一个%d转换说明读取一个整数。 324 | 325 | scanf()函数每次读取一个字符，跳过所有空白字符，直至遇到第1个非空白字符才开始读取。scanf()不断地读取和保存字符，直至遇到非数字字符。如果遇到非数字字符，它便认为到了整数的末尾。然后scanf()把非数字字符放回输入。 326 | 327 | - 如果第1个非空白字符(记为A)不是数字会怎么样？ 328 | 329 | scanf()将会停在那里，并把A放回输入中，不会把值赋给指定变量。程序在下一次读取输入时，首先读到的字符是A。如果程序只用了%d转换说明，那么scanf()就一直无法越过A读取下一个字符。另外，如果使用带了`多个`转换说明的scanf()，C规定在第1个出错出停止读取输入。 330 | 331 | - %s: 332 | 333 | scanf()会跳过空白，读取非空白字符，也就是说通过`%s`读取的字符串不含空白。需要注意的是，当scanf()把字符串放进指定数组中时，它会在字符序列的末尾加上`\0`。 334 | 335 | - #### scanf()的返回值 336 | scanf()函数返回成功读取的项数。如果没有任何读取项，且需要读取一个数字而用户却输入一个非数值字符串，scanf()便返回0。当检测到“文件结尾”时，会返回`EOF`。
337 | 例子： 338 | ``` C 339 | #include 340 | 341 | int main() 342 | { 343 | char a[20]; 344 | int sign, b, c; 345 | while(true) 346 | { 347 | sign = scanf("%s %d %d", a, &b, &c); 348 | printf("返回:%d\n", sign); 349 | } 350 | 351 | return 0; 352 | } 353 | ``` 354 | 355 | 由此可作为输入时的循环条件 356 | ``` C 357 | while (~scanf("%d %d",&n,&m)) 等效于 while (scanf("%d %d",&n,&m) != EOF) 358 | ``` 359 | 360 | - #### 其他输入输出 361 | - getchar() 362 | - putchar() 363 | - gets() 364 | - puts() 365 | 366 | 367 | # 分支语句 368 | - #### if 369 | > **形式：** 370 | > ``` C 371 | > if ( expression2 ) 372 | > statement1 373 | > else if ( expression2 ) 374 | > statement2 375 | > else 376 | > statement3 377 | > ``` 378 | > 如果expression1为真，执行statement1部分；如果expression2为真，执行statement2部分；否则，执行statement3部分 379 | 380 | - 在写条件时，注意优先级。例如下面错误的判断是否为字母 381 | ``` C 382 | if(ch >= 'a' && ch <= 'z' || ch >= 'A' && ch <= 'Z') 383 | { 384 | printf("is alphabet") 385 | } 386 | ``` 387 | 388 | - #### 三元运算符：? : 389 | > 条件运算符需要3个运算对象，每个运算对象都是一个表达式。 390 | > *expression1* ? *expression2* : *expression3* 391 | > 如果*expression1*为真，整个条件表达式的值是*expression2*的值；否则，是*expression3*的值。 392 | 393 | 它可以与`if else`等效，例如 394 | ``` C 395 | x = (y < 0) ? -y : y; 396 | 397 | // 等效于 398 | if (y < 0) 399 | x = -y; 400 | else 401 | x = y; 402 | ``` 403 | 404 | - #### 多重选择：switch语句 405 | > **形式：** 406 | > ``` C 407 | > switch( expression ) 408 | > { 409 | > case label1: statement1 // 使用break跳出switch 410 | > case label2: statement2 411 | > default: statement3 412 | > } 413 | > ``` 414 | > 可以有多个标签语句，default语句可选。
415 | > **注解：**
416 | > 程序根据expression的值跳转至相应的case标签处，然后，执行剩下的所有语句，除非执行到break语句进行重定向。expression和case标签都必须是整数值（包括char类型），标签必须是常量或完全由常量组成的表达式，如果没有case标签与expression的值匹配，控制则转至标有default的语句（如果有的话）；否则，将转至执行紧跟在wwitch语句后面的语句。 417 | 418 | - EX：统计一段话中元音字母个数。 419 | ``` C 420 | #include 421 | 422 | int main() 423 | { 424 | int count = 0; 425 | char ch; 426 | while((ch = getchar()) != '\n') 427 | { 428 | switch(ch) 429 | { 430 | case 'a': 431 | case 'A': 432 | count++; 433 | break; 434 | case 'e': 435 | case 'E': 436 | count++; 437 | break; 438 | case 'i': 439 | case 'I': 440 | count++; 441 | break; 442 | case 'o': 443 | case 'O': 444 | count++; 445 | break; 446 | case 'u': 447 | case 'U': 448 | count++; 449 | break; 450 | } 451 | } 452 | printf("count: %d", count); 453 | 454 | return 0; 455 | } 456 | ``` 457 | 458 | 459 | # 循环语句 460 | 461 | ### 入口条件循环 462 | 顾名思义，入口条件循环就是在循环的每次迭代之前检查测试条件，所以它有可能根本不执行循环体中的内容。 463 | - #### while循环 464 | > **形式:** 465 | > ``` C 466 | > while( expression ) 467 | > statement 468 | > ``` 469 | > 在*expression*部分为假之前，重复执行*statement*部分。 470 | 471 | 循环输入的例子： 472 | ``` C 473 | #include 474 | 475 | int main() 476 | { 477 | char ch; 478 | while(scanf("%c", &ch) != EOF) 479 | { 480 | if(ch >= '0' &&ch <= '9') 481 | printf("%c", ch); 482 | } 483 | 484 | return 0; 485 | } 486 | ``` 487 | - **何为真假？**
488 | 在C语言中这个很好判断，不为0的数就是`真`，即-1,-1000,1,100都为真。只有0为`假`。
布尔型的`True == 1`、`False == 0`。 489 | - EX.1：若成功输入，预测下面代码执行结果。 490 | ``` C 491 | #include 492 | 493 | int main() 494 | { 495 | int num, status; 496 | int sum = 0; 497 | 498 | status = scanf("%d", &num); 499 | 500 | while(status = 1) 501 | { 502 | sum += num; 503 | if(sum >= 10) 504 | status = 0; 505 | } 506 | printf("%d", sum); 507 | 508 | return 0; 509 | } 510 | ``` 511 | 出现了死循环，`while(status = 1)`实际上相当于`while(1)`，此时入口条件永为真。
512 | 这种错误，程序在编译时，编译器一般不会报错（现代编译器会发出警告），为避免出现这种误用情况，经验丰富的程序员一般会把数写在等号左边，这样如果出现误写，在编译时会报错。 513 | ``` C 514 | 1 = status // 语法错误 515 | 1 == status // 返回真假 516 | ``` 517 | 518 | - **空语句**
519 | 在C语言中，单独的分号表示空语句。有时程序员会故意使用带空语句的while语句，例如，假设你想跳过输入到第1个非空白字符或数字，可以这样写。 520 | ``` C 521 | while(scanf("%d", &num) == 1) 522 | ; // 跳过整数输入 523 | ``` 524 | 防止误用空语句。以下是常见的几种误用，大括号中的语句仅执行了一次 525 | ``` C 526 | int i = 0; 527 | while(i > 5); 528 | { 529 | i++; 530 | printf("%d", i); 531 | } /* 输出：1*/ 532 | 533 | 534 | int i; 535 | for(i = 0; i < 5; i++); 536 | { 537 | printf("%d", i); 538 | } /* 输出：5*/ 539 | 540 | 541 | int i = 5; 542 | if(i > 999); 543 | { 544 | printf("%d", i); 545 | } /* 输出：5*/ 546 | ``` 547 | 548 | - #### for循环 549 | for循环把初始化、测试和更新三个行为组合在了一处。 550 | > **形式：** 551 | > ``` C 552 | > for ( initialize; test; update ) 553 | > statement 554 | > ``` 555 | > 在*test*为假或0之前，重复执行*statement*。
556 | > **注解：**
557 | > for语句使用3个表达式控制循环过程，分别用分号隔开。initialize表达式在执行for语句之前只执行一次；然后对test表达式求值，如果表达式为真（或非零），执行循环一次；接着对update表达式求值，并再次检查test表达式。for语句是一种入口条件循环，即在执行循环之前就决定了是否执行循环。因此，for循环可能一次都不执行，statement部分可以是一条简单语句或复合语句。 558 | 559 | - 输出1到200的奇数，十个为一行 560 | ``` C 561 | #include 562 | 563 | int main() 564 | { 565 | int i; 566 | for (i = 1; i <= 200; i+=2) 567 | { 568 | printf("%d", i); 569 | printf("%c", (i + 1) % 20 ? '\t': '\n' ); 570 | } 571 | 572 | return 0; 573 | } 574 | ``` 575 | 576 | - #### 逗号运算符 577 | > 逗号运算符把两个表达式连接成一个表达式，并保证最左边的表达式最先求值，逗号运算符通常在for循环头的表达式中用于包含更多的信息。整个逗号表达式的值是逗号右侧表达式的值。 578 | 579 | 上个例子还可以这样写。 580 | ``` C 581 | #include 582 | 583 | int main() 584 | { 585 | int i, k; 586 | for (i = 1, k = 1; i <= 200; i+=2, k++) 587 | { 588 | printf("%d", i); 589 | if(k % 10 == 0) 590 | printf("\n"); 591 | else 592 | printf("\t"); 593 | } 594 | 595 | return 0; 596 | } 597 | ``` 598 | - 防止误用逗号运算符
599 | 举个例子，假如你正在给一个表示房价的变量赋值，它在书上表示的是`$295,500`，然后你在输入的时候，不小心把逗号也输入进去了。 600 | ``` C 601 | houseprice = 259,500; 602 | ``` 603 | 结果是houseprice的值被赋为了500。这不是语法错误，C编译器会将其解释为一个逗号表达式。以逗号为分隔，`500`成了一条语句，由于它位于表达式的最右侧，所有就是这个表达式的值。 604 | 605 | - #### while or for 606 | 这两个循环可以做到互相等价，例如： 607 | ``` C 608 | for(; test ; ){} 609 | 610 | /* 等效于 */ 611 | while (test){} 612 | ``` 613 | ``` C 614 | 初始化; 615 | while( 测试 ) 616 | { 617 | 其他语句 618 | 更新语句 619 | } 620 | 621 | /* 等效于 */ 622 | for( 初始化; 测试 ; 更新 ) 623 | 其他语句 624 | 625 | ``` 626 | 一般而言，当循环涉及初始化和更新变量时，用for循环比较合适，而在其他情况下用while循环更好。 627 | 628 | ### 出口条件循环：do while 629 | 出口条件循环，即在循环的每次迭代之后检查测试条件，这保证了至少执行循环体中的内容一次。 630 | > **形式：** 631 | > ```C 632 | > do 633 | > statement 634 | > while( expression ); 635 | > ``` 636 | > 在*test*为假或0之前，重复执行statement部分 637 | 638 | - 验证密码 639 | ``` C 640 | #include 641 | #define PASSWORD 123456 642 | 643 | int verify_password(int num) 644 | { 645 | if(num == PASSWORD) 646 | return 0; 647 | else 648 | return 1; 649 | } 650 | 651 | int main() 652 | { 653 | int password; 654 | do 655 | { 656 | printf("Please enter password:"); 657 | scanf("%d", &password); 658 | } 659 | while(verify_password(password)); 660 | printf("success!"); 661 | 662 | return 0; 663 | } 664 | ``` 665 | 666 | - #### 跳出循环 667 | - `continue`：**结束本次**循环，进行下一次循环 668 | - `break`：**终止**循环不再进行 669 | 670 | 671 | ### 函数 672 | 代码示例： 673 | ``` C 674 | #include 675 | 676 | int max(int, int); // 函数原型 677 | 678 | int main() 679 | { 680 | int a, b, num; 681 | scanf("%d %d", &a, &b); 682 | num = max(a, b); // 函数调用 683 | printf("%d", num); 684 | 685 | return 0; 686 | } 687 | 688 | int max(int a, int b) // 函数定义 689 | { 690 | return a > b ? a : b; // 返回int类型的值 691 | } 692 | ``` 693 | - 什么是函数签名？
694 | 函数的返回类型和形参列表构成了函数签名。因此函数签名指定了传入函数的值的类型和函数值的类型。 695 | 696 | - 函数原型的作用
697 | 之所以使用函数原型，是为了让编译器在第1此执行到该函数之前就知道如何使用它。
既然是告知编译器如何使用它，那么肯定有等效的方法能省略它。例如上面的代码 698 | ``` C 699 | int max(int a, int b) // 函数定义 700 | { 701 | return a > b ? a : b; // 返回int类型的值 702 | } 703 | 704 | int main() 705 | { 706 | int a, b, num; 707 | scanf("%d %d", &a, &b); 708 | num = max(a, b); // 函数调用 709 | printf("%d", num); 710 | 711 | return 0; 712 | } 713 | ``` 714 | 只需要在调用子函数之前，让编译器知道它的存在即可。 715 | 716 | - 同名函数
717 | 在支持ANSI C的编译器下，可以使用相同的名称命名多个函数，只要它的函数签名不同即可。注意在g++编译器下，不允许这样的操作。 718 | 举个例子： 719 | ``` C 720 | #include 721 | 722 | int max(int, int); // 函数原型 723 | char max(char, char); 724 | 725 | int main() 726 | { 727 | int a, b; 728 | char ch1, ch2; 729 | 730 | scanf("%d %d", &a, &b); 731 | printf("max: %d\n\n", max(a, b)); 732 | 733 | getchar(); // 读取换行 734 | scanf("%c %c", &ch1, &ch2); 735 | printf("char is %c and %c\n", ch1, ch2); 736 | printf("max: %c\n", max(ch1, ch2)); 737 | 738 | return 0; 739 | } 740 | 741 | int max(int a, int b) // 函数定义 742 | { 743 | return a > b ? a : b; // 返回int类型的值 744 | } 745 | 746 | char max(char a, char b) 747 | { 748 | return a > b ? a : b; 749 | } 750 | ``` 751 | - #### 了解：与指针相关的运算符 752 | > **地址运算符：&** 753 | > **注解**：后跟一个变量名时，&给出该变量的地址 754 | > **示例**：&house表示变量house的地址。 755 | 756 | > **地址运算符：*** 757 | > **注解**：后跟一个指针名或地址时，*给出储存在指正指向地址上的值。 758 | > **示例**：
759 | > ``` C 760 | > house = 22; 761 | > ptr = &house; // 指向house指针 762 | > value = *ptr; // 把ptr指向的地址上的值赋给value 763 | > ``` 764 | 765 | - #### 引用 766 | 函数的形参如果是地址，可以称为引用变量。此时修改形参的值，将会直接影响实参的值。 767 | 举个例子 768 | ``` C 769 | #include 770 | 771 | void find_max(int a, int b, int &max) 772 | { 773 | max = a > b ? a : b; 774 | } 775 | 776 | int main() 777 | { 778 | int a, b, max; 779 | scanf("%d %d", &a, &b); 780 | find_max(a, b, max); 781 | printf("max: %d\n", max); 782 | 783 | return 0; 784 | } 785 | ``` 786 | 在子函数中给`max`变量赋值，也会直接影响main函数中的max的值。 787 | 788 | - #### 返回指针 789 | ``` C 790 | #include 791 | 792 | char *input() 793 | { 794 | char str[20]; 795 | scanf("%s", str); 796 | return &str[0]; 797 | } 798 | 799 | int main() 800 | { 801 | char *str = input(); 802 | printf("%s", str); 803 | 804 | return 0; 805 | } 806 | ``` 807 | - 思考：如果一个子函数，有多个同类型的值要返回怎么办呢？ 808 | 809 |
810 | 811 | 812 | 813 | 814 | -------------------------------------------------------------------------------- /18-C-Train-W/18-C-Train-T.md: -------------------------------------------------------------------------------- 1 | # 18-C-Train-Test 2 | 3 | + 使用指针交换两个整数变量的值，并写成函数形式，即实现void swap(int *a, int *b)函数 4 | 5 | ```c 6 | void swap(int *a,int b) 7 | { 8 | int temp; 9 | temp = *a; 10 | *a = *b; 11 | *b = temp; 12 | } 13 | ``` -------------------------------------------------------------------------------- /18-C-Train-W/18-C-Train-W-1.md: -------------------------------------------------------------------------------- 1 | # C Train For 18 2 | 3 | ## 大一C语言培训 (中) 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 | + 一次性获取用用户输入的十个整数，然后对每一个数据做平方处理然后输出，一般情况下，既然要一次获取10个整数,那么就必须定义十个变量来储存这是个数据，代码看起来已经非常的麻烦了，如果数量更大的话，就会更麻烦了，比如以下代码 43 | 44 | ```c 45 | int main() 46 | { 47 | int i1,i2,i3,i4 ... i10; 48 | scanf("%d%d%d ... %d",&i1,&i2,&i3 ... &i10); 49 | i1 *= i1; 50 | i2 *= i2; 51 | 52 | ..... 53 | 54 | printf("%d%d%d.....%d",i1,i2,i3....i10); 55 | } 56 | ``` 57 | 58 | + 为了对这种大量数据进行处理，C语言引进了数组 59 | 60 | ### 数组的定义和使用 61 | 62 | #### 定义数组 63 | 64 | + 在 C 中要声明一个数组，需要指定元素的类型和元素的数量，使用数组前，需要先定义数组，定义数组的格式如下： 65 | 66 | ```c 67 | 数据类型 数组名 [整形常量表达式], ... 68 | type arrayName [ arraySize ]; 69 | ``` 70 | 71 | + 数组由数据类型相同的一系列元素组成，需要使用该数组时，通过声明数组告诉编译器数组中含有多少元素和这些元素的类型，编译器根据这些信息正确的创建数组 ，例如： 72 | 73 | ```c 74 | int main() 75 | { 76 | float candy[365] /*内含有365个float类型元素的数组 */ 77 | char code[20]; /*内含有20个char类型元素的数组 */ 78 | int book[50]; /*内含有50个int类型元素的数组 */ 79 | } 80 | ``` 81 | 82 | #### 初始化数组 83 | 84 | + 数组的声明并不是声明一个个单独的变量，比如 number0、number1、...、number99，而是声明一个数组变量，比如 numbers 85 | + 如下代码所示，用以逗号分割的数值列表 (用花括号括起来) 来初始化数组 86 | 87 | ```c 88 | int main() 89 | { 90 | int numbers[8] = {1,2,4,5,7,9,12,435}; 91 | } 92 | ``` 93 | 94 | + 大括号 { } 之间的值的数目不能大于我们在数组声明时在方括号 [ ] 中指定的元素数目。如果你省略掉了数组的大小，数组的大小则为初始化时元素的个数。因此，如果执行以下的代码 将创建一个数组，它与前一个实例中所创建的数组是完全相同的。 95 | 96 | ```c 97 | double balance[] = {1000.0, 2.0, 3.4, 7.0, 50.0}; 98 | ``` 99 | 100 | 创建完的数组balance在内存中的结构： 101 | 102 |
103 | 104 | ![array_presentation.jpg](https://upload-images.jianshu.io/upload_images/9140378-1c77919410172241.jpg?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240) 105 | 106 |
107 | 108 | + 或者利用数组的下标进行赋值 109 | 110 | ```c 111 | //下面是一个为数组中某个元素赋值的实例： 112 | 113 | numbers[4] = 50.0; 114 | 115 | //下面是为数组的所有元素进行赋值 116 | 117 | int main() 118 | { 119 | int num[5]; 120 | for(int i = 0;i < 4;i ++) 121 | num[i] = i + 1; 122 | } 123 | ``` 124 | 125 | 创建完的数组的结构： 126 | 127 |
128 | 129 | ![train4.png](https://upload-images.jianshu.io/upload_images/9140378-67efb5f61143edf0.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/440) 130 | 131 |
132 | 133 | #### 通过数组下标访问数组的数值 134 | 135 | + 如下图所示，使用 numbers[0]、numbers[1]、...、numbers[99] 来代表一个个单独的变量。数组中的特定元素可以通过索引访问。所有的数组都是由连续的内存位置组成。最低的地址对应第一个元素，最高的地址对应最后一个元素。，数组的首位置的下标一定是0,下标的最大值一定是数组的长度 - 1 136 | 137 |
138 | 139 | ![train5.jpg](https://upload-images.jianshu.io/upload_images/9140378-a6be205a10460f5b.jpg?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240) 140 | 141 |
142 | 143 | + 数组边界 144 | 145 | 在访问数组元素时，要防止数组下标超出边界，也就是说，必须确保下标时有效的值，加入有下面的声明： 146 | 147 | ```c 148 | int bao[20]; 149 | ``` 150 | 151 | 那么在访问该数组时，要确保程序中使用的数组下标在 0 ~ 19 的范围内，因为编译器不会检查出这种错误，也就是说，编译运行照常通过，但看起来运行的结果很奇怪 152 | 假设我们访问数组下标以外的数值，例如： 153 | 154 | ```c 155 | #include "stdio.h" 156 | int main() 157 | { 158 | int lihao[3] = {1,2,3}; 159 | for(int i =0;i < 7;i ++) 160 | printf("%d\n",lihao[i]); 161 | return 0; 162 | } 163 | /* 164 | 1 165 | 2 166 | 3 167 | 3 168 | 11692832 169 | 0 170 | 4199400 171 | */ 172 | ``` 173 | 174 | + C是相信程序员能正确的编写程序，这样C可以运行的更快，所以访问数组时C是不检查边界的，但不是所有程序员可以做到这一点，所以才出现了这个数组下标越界的问题，所以建议大家在声明数组的时候使用符号常量来表达数组的大小 175 | 176 | ```c 177 | #define SIZE 4; 178 | int main() 179 | { 180 | int arr[SIZE]; 181 | for(int i = 0;i < SIZE;i ++) 182 | 183 | ... 184 | 185 | return 0; 186 | } 187 | ``` 188 | 189 | #### 数组的简单应用 190 | 191 | 两个经典的排序 192 | 193 | + 冒泡排序 194 | 195 |
196 | 197 | ![train7.png](https://upload-images.jianshu.io/upload_images/9140378-5eb8e56677da3aa4.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/350) 198 | 199 |
200 | 201 | + 比较相邻的元素。如果第一个比第二个大，就交换他们两个，就像把大的像泡泡一样“冒”到数组后面去 202 | + 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。 203 | + 针对所有的元素重复以上的步骤，除了最后一个。 204 | + 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。 205 | 206 | ```c 207 | int main() 208 | { 209 | int i = 0,j = 0; 210 | int a[10] = {3,1,4,1,5,9,2,6,5,4}; 211 | for(i = 0;i < 9;i ++) 212 | { 213 | int temp = 0; 214 | for(j = 0;j < 9 - i;j ++) 215 | { 216 | if(a[j] > a[j + 1]) 217 | { 218 | //将位置 j + 1 的数与位置j的数进行交换 219 | temp = a[j + 1]; 220 | a[j + 1] = a[j]; 221 | a[j] = temp; 222 | } 223 | } 224 | } 225 | for (i = 0;i < 10;i ++) 226 | printf("%d ",a[i]); 227 | return 0; 228 | } 229 | 230 | /* 231 | 1 1 2 3 4 4 5 5 6 9 232 | */ 233 | ``` 234 | 235 | [动态演示 -- 冒泡排序算法可视化](https://visualgo.net/zh/sorting) 236 | 237 | + 选择排序 238 | 239 |
240 | 241 | ![train8.png](https://upload-images.jianshu.io/upload_images/9140378-0c2f621c106a60ed.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/380) 242 | 243 |
244 | 245 | + 选择排序（从小到大）的基本思想是，首先，选出最小的数，放在第一个位置；然后，选出第二小的数，放在第二个位置；以此类推，直到所有的数从小到大排序。 246 | + 在实现上，我们通常是先确定第i小的数所在的位置，然后，将其与第i个数进行交换 247 | 248 | ```c 249 | #include "stdio.h" 250 | int main() 251 | { 252 | int i = 0,j = 0; 253 | int temp = 0; 254 | int a[10] = {3,1,4,1,5,9,2,6,5,4}; 255 | for(i = 0;i < 9;i ++) 256 | { 257 | int pos = 0; 258 | for(j = 1;j < 10 - i;j ++) 259 | if(a[pos] < a[j]) 260 | pos = j; 261 | if(pos != 9 - i) 262 | { 263 | temp = a[9 - i]; 264 | a[9 - i] = a[pos]; 265 | a[pos] = temp; 266 | } 267 | } 268 | for (i = 0;i < 10;i ++) 269 | printf("%d ",a[i]); 270 | return 0; 271 | } 272 | /* 273 | 1 1 2 3 4 4 5 5 6 9 274 | */ 275 | ``` 276 | 277 | [动态演示 -- 选择排序算法可视化](https://visualgo.net/zh/sorting) 278 | 279 | ### 多维数组 280 | 281 | #### 多维数组的声明 282 | 283 | C 语言支持多维数组。多维数组声明的一般形式如下： 284 | 285 | ```c 286 | type name[size1][size2]...[sizeN]; 287 | ``` 288 | 289 | 例如，下面的声明创建了一个三维 5 . 10 . 4 整型数组： 290 | 291 | ```c 292 | int threedim[5][10][4]; 293 | ``` 294 | 295 | ### 二维数组 296 | 297 | #### 初始化二维数组 298 | 299 | + 初始化可以使用一个 { } 里面包含有多个数据的方式，多个数据使用逗号进行分隔,例如： 300 | 301 | ```c 302 | 数据类型 数组名[整型常量][整形常量] = { {数据1,...} , {数据2,...}, {数据3,...}, ...}; 303 | 304 | int a[3][4] = { 305 | {0, 1, 2, 3}, /* 初始化索引号为 0 的行 */ 306 | {4, 5, 6, 7}, /* 初始化索引号为 1 的行 */ 307 | {8, 9, 10, 11} /* 初始化索引号为 2 的行 */ 308 | }; 309 | ``` 310 | 311 | + 数组的第一个下标可以直接由 “{ }” 里面的包含的 “{ }” 个数决定，所以完全可以省略第一个下标： 312 | 313 | ```c 314 | int a[][4] = { {0, 1, 2, 3}, {4, 5, 6, 7}, {8, 9, 10, 11} }; 315 | ``` 316 | 317 | + 虽然二维数组在概念上是二维的，有行和列，但在内存中所有的数组元素都是连续排列的，它们之间没有“缝隙”,以下面的二维数组 a 为例： 318 | 319 | ```c 320 | int a[3][4] = { {0, 1, 2, 3}, {4, 5, 6, 7}, {8, 9, 10, 11} }; 321 | ``` 322 | 323 | + 但在内存中，a 的分布是一维线性的，整个数组占用一块连续的内存： 324 | 325 |
326 | 327 | ![train3.jpg](https://upload-images.jianshu.io/upload_images/9140378-753dc9d279810b55.jpg?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240) 328 | 329 |
330 | 331 | + C语言中的二维数组是按行排列的，也就是先存放 a[0] 行，再存放 a[1] 行，最后存放 a[2] 行；每行中的 4 个元素也是依次存放。 332 | 333 |
334 | 335 | ![train11.jpg](https://upload-images.jianshu.io/upload_images/9140378-7445afc38122c969.jpg?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240) 336 | 337 |
338 | 339 | + 数组 a 为 int 类型，每个元素占用 4 个字节，整个数组共占用 4×(3×4) = 48 个字节。 340 | + C语言允许把一个二维数组分解成多个一维数组来处理。对于数组 a，它可以分解成三个一维数组，即 a[0]、a[1]、a[2]。每一个一维数组又包含了 4 个元素，例如 a[0] 包含 a[0][0]、a[0][1]、a[0][2]、a[0][3] 341 | 342 | + 假设数组 a 中第 0 个元素的地址为 1000，那么每个一维数组的首地址如下图所示： 343 | 344 |
345 | 346 | ![train9.png](https://upload-images.jianshu.io/upload_images/9140378-f382b296f8bf9418.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240) 347 | 348 |
349 | 350 | #### 为二维数组赋值并访问二维数组的元素 351 | 352 | + 二维数组中的元素也是通过使用下标（即数组的行索引和列索引）来访问的。例如： 353 | 354 | ```c 355 | int val = a[2][3]; 356 | ``` 357 | 358 | + 上面的语句将获取数组中第 3 行第 4 个元素。您可以通过上面的示意图来进行验证。让我们来看看下面的程序，我们将使用嵌套循环来处理二维数组： 359 | 360 | 首先定义一个二维数组 361 | 362 | ```c 363 | /* 一个带有 3 行 4 列的数组 */ 364 | int a[3][4]; 365 | ``` 366 | 367 | 二维数组的赋值 368 | 369 | + 使用循环的嵌套来从键盘录入数据 370 | 371 | ```c 372 | int i, j; 373 | for(i = 0;i < 3;i ++ ) 374 | { 375 | for(j = 0;j < 4;j ++) 376 | { 377 | scanf("%d",&a[i][j]); 378 | } 379 | } 380 | ``` 381 | 382 |
383 | 384 | ![train12.jpg](https://upload-images.jianshu.io/upload_images/9140378-a9894652810c62b5.jpg?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240) 385 | 386 |
387 | 388 | 二维数组的输出 389 | 390 | + 同样我们使用循环的嵌套来从输出数据 391 | 392 | ```c 393 | //输出具体数值 394 | for ( i = 0; i < 3; i++ ) 395 | { 396 | for ( j = 0; j < 4; j++ ) 397 | printf("%d ",a[i][j]); 398 | printf("\n"); 399 | } 400 | /* 401 | 1 2 3 4 402 | 3 4 5 6 403 | 5 6 7 8 404 | */ 405 | for ( j = 0; j < 4; j++ ) 406 | printf("a[%d][%d] = %d\n", i,j, a[i][j]); 407 | /* 408 | a[0][0] = 1 409 | a[0][1] = 2 410 | a[0][2] = 3 411 | a[0][3] = 4 412 | 413 | a[1][0] = 3 414 | a[1][1] = 4 415 | a[1][2] = 5 416 | a[1][3] = 6 417 | 418 | a[2][0] = 5 419 | a[2][1] = 6 420 | a[2][2] = 7 421 | a[2][3] = 8 422 | */ 423 | } 424 | ``` 425 | 426 | #### 多维数组的使用 427 | 428 | 从前面的学习中，大家应该都知道了，数组的维数与定数组时，数组的整型常量表达式，即下标的个数有关 429 | 430 | + 含有一个下标的是一维数组，包含两个下标的二维数组，很容易就可以推测出多维数组是如何定义并初始化的，如定义一个 int 型的三维数组 431 | 432 | ```c 433 | int num[2][4][2]; 434 | ``` 435 | 436 | + 上面所定义的三维数组的储存单元数应该是：2 * 4 * 2，即16 个储存单元，无论是有几个下标的多维数组，都可以看成是数组不断嵌套的结果,而且多维数组在程序的编写中不经常用到 437 | + 接下来通过一个实例来让大家熟悉一下多维数组 438 | 439 | ```c 440 | int mian() 441 | { 442 | int address[3][6][4]; 443 | for(int i = 0;i < 3;i ++) 444 | { 445 | printf("第%d栋楼\n\n"，i); 446 | for(int j = 0;j < 6;j ++) 447 | { 448 | printf("第%d层楼"，6 - j); 449 | for(int k = 0;k < 4;k ++) 450 | { 451 | address[i][j][k] = k + 1; 452 | printf("%d",address[i][j][k]); 453 | } 454 | } 455 | } 456 | } 457 | ``` 458 | 459 | ## 指针 460 | 461 | ### 指针及其使用 462 | 463 | #### 初识指针 464 | 465 | 指针是什么？ 466 | 467 | 首先理解 " & " 和 " * " ( 取地址和指针运算符 ) 468 | 469 | ```c 470 | int var1; 471 | char var2[10]; 472 | //打印出地址 473 | printf("var1 变量的地址： %p\n", &var1 ); 474 | printf("var2 变量的地址： %p\n", &var2 ); 475 | /* 476 | var1 变量的地址： 0x7fff5cc109d4 477 | var2 变量的地址： 0x7fff5cc109de 478 | */ 479 | ``` 480 | 481 | ```c 482 | scanf("%d",&i);//传入一个地址 483 | //scanf的函数原型 484 | int scanf(const char * restrict format,...); 485 | ``` 486 | 487 | 如何定义指针变量？ 488 | 489 | + 指针本身是一个变量，它存储的是数据在内存中的地址而不是数据本身的值。它的定义如下: 490 | 491 | ```c 492 | 数据类型* 变量名 或 数据类型 *变量名 //只是*的位置不同而已 493 | 494 | int *pointer; 495 | char *name; 496 | ``` 497 | 498 | + 这样就定义好了两个指针变量，int 和 char 表示该这两个指针变量指向的数据类型，*表示这是指针变量。 499 | 500 | + 指针变量的初始化：每一个变量都有一个内存位置，每一个内存位置都定义了可使用连字号（&）运算符访问的地址，它表示了在内存中的一个地址, 501 | 502 | ![train13.png](https://upload-images.jianshu.io/upload_images/9140378-ccd065db4a4c4091.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/640) 503 | 504 | ```c 505 | int a = 10,*p; 506 | p = &a 507 | int a = 10; 508 | int *p = &a; 509 | ``` 510 | 511 | + 首先我们可以理解 int * 这个是要定义一个指针p，然后因为这个指针存储的是地址所以要对a取地址(&)将值赋给指针p，也就是说这个指针p指向a。 512 | + 可能会对对这两种定义方法感到迷惑，其实他俩的意思是一样的。第一种定义方法定义了int型的变量 a 和 指针 p ，然后将 a 的地址赋给 p 513 | + 第二种是在定义指针p的同时将 a 的地址赋给指针 p。我们姑且理解为" int * "是定义指针的标志。 514 | 515 | 在变量声明的时候，如果没有确切的地址可以赋值，为指针变量赋一个 NULL 值是一个良好的编程习惯。赋为 NULL 值的指针被称为空指针。NULL 指针是一个定义在标准库中的值为零的常量 516 | 517 | ```c 518 | int *ptr = NULL; 519 | printf("ptr 的地址是 %p\n", ptr ); 520 | return 0; 521 | /* 522 | 结果： 523 | ptr 的地址是 0x0 524 | */ 525 | ``` 526 | 527 | #### 指针有什么用 528 | 529 | 这样我们就可以通过*p来找到指针所指向的变量a的地址，然后对地址中的值(值是10)进行操作。 530 | 531 | ```c 532 | printf("%p",p) //结果是一个地址(p指向的变量a的地址)。 533 | printf("%d",*p) //结果是10，变量a的值。 534 | printf("%d",&p) //结果是一个地址(指针p的地址，因为指针也是一个变量自己也有地址的) 535 | ``` 536 | 537 | 题目： 538 | 539 | 使用指针交换两个整数变量的值，并写成函数形式，即实现void swap(int *a, int *b)函数 540 | 541 | #### 指针运算 542 | 543 | 指针就是地址，地址在内存中也是以数的形式存在，所以指针也能做加法，减法，比较等运算 544 | 545 | ```c 546 | int a = 5; 547 | int *i = &a; 548 | printf("%p\n",i); 549 | i ++; 550 | printf("%p\n",i); 551 | i -= 2; 552 | printf("%p\n",i); 553 | return 0; 554 | /* 555 | 000000000062FE44 556 | 000000000062FE48 557 | 000000000062FE40 558 | */ 559 | ``` 560 | 561 | ### 指向数组的指针 562 | 563 | #### 指向一维数组的指针 564 | 565 | 为指针赋数组数据的地址 566 | 567 | + 数组的每个数据都保存在一个储存单元里面，只要是储存单元就会有地址，既然指针变量的储存单元可以保存地址，那么就可以用指针保存数组储存单元的地址 568 | 569 | ```c 570 | int *p_i = NULL; //定义指针变量 571 | int num[5] = {1，2，3，4，5}; 572 | for(int i = 0;i < 5;i ++) 573 | { 574 | p_i = &num[i]; //先让指针指向想要输出的数据 575 | printf("%d ",*p_i); //通过指针输出数组数据 576 | } 577 | ``` 578 | 579 | 使用数组名为指针赋值 580 | 581 | + 对于下面的数组和指针 582 | 583 | ```c 584 | int num[5] = {1,2,3,4,5}; 585 | int *p_i; 586 | ``` 587 | 588 | + 为指针赋予第一个数组数据的地址的方式为： 589 | 590 | ```c 591 | p_i = &num[0]; 592 | ``` 593 | 594 | + 其实还可以写成下面的形式,直接将数组名赋予指针，指针需要储存的数据就是地址，而 num 就代表的是数组的首地址 595 | 596 | ```c 597 | p_i = num; 598 | ``` 599 | 600 | 指向数组的指针的加减运算, -- 数组的另外一种遍历方式 601 | 602 | ![train14.png](https://upload-images.jianshu.io/upload_images/9140378-29428f6b9449104d.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240) 603 | 604 | + 对于*(num + i), num 是数组的首地址，指向数组的首元素，而num + i 则便是数组的第 i 个元素的地址，再加上指针运算符* 就得到了该元素的值 605 | + array每次加一的时候，它自己的值都会增加sizeof(int)，加 i 的时候就增加i *sizeof ( int ) 606 | 607 | ```c 608 | int num[5] = {2,4,6,8,10}; 609 | for(int i = 0;i < 5;i ++) 610 | { 611 | //通过数组下标遍历数组 612 | printf("%d",num[i]); 613 | //通过指针变量遍历数组 614 | printf("%d",*(num + i)); 615 | } 616 | ``` 617 | 618 | #### 指向二维数组的指针 619 | 620 | 跟一位数组同样的道理 621 | 622 | ```c 623 | int num[3][2] = {{1,2},{3,4},{5,6}}; 624 | int *p_i = &num[0][0]; 625 | ``` 626 | 627 | + 不过在这里要注意的是，不能为指针直接赋予二维数组的数组名，即上面的代码不能写成: int *p_i = num; 628 | 629 |
630 | 631 | ![train9.png](https://upload-images.jianshu.io/upload_images/9140378-261b27c28b07feab.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240) 632 | 633 |
634 | 635 | + 假设定义一个二维数组：num[m][n];一个指针p指向了这个二维数组的首地址，那么对于数组的数据 num[i][j](0 <= i < m,0 <= j < n) ，指针变量p要想指向这个数据,那么指针变量 p = p + n * i + j; 636 | 637 | ```c 638 | double arr[4][3] = { 639 | {78.4,72.1,41.2}, 640 | {56.4,12.4,45.1}, 641 | {12.5,14.6,20.4}, 642 | {23.5,34.6,67.8} 643 | } 644 | double *p_d = &arr[0][0]; //指针变量的类型必须要跟数组类型一致 645 | printf("二维数组中arr[3][2]位置上的数据为：%6.11f\n",*(p_d + 3 * 3 + 2)); 646 | ``` 647 | 648 | ### 保存指针的数组 649 | 650 |
651 | 652 | ![train15.png](https://upload-images.jianshu.io/upload_images/9140378-f25fae78ce0cba15.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240) 653 | 654 |
655 | 656 | 从名字的定义上来看，数组元素全为指针的数组就称为指针数组。 657 | 658 | + 一维指针数组的定义形式为： 类型名 *数组标识符[数组长度] 659 | 例如，一个一维指针数组的定义： 660 | 661 | ```c 662 | int *ptr_array[10] 663 | ``` 664 | 665 | + 因为[]比*的优先级高，所以也可以看成是*(ptr_array[10])，括号里面ptr_array[10]表示的是一个长度为10的数组，然后括号外面的* 说明数组的元素类型是 int* 的指针类型 666 | 667 | + 看一个指针数组的例子 668 | 669 | ```c 670 | int main() 671 | { 672 | int a = 16, b = 932, c = 100; 673 | //定义一个指针数组 674 | int *arr[3] = {&a, &b, &c}; 675 | printf("%d %d %d\n", *arr[0], *arr[1], *arr[2]); 676 | return 0; 677 | } 678 | /* 679 | 16 932 100 680 | */ 681 | 682 | ``` 683 | 684 | 因为数组arr里面的元素都是指针，所以在声明指针数组的时候，把a,b,c的地址&啊，&b,&c传进去了，在输出的时候先通过 数组下标得到数组内的指针，即a,b,c的地址，然后，再通过 运算符 * 将数据取出 685 | 686 | ### 数组指针 687 | 688 | 定义方式 689 | 690 | ```c 691 | datatype (*ptr)[length] 692 | ``` 693 | 694 | 如果一个指针指向了数组，就称它为数组指针,例如： 695 | 696 | ```c 697 | int a[4][3] = {{0,2,3},{1,5,6},{2,3,4},{7,8,9}}; 698 | ``` 699 | 700 | 在概念上他是像这种矩阵的样子： 701 | 702 | ```c 703 | 0 2 3 704 | 1 5 6 705 | 2 3 4 706 | 7 8 9 707 | ``` 708 | 709 | 但实际上他在内存中是链式的： 710 | 711 | ```c 712 | 0 2 3 1 5 6 2 3 4 7 8 9 713 | ``` 714 | 715 | 我们可以将这个二维数组分解成多个一维数组,a[0]包括a[0][0]、 716 | a[0][1]、a[0][2] 三个元素 717 | 718 | ```c 719 | a[][0] a[][1] a[][2] 720 | a[0] 0 2 3 721 | a[1] 1 5 6 722 | a[2] 2 3 4 723 | a[3] 7 8 9 724 | ``` 725 | 726 | 这里的 a 就是那四个一位数组的组名，接着我们定义一个 数组指针 727 | 728 | ```c 729 | int (*p)[4] = a; 730 | ``` 731 | 732 | 括号里面的*代表 p 是一个指针，[4] 代表这个 指针 p指向了类型为 int[4] 的数组 733 | 734 | 下面使用数组指针来遍历一遍二维数组 735 | 736 | + p指向数组a的开头，就是指向第0行元素，p + 1 代表的是数组中的第一行元素 737 | + 那么 *(p + 1) 就表示的是 数组a 的第一行元素，是多个数据 738 | + *(p + 1) + 1 则表示的是第一行的第一个数据的地址 739 | + ((p+1)+1)表示第一行的第一个数据的值 740 | 741 | ### 指针在函数中的应用 742 | 743 | #### 指针作为函数参数 744 | 745 | ```c 746 | #include "stdio.h" 747 | 748 | void add_five(int *); 749 | int main() 750 | { 751 | int i = 10; 752 | add_five(&i); 753 | } 754 | 755 | void add_five(int *a) 756 | { 757 | *a = *a + 5; 758 | } 759 | ``` 760 | 761 | #### 指针作为函数返回值 762 | 763 | #### 指向函数的指针 764 | 765 | ### 二级指针 -------------------------------------------------------------------------------- /18-C-Train-W/18-C-Train-W-2.md: -------------------------------------------------------------------------------- 1 | # C Train For 18 2 | 3 | ## 大一C语言培训 (下) 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 | ```c 43 | #include "stdio.h" 44 | int main() 45 | { 46 | char name[20] = "baoqianyue"; 47 | int height = 175; 48 | int weight = 70; 49 | char sex = 'm'; 50 | short age = 19; 51 | long wealth = 300000; 52 | printf("鲍骞月的个人信息：\n"); 53 | printf("姓名：%s,身高：%d,性别：%c,年龄：%d,财产：%d\n",name,height,sex,age,wealth); 54 | return 0; 55 | } 56 | ``` 57 | 58 | 数组允许定义可存储相同类型数据项的变量，结构是 C 编程中另一种用户自定义的可用的数据类型，它允许您存储不同类型的数据项,而结构体的出现就很好的解决了这个问题 59 | 60 | + 结构体的构造 61 | 62 | ```c 63 | struct 结构类型名 64 | { 65 | 数据类型1 成员变量1; 66 | 数据类型2 成员变量2; 67 | 数据类型3 成员变量3; 68 | .... 69 | }; //<- 需要注意的地方 70 | ``` 71 | 72 | + 定义结构体变量 73 | 74 | ```c 75 | struct Stu{ 76 | int height;//身高 77 | int weight;//体重 78 | char sex;//性别 79 | int age; //年龄 80 | long wealth; 81 | }; 82 | ``` 83 | 84 | 这个结构体名是Stut，它内部有五个成员，分别为身高，体重，性别，年龄。定义形式与普通变量定义的方式一样，只不过不能立即初始化。 85 | 86 | + 结构体变量的初始化 87 | 88 | 结构体也是一种数据类型，在某种意义上与int，char这些基本数据类型是同级的，所以定义变量的方式是一样的。 89 | 90 | ```c 91 | struct student stu1,stu2; 92 | ``` 93 | 94 | 对于结构体，初始化并赋值的一般形式为 95 | 96 | ```c 97 | strcut 结构类型名 结构变量 = {数据1，数据2,...}; 98 | ``` 99 | 100 | + 结构体成员的读取和赋值 101 | 102 | 结构体成员的获取形式为： 103 | 104 | ```c 105 | 结构体变量名.成员名; 106 | ``` 107 | 108 | 为单个结构体变量赋值,定义结构体变量并赋值，在这里我们定义了一个名stu1的结构体变量，并且为这个结构体 109 | 110 | ```c 111 | Stu stu1; 112 | stu1.age = 19; 113 | stu1.height = 175; 114 | stu1.sex = 'm'; 115 | stu1.wealth = 30000; 116 | stu1.weight = 70; 117 | printf("身高：%d,性别：%c,年龄：%d,财产：%d\n",stu1.height,stu1.sex,stu1.age,stu1.wealth); 118 | ``` 119 | 120 | + 使用typedef简化变量名 121 | 122 | ```c 123 | typedef StudentInfo Stu; 124 | typedef int integer; 125 | ``` 126 | 127 | ### 结构体的使用 128 | 129 | #### 结构体与数组 130 | 131 | + 数组作为结构体的变量 132 | 133 | 举个例子：一家店雇佣了三个兼职人员，只需要他们在一个星期内来4天就可以，此时如何定义结构体？ 134 | 135 | ```c 136 | struct schedule{ 137 | char name; 138 | char sex; 139 | int week1; 140 | int week2; 141 | int week3; 142 | int week4; 143 | }; 144 | ``` 145 | 146 | 使用数组节省没必要的变量 147 | 148 | ```c 149 | struct schedule{ 150 | char name; 151 | char sex; 152 | int week[4]; 153 | }; 154 | //简化结构体的名字 155 | typedef schedule S; 156 | ``` 157 | 158 | ```c 159 | int main() 160 | { 161 | S sd1 = {'A','m',1,2,4,6}; 162 | S sd2 = {'A','m',3,5,6,7}; 163 | S sd3 = {'A','m',2,3,5,7}; 164 | printf("姓名：%c,性别：%c,工作日：%d %d %d %d", 165 | sd1.name,sd1.sex,sd1.week[0],sd1.week[1],sd1.week[2],sd1.week[3]); 166 | return 0; 167 | } 168 | ``` 169 | 170 | + 保存结构的数组 171 | 172 | ```c 173 | int main() 174 | { 175 | S st[3] = { {'A','m',1,2,4,6 } , {'A','m',3,5,6,7} , {'A','m',2,3,5,7} }; 176 | for(int i = 0;i < 3;i ++) 177 | printf("姓名：%c,性别：%c,工作日：%d %d %d %d\n", 178 | st[i].name,st[i].sex,st[i].week[i],st[i].week[1],st[i].week[2],st[i].week[3]); 179 | return 0; 180 | } 181 | ``` 182 | 183 | #### 结构体与指针 184 | 185 | + 结构体与函数 186 | 187 | 结构体作为函数参数，传入函数进行赋值，并将赋值完的结构体返回给主函数 188 | 传参方式与其他类型的变量或指针类似 189 | 190 | ```c 191 | #include "stdio.h" 192 | struct complex_num{ 193 | int real; 194 | int image; 195 | }; 196 | typedef complex_num comp; 197 | 198 | comp assign(comp num) 199 | { 200 | puts("输入复数的实部："); 201 | scanf("%d",&(num.real)); 202 | puts("输入复数的实部："); 203 | scanf("%d",&(num.image)); 204 | return num; 205 | } 206 | 207 | int main() 208 | { 209 | comp com1; 210 | com1 = assign(com1); 211 | printf("%d + %di",com1.real,com1.image); 212 | return 0; 213 | } 214 | ``` 215 | 216 | 217 | ### 结构体的应用 218 | 219 | 结构体的应用 -- 链表 220 | 221 | #### 结构体变量指针 222 | 223 | ![train.png](https://upload-images.jianshu.io/upload_images/9140378-105df5dddce29c6a.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/640) 224 | 225 | + 结构体变量成员指向自身 226 | 227 | 即将定义的结构体变量的地址赋予给所定义的结构体，这样定义的该结构体的指针域就只想了结构体本身 228 | 229 | ```c 230 | struct table{ 231 | int i; 232 | char c; 233 | struct table *st; 234 | }; 235 | int main() 236 | { 237 | table st1 = {1,'a'}; 238 | st1.st = &st1; 239 | //使用结构体变量输出自身的2个成员的值 240 | printf("%d %c\n",st1.i,st1.c); 241 | //使用结构体指针域所指向的结构体输出数值 242 | printf("%d %c\n",st1.st->i,st1.st->c); 243 | return 0; 244 | } 245 | /* 246 | 1 a 247 | 1 a 248 | */ 249 | ``` 250 | 251 | + 结构体变量成员指向其他结构变量 252 | 253 | 即将定义的两个结构体变量，比方说定义了 st1 和 st2两个结构体变量，只需要将st2 的地址 赋给 st1 的指针域，这样 st1 的指针就指向了 st2 254 | 255 | ![train1.png](https://upload-images.jianshu.io/upload_images/9140378-b8b80be836c3d74a.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/440) 256 | 257 | ```c 258 | int main() 259 | { 260 | table st1 = {1,'a'}; 261 | table st2 = {2,'b'}; 262 | st1.st = &st2; 263 | 264 | //使用结构体变量输出st1自身的2个成员的值 265 | printf("%d %c\n",st1.i,st1.c); 266 | 267 | //使用结构体指针域所指向的结构体输出数值,即 st2 中的数值 268 | printf("%d %c\n",st1.st->i,st1.st->c); 269 | 270 | //使用结构体变量输出st2自身的2个成员的值 271 | printf("%d %c\n",st2.i,st2.c); 272 | 273 | return 0; 274 | } 275 | /* 276 | 1 a 277 | 2 b 278 | 2 b 279 | */ 280 | ``` 281 | 282 | #### 数组与链表 283 | 284 | 数组是由同类型的多个数据组成的，链表是由是由多个相同结构连接而成 285 | 但是数组中就可以存放结构体，为啥还要单独专门独立出来一个链表呢？这是因为数组的长度总是固定的，没办法动态的储存数据 286 | 287 | ```c 288 | #include "stdio.h" 289 | struct table{ 290 | int i; 291 | char c; 292 | struct table *st; 293 | }; 294 | int main() 295 | { 296 | table tal[3] = { 297 | {1,'a'}, 298 | {2,'b'}, 299 | {3,'c'} 300 | }; 301 | return 0; 302 | } 303 | ``` 304 | 305 | 上面的代码也能做到和链表一样的效果，甚至比链表还要简洁，但是如果程序中的结构数目是用户自己决定的话，或者说结构体的数目是位未知的，那怎么办?数组的长度可以在程序运行时不能被更改，所以说，数组跟结构体搭配的前提时数组的长度固定并且已知 306 | 307 | #### 链表概述 308 | 309 | ![timg.jpg](https://upload-images.jianshu.io/upload_images/9140378-c16769111551b03e.jpg?imageMogr2/auto-orient/strip%7CimageView2/2/w/840) 310 | 311 | 链表的最小单元 -- 结点 312 | 313 | ```c 314 | struct table 315 | { 316 | int i; 317 | char c; 318 | struct table *next; 319 | } 320 | strcut table st1 = {1,'a'}; 321 | struct table st2 = {2,'b'}; 322 | st1.next = &st2; 323 | ``` 324 | 325 | 链表的组成部分 326 | 327 | 一个连边通常由3部分组成：投机欸但、数据结点和尾结点 328 | 329 | + 头节点：数据域的变量不指代数据，指针域的指针变量指向链表的第一个数据结点。通常情况下，使用‘ 单链表 ’ 的程序只记录头节点，其他节点都是通过头节点一次获取得到的 330 | + 数据结点：数据域的变量指代实实在在的数据，指针域的指针变量用于指向下一个数据结点 331 | + 尾结点：数据域的变量指代实实在在的数据，指针域的指针变量被赋予为空，便是没有指向任何地方 332 | 333 | #### 动态创建链表 334 | 335 | 构建3步骤 336 | 337 | + 构造一个结构类型，此结构类型必须包含至少一个成员指针，此指针要指向此结构类型， 338 | + 定义3个结构体类型的指针，按照用途可以命名为，p_head,p_rail,p_new 339 | + 动态生成新的结点，为各成员变量赋值，最后加到链表当中 340 | 341 | 构造专用于链表的结构 342 | 343 | ```c 344 | struct node 345 | { 346 | short i; 数据域 347 | char c; ///数据域 348 | struct node *next; //指针域，用于指向下一个结点 349 | } 350 | ``` 351 | 352 | 定义结构体指针 353 | 354 | ```c 355 | struct node *p_head,*p_rail,*p_new ; 356 | ``` 357 | 358 | 使用malloc() 动态申请储存空间作为新节点，声明形式： 359 | 360 | ```c 361 | void malloc(unsigned int num_bytes); 362 | ``` 363 | 364 | + num_bytes声明的空间大小 365 | + 返回void类型的指针 366 | + 要注意的是，生命完要把空间释放掉，盗用的函数为 free(); 367 | 368 | ![train20.png](https://upload-images.jianshu.io/upload_images/9140378-e9fbe3bdd6db4850.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/540) 369 | 370 | 接下来写一个动态创建链表的实例： 371 | 372 | 首先构造结构体 373 | 374 | ```c 375 | struct node { 376 | short i; 377 | char c; 378 | struct node *next; 379 | }; 380 | ``` 381 | 382 | 构造一个含有3个结点的链表 383 | 384 | ```c 385 | struct node node1 = {1,'A'}; 386 | struct node node2 = {2,'B'}; 387 | struct node node3 = {3,'C'}; 388 | node1.next = &node2; 389 | node2.next = &node3; 390 | ``` 391 | 392 |
393 | 394 | ![train21.png](https://upload-images.jianshu.io/upload_images/9140378-32814c518bae8414.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/540) 395 | 396 |
397 | 398 | 遍历链表输出数据 399 | 400 | ```c 401 | struct node *p; 402 | p = &node1; 403 | for(int j = 0;j < 3;j ++) 404 | { 405 | printf("node:%d %c",p->i,p->c); 406 | p = p->next; 407 | } 408 | ``` 409 | 410 | 动态生成新节点 411 | 412 | ```c 413 | struct node *p_new; 414 | p_new = (struct node *)malloc(sizeof(struct node)); 415 | p_new->i = 4; 416 | p_new->c = 'd'; 417 | ``` 418 | 419 | 添加到链表当中 420 | 421 | ```c 422 | node3.next = p_new; 423 | ``` 424 | 425 | #### 链表操作 426 | 427 | 插入结点到链表 428 | 429 | + 插入结点到第一个数据结点前 430 | 431 |
432 | 433 | ![train22.png](https://upload-images.jianshu.io/upload_images/9140378-884b75f47c63a109.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/740) 434 | 435 |
436 | 437 | ```c 438 | struct node p_new = (struct node *)malloc(sizeof(struct node)); //创建新结点，并为其开辟空间 439 | scanf("%d%c",&(p_new->i),&(p_new->c)); //录入结点数据 440 | //插入节点 441 | p_new->next = p_head-next; 442 | p_head->next = p_new; 443 | ``` 444 | 445 | + 插入结点到链表中间 446 | 447 |
448 | 449 | ![train23.png](https://upload-images.jianshu.io/upload_images/9140378-320eb2dd5952ee8f.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/740) 450 | 451 |
452 | 453 | ```c 454 | struct node p_new = (struct node *)malloc(sizeof(struct node)); //创建新结点，并为其开辟空间 455 | p_new->i = 2; 456 | p_new->c = 'B'; 457 | 458 | struct node *p_front = p_head->next; 459 | p_new->next = p_front->next; 460 | p_front->next = p_new; 461 | ``` 462 | 463 | + 插入节点到链表末尾 464 | 465 | ![train24.png](https://upload-images.jianshu.io/upload_images/9140378-b772cb8890126923.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240) 466 | 467 | ```c 468 | while(1) 469 | { 470 | if(p-next == NULL) 471 | { 472 | p_rail = p; 473 | break; 474 | } 475 | p = p->next; 476 | } 477 | p_rail->next = p_new; 478 | p_tail = p_new; 479 | ``` 480 | 481 | + 删除链表中的结点 482 | 483 |
484 | 485 | ![train25.png](https://upload-images.jianshu.io/upload_images/9140378-3582fbb7b736eb09.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/440) 486 | 487 |
488 | 489 | ```c 490 | void del_list(struct node *p_head,int pos) 491 | { 492 | strct node *p_front,*p_del; 493 | p_front = p_head; 494 | for(int i = 0;i <= pos - 1;i ++) 495 | { 496 | p_front = p_front->next; 497 | } 498 | p_del = p_front->next; 499 | p_front->next = p_del->next; 500 | free(p_del); 501 | } 502 | ``` 503 | 504 | ## 字符串 505 | 506 | ### 初识字符串 507 | 508 | 什么是字符串？ 509 | 510 | 在 C 语言中，字符串实际上是使用 null 字符 '\0' 终止的一维字符数组。因此，一个以 null 结尾的字符串，包含了组成字符串的字符。 511 | 512 | 下面的声明和初始化创建了一个 "Hello" 字符串。由于在数组的末尾存储了空字符，所以字符数组的大小比单词 "Hello" 的字符数多一个 513 | 514 | ```c 515 | char greeting[6] = {'H', 'e', 'l', 'l', 'o', '\0'}; 516 | ``` 517 | 518 | 依据数组初始化规则，您可以把上面的语句写成以下语句： 519 | 520 | ```c 521 | char greeting[] = "Hello"; 522 | ``` 523 | 524 | 定义的字符串的内存表示： 525 | 526 | ![train17.jpg](https://upload-images.jianshu.io/upload_images/9140378-c4e53c41e194053a.jpg?imageMogr2/auto-orient/strip%7CimageView2/2/w/540) 527 | 528 | ### 字符串的输入与输出 529 | 530 | #### 输出 531 | 532 | 普通方式 533 | 534 | ```c 535 | char arr[] = "Hello!"; 536 | int i = 0; 537 | while(arr[i] != '\0') 538 | { 539 | printf("%c",arr[i]); 540 | i ++; 541 | } 542 | ``` 543 | 544 | 特殊方式 545 | 546 | ```c 547 | char arr[] = "Hello!"; 548 | printf("%s\n",arr); 549 | ``` 550 | 551 | 其他方式,函数 putchar(); 552 | 553 | ```c 554 | char arr[] = "Hello!"; 555 | int i = 0; 556 | while(arr[i] != '\0') 557 | { 558 | putchar(arr[i]); 559 | i ++; 560 | } 561 | ``` 562 | 563 | #### 输入 564 | 565 | 普通方式 566 | 567 | ```c 568 | int i = -1; 569 | do 570 | { 571 | i ++; 572 | scanf("%c",&arr[i]); 573 | }while(arr[i] != '\n'); 574 | arr[i] = '\0'; 575 | ``` 576 | 577 | 特殊方式 578 | 579 | ```c 580 | scanf("%s",arr); 581 | ``` 582 | 583 | 其他方式 584 | 585 | ```c 586 | arr[i] = getchar(); 587 | ``` 588 | 589 | ### 指向字符串的指针 590 | 591 | ```c 592 | char arr[10] = {0}; 593 | char *p = arr; 594 | int i = -1; 595 | do 596 | { 597 | i ++; 598 | scanf("%d",p + i); 599 | }while(*(p + i) != '\n'); 600 | *(p + i) = '\0'; 601 | i = 0; 602 | while(*(p + i) != '\0') 603 | { 604 | printf("%c",*(p + i)); 605 | i ++; 606 | } 607 | ``` 608 | 609 | gets 和 puts() 610 | 611 | ```c 612 | cahr arr[20] = {0}; 613 | char *p = arr; 614 | gets(p); 615 | puts(p); 616 | ``` 617 | 618 | ### 常见的字符串操作 619 | 620 | + strcpy(p, p1) 复制字符串 621 | + strncpy(p, p1, n) 复制指定长度字符串 622 | + strcat(p, p1) 附加字符串 623 | + strncat(p, p1, n) 附加指定长度字符串 624 | + strlen(p) 取字符串长度 625 | + strcmp(p, p1) 比较字符串 626 | + strcasecmp忽略大小写比较字符串 627 | + strncmp(p, p1, n) 比较指定长度字符串 628 | + strchr(p, c) 在字符串中查找指定字符 629 | + strrchr(p, c) 在字符串中反向查找 630 | + strstr(p, p1) 查找字符串 631 | 632 | #### 赋值 633 | 634 | 何为赋值？ 635 | 636 | ```c 637 | float f1 = 3.654; 638 | float f2; 639 | f2 = f1; 640 | ``` 641 | 642 | 字符串拷贝函数 643 | 644 | 将src指向的字符串拷贝到des指向的字符串数组中去，结束符也一同进行拷贝，size参数也可以拷贝制定长度的字符串，建议des为字符数组 645 | 646 | ```c 647 | char *strcpy(char*des,char*src); 648 | char *strncpy(char *des,char *src,int size); 649 | ``` 650 | 651 | #### 加法 652 | 653 | 字符串的连接函数 654 | 655 | 将str2指向的字符串连接到str1指向的字符后面，同时会删除str1后面的’\0’,返回的是str1指向字符串的首地址重点内容 656 | 657 | ```c 658 | char * strcat(const *char str1,const *char str2); 659 | char *strncat(const *char str1,const *char str2,int size); 660 | ``` 661 | 662 | 错误的加法运算 663 | 664 | ```c 665 | char *p1 = "super"; 666 | char *p2 = "market"; 667 | char *p3 = p1 + p2; //错误的加法 668 | ``` 669 | 670 | ```c 671 | char arr[30] = {0}; 672 | char *p3 = arr; 673 | p3 = strcat(p3,p1); 674 | p3 = strcat(p3,p2); 675 | p3 = strncat(p3,p1,1); //将p1所指向的字符的第一个字符加到p3所指字符串的末尾 676 | // p3 = supermarkets 677 | ``` 678 | 679 | #### 修改 680 | 681 | ```c 682 | cahr arr[] = "Nes!"; 683 | cahr *p = arr; 684 | *p = 'Y'; 685 | ``` 686 | 687 | 指针p指向了arr字符串的字符串，借助 p 可以任意修改字符串中的任意字符,但是借助指针修改一个字符还比较容易，批量的话就需要 库函数 strset 688 | 689 | ```c 690 | char *strset(char *s,char c); //将字符串s中的字符全部设成字符 c 691 | char *strnset(char *s,char c,int n); //将s指向的字符串的前n个字符都设成c 692 | ``` 693 | 694 | ```c 695 | char p1[] = "Are you ok"; 696 | strset(p1,'a'); 697 | // p1 aaaaaaaaaa 698 | 699 | strset(p2,'b',2); 700 | 701 | //p1 bbaaaaaaaa 702 | ``` 703 | 704 | #### 比较 705 | 706 | 字符串比较函数 707 | 708 | 错误的比较方式 709 | 710 | ```c 711 | char arr[] = "What"; 712 | char arr2[] = "That"; 713 | arr1 = arr2; //错误的比较方式 714 | ``` 715 | 716 | 按照ascii码来进行比较，并由函数返回值进行判断 717 | 返回0,字符串1等于字符串2, 718 | 大于0,字符串1大于字符串2, 719 | 小于0,字符串1小于字符串2, 720 | 721 | ```c 722 | int strcmp(const char *str1,const char *str2); 723 | int strncmp(const char *str1,const char *str2,int size); 724 | 725 | char buf1[] = "aaa"; 726 | char buf2 = "bbb"; 727 | int ptr = strcmp(buf2,buf1);//ptr < 0 728 | ``` 729 | 730 | ## 文件 731 | 732 |
733 | 734 | ![train19.gif](https://upload-images.jianshu.io/upload_images/9140378-68d9870e8f7a4e41.gif?imageMogr2/auto-orient/strip%7CimageView2/2/w/440) 735 | 736 |
737 | 738 | ### 为什么要有文件操作 739 | 740 | 两个没有解决的问题 741 | 742 | 不得不再次运行程序 743 | 744 | + 我们运行计算机上的程序，然后不断输入数据给程序，然后得到程序对程序的处理结果，如果关掉程序的话，再想看到那些数据，就不得不再次运行程序。而且如果数据量过大的话，没办法留住这些数据 745 | 746 | 不得不重新输入数据 747 | 748 | + 每次在循行程序的时候吗，每运行一次都要重新的从简盘再次录入数据，而文件的运用帮我们解决了这个繁琐的问题 749 | 750 | ### 文件概述 751 | 752 | + 定位文件 753 | + 读取、写入文件 754 | + 关闭文件 755 | 756 |
757 | 758 | ![train16.png](https://upload-images.jianshu.io/upload_images/9140378-3e2ccfe2d81cd5ba.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/540) 759 | 760 |
761 | 762 | ### 文件的打开和关闭 763 | 764 | #### 打开文件 765 | 766 | 可以使用 fopen( ) 函数来创建一个新的文件或者打开一个已有的文件，这个调用会初始化类型 FILE 的一个对象，类型 FILE 包含了所有用来控制流的必要的信息。下面是这个函数调用的原型： 767 | 768 | ```c 769 | FILE *fopen( const char * filename, const char * mode ); 770 | ``` 771 | 772 | 在这上面的函数原型里面，filename 是字符串，用来命名文件，访问模式 mode 的值可以是下列值中的一个： 773 | ||| 774 | |:--|:--| 775 | |模式|描述| 776 | |r|打开一个已有的文本文件，允许读取文件。| 777 | |w|打开一个文本文件，允许写入文件。如果文件不存在，则会创建一个新文件。在这里，您的程序会从文件的开头写入内容。如果文件存在，则该会被截断为零长度，重新写入。| 778 | |a|打开一个文本文件，以追加模式写入文件。如果文件不存在，则会创建一个新文件。在这里，您的程序会在已有的文件内容中追加内容。| 779 | |r+|打开一个文本文件，允许读写文件。| 780 | |w+|打开一个文本文件，允许读写文件。如果文件已存在，则文件会被截断为零长度，如果文件不存在，则会创建一个新文件。| 781 | |a+|打开一个文本文件，允许读写文件。如果文件不存在，则会创建一个新文件。读取会从文件的开头开始，写入则只能是追加模式。| 782 | 783 | 如果处理的是二进制文件，则需使用下面的访问模式来取代上面的访问模式： 784 | 785 | ```c 786 | "rb", "wb", "ab", "rb+", "r+b", "wb+", "w+b", "ab+", "a+b" 787 | ``` 788 | 789 | #### 关闭文件 790 | 791 | 为了关闭文件，请使用 fclose( ) 函数。函数的原型如下： 792 | 793 | ```c 794 | int fclose( FILE *fp ); 795 | ``` 796 | 797 | 如果成功的关闭了文件，会清空缓冲区中的数据，并释放用于该文件的所有内存，这个函数就会返回0，如果关闭文件的时候放生错误，函数会返回EOF，而EFO是一个常量 798 | 799 | ```c 800 | #include "stdio.h" 801 | #include "stdlib.h" 802 | int main() 803 | { 804 | //定义一个指向文件类型的指针 805 | FILE *fp; 806 | //打开一个已有的文件 807 | fp = fopen(text.txt,"r"); //错误的方式 808 | fp = fopen("D:\Desktop\text.txt","r"); //错误的方式 809 | if(fp == NULL ) 810 | { 811 | printf("打开文件失败！\n"); 812 | exit(0); 813 | } 814 | printf("打开文件成功！\n"); 815 | fclose(fp); 816 | 817 | 818 | //如果想要在字符串中使用 '\' 必须要写成 '\\' 来转义 819 | fp = fopen("D:\\Desktop\\text.txt","r"); 820 | //printf("D:\\Desktop\\text.txt\n"); 821 | //printf("D:\Desktop\text.txt\n"); 822 | 823 | //使用访问模式 'w' 打开文件，会发现文件之前保存的内容被清零 824 | fp = fopen("D:\\Desktop\\text.txt","w"); 825 | 826 | return 0; 827 | } 828 | ``` 829 | 830 | ### 文件的读写操作 831 | 832 | #### 写入数据 833 | 834 | 想要让程序在文件中写入文件，在程序与文件建立关联的时候，必须保证打开方是可写的，有 4 中方式可以将数据写入文件当中 835 | 836 | 字符方式 837 | 838 | 程序可以以字符为单位，一个字符一个字符的将数据写入到文件当中，需要的函数是 fputc(),声明如下： 839 | 840 | ```c 841 | int fputc(char c,FILE *stream); 842 | ``` 843 | 844 | + 参数 c 指代的是一个将要被写入文件的字符 845 | + 参数 stream 是一个文件指针，指向将要被写入的文件 846 | + 写入成功，返回 写入字符的ASCII 码值 847 | 848 | ```c 849 | char ch; //定义一个字符串 850 | int i = 0; 851 | ch = getchar(); 852 | while(ch != '\n'); 853 | { 854 | i = fputc(ch,fp); // 以字符为单位，写入到text.txt文件 855 | if(i == -1) 856 | { 857 | puts("字符写入失败！"); 858 | exit(0); 859 | } 860 | ch = getchar(); 861 | } 862 | ``` 863 | 864 | 格式化方式 865 | 866 | 如果写入文件的内容有特定的格式要求，可以使用格式化的方式将数据写入到文本 867 | 868 | stdio.h 提供了一个库函数 fprintf(),可以达到这个目的，声明如下： 869 | 870 | ```c 871 | int fprintf(FILE *stream,const char *format[, argument ] ...); 872 | ``` 873 | 874 | 和 printf()的使用方法一致 875 | 876 | + 参数的 stream 是指向将要被写入数据的文件的文件指针 877 | + 参数 format 是格式化的字符串 878 | + 参数 argument 是可选的，如果 format 中有格式符，argument 就是对应的变量 879 | + 函数 fprintf() 返回实际输入到文件中的字符的个数 880 | 881 | ```c 882 | struct info 883 | { 884 | short no; 885 | char name[10]; 886 | char sex[6]; 887 | }; 888 | 889 | struct info info_st[3] ={ 890 | {1,"baoqianyue","men"}, 891 | {2,"lihao","men"}, 892 | {3,"wanghao","men"} 893 | }; 894 | for(int i = 0;i < 3;i ++) 895 | { 896 | fprintf(fp,"No = %d\tname = %-8s\tsex = %-6s\n",info_st[i].no, 897 | info_st[i].name,info_st[i].sex); 898 | } 899 | ``` 900 | 901 | 字符串方式 902 | 903 | 对于程序中的字符串，除了以字符串为单位，一个字符一个字符的录入之外，还可以以字符串为单位，一次性的写入一串字符，需要用到的路函数是 fputs(),它的声明是： 904 | 905 | ```c 906 | int puts(const char *str,FILE *stream); 907 | ``` 908 | 909 | + str 写入文件的字符串指针 910 | + stream 文件指针 911 | + 字符串写入失败的话，同样也是会返回 -1 912 | 913 | ```c 914 | char c[100]; 915 | gets(c); 916 | int value = fputs(c,fp); 917 | if(value == -1) 918 | { 919 | puts("字符串写入失败！\n"); 920 | exit(0); 921 | } 922 | ``` 923 | 924 | 二进制方式 925 | 926 | 储存为文件的数据形式一般为两种，分别是字符形式 和 二进制 形式，使用二进制方式向文件写入数据，需要用到的库函数是 fwrite(),它的声明是： 927 | 928 | ```c 929 | int fwrite(const void *buffer,int size,int count,FILE *stream); 930 | ``` 931 | 932 | + buffer 无类型指针 933 | + size 是要被写入到文件的数据的大小 934 | + count 是size 为单元的单元的个数 935 | + stream 文件指针 936 | 937 | ```c 938 | struct info 939 | { 940 | short no; 941 | char name[10]; 942 | char sex[6]; 943 | }; 944 | 945 | struct info info_st[3] ={ 946 | {1,"baoqianyue","men"}, 947 | {2,"lihao","men"}, 948 | {3,"wanghao","men"} 949 | }; 950 | 951 | int count = fwrite(info_st,sizeof(struct info),3,fp); //写入数据到文件 952 | 953 | ``` 954 | 955 | #### 读取数据 956 | 957 | 字符方式 958 | 959 | 以字符为单位，一个一个从文本文件读取数据，使用的库函数为 fgetc()，声明方式如下: 960 | 961 | ```c 962 | int fgetc(FILE *stream); 963 | ``` 964 | 965 | + 参数 stream 是一个文件指针，指向将要被写入的文件 966 | + 写入成功，返回 写入字符的ASCII 码值，写入失败，返回 -1 967 | 968 | ```c 969 | char ch = fgetc(fp); 970 | while(ch != -1) 971 | { 972 | putchar(ch); 973 | ch = fgetc(fp); 974 | } 975 | ``` 976 | 977 | 格式化方式 978 | 979 | 要格式化的一次性从一个文件读取多个字符，用到的库函数是fscanf(),声明方式如下： 980 | 981 | ```c 982 | int fscanf(FILE *stream,const char *format[, argument ]...); 983 | ``` 984 | 985 | + 参数的 stream 是指向将要被写入数据的文件的文件指针 986 | + 参数 format 是格式化的字符串 987 | + 参数 argument 是可选的，如果 format 中有格式符，argument 就是对应的变量 988 | + 函数 fprintf() 返回读取到的文件中的字符的个数 989 | 990 | ```c 991 | struct info 992 | { 993 | short no; 994 | char name[10]; 995 | char sex[6]; 996 | }; 997 | 998 | struct info info_st[3] ={ 999 | {1,"baoqianyue","men"}, 1000 | {2,"lihao","men"}, 1001 | {3,"wanghao","men"} 1002 | }; 1003 | for(int i = 0;i < 3;i ++) 1004 | { 1005 | fscanf(fp,"No = %d\tname = %-8s\tsex = %-6s\n",&info_st[i].no, 1006 | &info_st[i].name,&info_st[i].sex); 1007 | } 1008 | ``` 1009 | 1010 | 字符串方式 1011 | 1012 | 一次性全部取出字符串，用到的库函数为 fgets(),它的声明如下： 1013 | 1014 | ```c 1015 | char *fgets(char *str,int n,FILE *stream); 1016 | ``` 1017 | 1018 | + str 写入文件的字符串指针 1019 | + n 是读取字符串结束标志 "\0" 1020 | + stream 文件指针 1021 | + 字符串读取成功的话，返回指向字符串的指针，否则返回NULL 1022 | 1023 | ```c 1024 | char arr[15] = {0}; 1025 | char *p = fgets(arr,15,fp); 1026 | while(p != NULL) 1027 | { 1028 | printf("%s",arr); 1029 | p = fgets(arr,15,fp); 1030 | } 1031 | ``` 1032 | 1033 | 二进制方式 1034 | 1035 | 以二进制写入文件通常是给程序自己看的，就是俗称的乱码，用到的库函数是fread(),它的声明方式是： 1036 | 1037 | ```c 1038 | int fr(eadconst void *buffer,int size,int count,FILE *stream); 1039 | ``` 1040 | 1041 | ```c 1042 | int count = fread(info_st,sizeof(struct info),3,fp); //从文件读取数据 1043 | ``` -------------------------------------------------------------------------------- /18-C-Train-W/Pictures/train.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/android-nuc/18-C-Train/ecd72ca41c1b261aef18b4960dda889c798cbbd1/18-C-Train-W/Pictures/train.jpg -------------------------------------------------------------------------------- /18-C-Train-W/Pictures/train.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/android-nuc/18-C-Train/ecd72ca41c1b261aef18b4960dda889c798cbbd1/18-C-Train-W/Pictures/train.png -------------------------------------------------------------------------------- /18-C-Train-W/Pictures/train10.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/android-nuc/18-C-Train/ecd72ca41c1b261aef18b4960dda889c798cbbd1/18-C-Train-W/Pictures/train10.png -------------------------------------------------------------------------------- /18-C-Train-W/Pictures/train11.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/android-nuc/18-C-Train/ecd72ca41c1b261aef18b4960dda889c798cbbd1/18-C-Train-W/Pictures/train11.jpg -------------------------------------------------------------------------------- /18-C-Train-W/Pictures/train12.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/android-nuc/18-C-Train/ecd72ca41c1b261aef18b4960dda889c798cbbd1/18-C-Train-W/Pictures/train12.jpg -------------------------------------------------------------------------------- /18-C-Train-W/Pictures/train13.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/android-nuc/18-C-Train/ecd72ca41c1b261aef18b4960dda889c798cbbd1/18-C-Train-W/Pictures/train13.png -------------------------------------------------------------------------------- /18-C-Train-W/Pictures/train14.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/android-nuc/18-C-Train/ecd72ca41c1b261aef18b4960dda889c798cbbd1/18-C-Train-W/Pictures/train14.png -------------------------------------------------------------------------------- /18-C-Train-W/Pictures/train15.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/android-nuc/18-C-Train/ecd72ca41c1b261aef18b4960dda889c798cbbd1/18-C-Train-W/Pictures/train15.png -------------------------------------------------------------------------------- /18-C-Train-W/Pictures/train16.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/android-nuc/18-C-Train/ecd72ca41c1b261aef18b4960dda889c798cbbd1/18-C-Train-W/Pictures/train16.png -------------------------------------------------------------------------------- /18-C-Train-W/Pictures/train17.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/android-nuc/18-C-Train/ecd72ca41c1b261aef18b4960dda889c798cbbd1/18-C-Train-W/Pictures/train17.jpg -------------------------------------------------------------------------------- /18-C-Train-W/Pictures/train19.gif: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/android-nuc/18-C-Train/ecd72ca41c1b261aef18b4960dda889c798cbbd1/18-C-Train-W/Pictures/train19.gif -------------------------------------------------------------------------------- /18-C-Train-W/Pictures/train2.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/android-nuc/18-C-Train/ecd72ca41c1b261aef18b4960dda889c798cbbd1/18-C-Train-W/Pictures/train2.png -------------------------------------------------------------------------------- /18-C-Train-W/Pictures/train20.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/android-nuc/18-C-Train/ecd72ca41c1b261aef18b4960dda889c798cbbd1/18-C-Train-W/Pictures/train20.png -------------------------------------------------------------------------------- /18-C-Train-W/Pictures/train21.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/android-nuc/18-C-Train/ecd72ca41c1b261aef18b4960dda889c798cbbd1/18-C-Train-W/Pictures/train21.png -------------------------------------------------------------------------------- /18-C-Train-W/Pictures/train22.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/android-nuc/18-C-Train/ecd72ca41c1b261aef18b4960dda889c798cbbd1/18-C-Train-W/Pictures/train22.png -------------------------------------------------------------------------------- /18-C-Train-W/Pictures/train23.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/android-nuc/18-C-Train/ecd72ca41c1b261aef18b4960dda889c798cbbd1/18-C-Train-W/Pictures/train23.png -------------------------------------------------------------------------------- /18-C-Train-W/Pictures/train24.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/android-nuc/18-C-Train/ecd72ca41c1b261aef18b4960dda889c798cbbd1/18-C-Train-W/Pictures/train24.png -------------------------------------------------------------------------------- /18-C-Train-W/Pictures/train25.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/android-nuc/18-C-Train/ecd72ca41c1b261aef18b4960dda889c798cbbd1/18-C-Train-W/Pictures/train25.png -------------------------------------------------------------------------------- /18-C-Train-W/Pictures/train3.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/android-nuc/18-C-Train/ecd72ca41c1b261aef18b4960dda889c798cbbd1/18-C-Train-W/Pictures/train3.jpg -------------------------------------------------------------------------------- /18-C-Train-W/Pictures/train4.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/android-nuc/18-C-Train/ecd72ca41c1b261aef18b4960dda889c798cbbd1/18-C-Train-W/Pictures/train4.png -------------------------------------------------------------------------------- /18-C-Train-W/Pictures/train5.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/android-nuc/18-C-Train/ecd72ca41c1b261aef18b4960dda889c798cbbd1/18-C-Train-W/Pictures/train5.jpg -------------------------------------------------------------------------------- /18-C-Train-W/Pictures/train6.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/android-nuc/18-C-Train/ecd72ca41c1b261aef18b4960dda889c798cbbd1/18-C-Train-W/Pictures/train6.jpg -------------------------------------------------------------------------------- /18-C-Train-W/Pictures/train7.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/android-nuc/18-C-Train/ecd72ca41c1b261aef18b4960dda889c798cbbd1/18-C-Train-W/Pictures/train7.png -------------------------------------------------------------------------------- /18-C-Train-W/Pictures/train8.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/android-nuc/18-C-Train/ecd72ca41c1b261aef18b4960dda889c798cbbd1/18-C-Train-W/Pictures/train8.png -------------------------------------------------------------------------------- /18-C-Train-W/Pictures/train9.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/android-nuc/18-C-Train/ecd72ca41c1b261aef18b4960dda889c798cbbd1/18-C-Train-W/Pictures/train9.png -------------------------------------------------------------------------------- /18-C-Train-W/code.md: -------------------------------------------------------------------------------- 1 | # codes of 18-C-Train 2 | 3 | 4 | 5 | ## 文件 6 | 7 | ```c 8 | #include "stdio.h" 9 | #include "stdlib.h" 10 | int main() 11 | { 12 | char ch; //定义一个字符串 13 | int i = 0; 14 | ch = getchar(); 15 | while(ch != '\n'); 16 | { 17 | i = fputc(ch,fp); // 以字符为单位，写入到text.txt文件 18 | if(i == -1) 19 | { 20 | puts("字符写入失败！"); 21 | exit(0); 22 | } 23 | ch = getchar(); 24 | } 25 | 26 | int value = fclose(fp); 27 | if(value != 0) 28 | { 29 | puts("文件关闭失败！"); 30 | exit(0); 31 | } 32 | puts("文件关闭成功！"); 33 | return 0; 34 | } 35 | ``` 36 | 37 | ```c 38 | #include "stdio.h" 39 | #include "stdlib.h" 40 | 41 | struct info 42 | { 43 | short no; 44 | char name[20]; 45 | char sex[10]; 46 | }; 47 | int main() 48 | { 49 | //定义一个指向文件类型的指针 50 | FILE *fp; 51 | //打开一个已有的文件 52 | fp = fopen("D:\\Desktop\\text.txt","w"); 53 | if(fp == NULL ) 54 | { 55 | printf("打开文件失败！\n"); 56 | exit(0); 57 | } 58 | printf("打开文件成功！\n"); 59 | 60 | 61 | struct info info_st[3] ={ 62 | {1,"baoqianyue","men"}, 63 | {2,"lihao","men"}, 64 | {3,"wanghao","men"} 65 | }; 66 | for(int i = 0;i < 3;i ++) 67 | { 68 | fprintf(fp,"No = %d\tname = %-8s\tsex = %-6s\n",info_st[i].no, 69 | info_st[i].name,info_st[i].sex); 70 | } 71 | int value = fclose(fp); 72 | if(value != 0) 73 | { 74 | puts("文件关闭失败！"); 75 | exit(0); 76 | } 77 | puts("文件关闭成功！"); 78 | return 0; 79 | } 80 | ``` -------------------------------------------------------------------------------- /C-语言-考核题目.md: -------------------------------------------------------------------------------- 1 | # C-语言-考核题目 2 | 3 | ### 1.使用链表实现两个1000 * 1000的矩阵相乘 4 | 5 | 6 | ![wotou.jpg](https://upload-images.jianshu.io/upload_images/9140378-47e0b36c94cc844d.jpg?imageMogr2/auto-orient/strip%7CimageView2/2/w/440) 7 | 8 | ### 2.通过指针将一个单链表倒序 9 | 10 | + 创建新链表 11 | + 在已有链表的基础上将原链表内容倒序 12 | 13 | ### 3.宿舍管理系统 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 | ```c 56 | // 这里只定义一个数据 57 | typedef struct Student_info{ 58 | int a; //这里先定义一个int型的数据 59 | struct Student_info *next; //定义结构体指针 60 | } Stu； 61 | ``` 62 | 63 | + 动态创建 64 | 65 | ```c 66 | 这里写了一个结构体中只有一个数据的链表的创建的例子： 67 | 首先从键盘获取想要录入的学生个数 m 68 | 创建链表需要三个指针，p_head指向头节点，p_new指向新创建结构体，q指针用于连接链表 69 | for(int i = 0;i < m;i ++) 70 | { 71 | int data = 0; //定义常量用来保存结构体里的信息，这里只有 a 72 | scanf("%d",&data); 73 | p = (Stu *)malloc(sizeof(Stu)); 74 | p->a = data; //为新开辟结点赋值 75 | p->next = NULL; 76 | if(a == 1) //如果是第一个结点，即链表还没有形成，p_head跟q都指向p,因为只有一个节点; 77 | { 78 | p_head = p; 79 | q = p; 80 | } 81 | else 82 | { 83 | q->next = p; //链表已经存在，就将q的next指针指向新开辟的新的结构体 84 | q = p; //将指针q指向p,也就是现在这个链表的最后一个结点，用于下次循环，链接新的结点 85 | } 86 | } 87 | //这样就创建了一个储存了m个学生信息的链表，这里的学生信息只有一个a,只做演示 88 | ``` 89 | 90 | + 遍历输出 91 | 92 | ```c 93 | 仿照这个例子： 94 | void printf(Stu *p_head) //传入链表的头节点 95 | { 96 | Stu *p = p_head; //定义结构体指针指向头节点 97 | if（p）//想一下这里,是p还是p->next 98 | { 99 | printf("链表为空！\n"); 100 | exit(0); 101 | } 102 | //如果到最后一个结点，while(p)还是ture,然后打印出最后一个结点的值，p = p->next(NULL) 103 | //之后就跳出循环 104 | while(p) 105 | { 106 | printf("%d ",p->a); 107 | p = p->next; 108 | } 109 | printf("\n"); 110 | } 111 | //这样就打印出了链表中的信息 112 | ``` 113 | 114 | + 查询 115 | 116 | ```c 117 | 仿照下面的这个例子： 118 | void (Stu *p_head,int a) //在链表中查找值为a的结点，并打印全部所属信息 119 | { 120 | Stu *p = p_head; 121 | while(p && p->a != a) 122 | p = p->next; 123 | printf("%d...",p->a...); 124 | } 125 | ``` 126 | 127 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # 2018-C语言培训 2 | > 本次培训采用C99标准 3 | > 本次培训采用C99标准 4 | # Hello World 5 | - #### 你好，世界！ 6 | ``` C 7 | #include // 包含另一个文件 8 | 9 | /* 这是一个简单的演示程序 */ 10 | int main() // 函数名 11 | { // 函数体开始 12 | int num; // 声明 13 | num = 1; // 赋值表达式语句 14 | printf("Hello World\n"); // 调用函数 15 | return 0; // return 语句 16 | } // 结束 17 | ``` 18 | - #### 程序细节 19 | - `#include`：这行代码是C语言预编译指令 20 | - `int main()函数`：C语言程序一定是从`main()`函数开始执行，并且一个项目只能有一个`main`函数。 21 | - `void main()`：注意，一些编译器允许这样写，但是所有的标准都未认可这种写法。而`int main()`是标准写法，使用标准写法，在将程序从一个编译器切换到另一个编译器时一般不会出现什么问题。 22 | - `/* ... */`：这是C语言中的注释，它允许同时注释多行。对于单行注释也可使用`//`。 23 | - `{ ... }`：这是花括号，一般而言，所有C函数都要使用花括号标记函数体的开始和结束。 24 | - `int num`：这是声明，声明一个变量一般形式是`关键字 标识符`，例如`char str`。 25 | - `num = 1`：赋值表达式语句。 26 | - `printf()`：这是C语言的一个标准输出函数。括号中的`Hello World\n`是这个函数的`实际参数`。 27 | - `return 0`：C语言标准中，要求main()函数返回0。但如果省略不写这一句呢？程序在运行至最外面的右花括号时会返回0。因此，可以省略main()函数的`return`语句，但是不要在其他有返回值的函数中漏掉它。强烈建议读者养成在main()函数中保留`return`语句的好习惯。 28 | 29 | - #### 代码编写规范 30 | - 标识符命名规范：标识符只能由字母、数字和下划线组成，并且第一个字符必须是字母或下划线 31 | - 变量名应该有具体含义 32 | - 每条语句占一行 33 | - 对齐缩进4个空格字符 34 | - ... 35 | 36 | 37 | # 数据类型 38 | - #### C数据类型 39 | ![type](https://github.com/android-nuc/17-C-Train/raw/master/image/c_language.png) 40 | 41 | - #### 什么是位、字节和字 42 | > 位、字节和字是描述计算机数据单元或存储单元的术语。
43 | > 最小的存储单元是位(bit)，可以储存0或1.虽然1位储存的信息有限，但是计算机中位的数量十分庞大。位是计算机内存的基本构建块。
44 | > 字节(byte)是常用的计算机存储单位。对于几乎所有的机器，1字节均为8位。这是字节的标准定义，至少在衡量存储单位时是这样。既然1位可以表示0或1，那么8位字节就有256（2的8次方）种可能的0、1组合。通过二进制编码（仅用0和1便可表示数字），便可表示0~255的整数或一组字符。
45 | > 字(word)是设计计算机时给定的自然存储单位，对于8位的微型计算机（如，最初的苹果机），1个字长只有8位。从那以后，个人计算机字长增至16位、32位，直到目前的64位，计算机的字长越大，其数据转移越快，允许的内存访问也快的多。
46 | > ————《C Primer Plus》 47 | 48 | `注意：C语言把1字节定义为char类型占用的位(bit)数。通常，char类型被定义为8位的存储单元。` 49 | 50 | - #### 整数类型 51 | 52 | |类型|存储大小|值范围| 53 | |-|-|-| 54 | |`char`|1 byte|`-128 到 127 或 0 到 255`| 55 | |unsigned char|1 byte|0 到 255| 56 | |signed char|1 byte|-128 到 127| 57 | |int|2 或 4 bytes|-32,768 到 32,767 或 -2,147,483,648 到 2,147,483,647| 58 | |unsigned int|2 或 4 bytes|0 到 65,535 或 0 到 4,294,967,295| 59 | |short|2 bytes|-32,768 到 32,767| 60 | |unsigned short|2 bytes|0 到 65,535| 61 | |long|4 bytes|-2,147,483,648 到 2,147,483,647| 62 | |unsigned long|4 bytes|0 到 4,294,967,295| 63 | 64 | 不同平台上数据类型的取值范围有所差异，为了得到某个类型或某个变量在特定平台上的准确大小，可以使用`sizeof`运算符，得到对象或类型的存储字节大小。 65 | 66 | ``` C 67 | #include 68 | 69 | int main() 70 | { 71 | printf("Storage size for int : %d \n", sizeof(int)); 72 | return 0; 73 | } 74 | ``` 75 | 输出： 76 | ``` 77 | Storage size for int : 4 78 | ``` 79 | 按照1个字节8位计算，那4个字节能够存储$2^{4*8}$，即$2^{32} = 4294967296$，正负数各分一半，也就是-2,147,483,648 到 2,147,483,647。 80 | 81 | 82 | 83 | - #### 浮点类型 84 | 85 | 类型|存储大小|值范围|精度 86 | |-|-|-|-| 87 | float|4 byte|1.2E-38 到 3.4E+38|6 位小数 88 | double|8 byte|2.3E-308 到 1.7E+308|15 位小数 89 | long double|10 byte|3.4E-4932 到 1.1E+4932|19 位小数 90 | 91 | - #### 基本数据类型所占字节数与三个方面因素有关 92 | - CPU位宽（即你的CPU是多少为的） 93 | - 操作系统位宽（笼统说就是操作系统位数，操作系统位宽取决于CPU位宽） 94 | - 编译器类型和版本 95 | 96 | - #### 整型溢出 97 | 98 | 99 | - EX.1
100 | 计算机中的计算只有二进制加法。因此，计算机在计算时实际上是取它们的补码进行加法运算。 101 | ``` C 102 | unsigned int a; 103 | int b = -1; 104 | a = b; 105 | printf("a=%u",a); 106 | ``` 107 | 输出： 108 | ``` 109 | a=4294967295 110 | ``` 111 | 让我们来分析一下，
112 | 首先int型的-1，对应二进制
113 | 取原码：`1000000000000000000000000000001`
114 | 取反码：`1111111111111111111111111111110`
115 | 取补码：`1111111111111111111111111111111`
116 | 而`unsigned int`型最大值对应的补码也是它，因此在赋值给`a`后，就得到了它的最大值。 117 | 118 | - EX.2
119 | 如果整数超出了相应类型的取值范围会怎样？ 120 | ``` C 121 | #include 122 | 123 | int main() 124 | { 125 | int i = 2147483647; 126 | unsigned int j = 4294967295; 127 | printf("%d %d %d\n", i, i+1, i+2); 128 | printf("%u %u %u\n", j, j+1, j+2); 129 | 130 | return 0; 131 | } 132 | ``` 133 | 输出： 134 | ``` 135 | 2147483647 -2147483648 -2147483647 136 | 4294967295 0 1 137 | ``` 138 | 从输出结果不难发现，当达到它们能表示的最大值时，会重新从起点开始。只不过`unsigned int`最小值为0，而`int`型最小值为-2147483648。 139 | 140 | [关于原码、反码和补码更多介绍](https://www.cnblogs.com/zhangziqiu/archive/2011/03/30/ComputerCode.html) 141 | 142 | # 明示常量：#define 143 | 编译时，在预处理阶段，预处理器会查找一行中以`#`号开始的预处理指令。预处理指令从`#`号开始执行，到后面的第一个换行符为止。也就是说，指令的长度仅限于一行（逻辑行）。 144 | 145 | - **类对象宏** 146 | ![obj](img/1.jpg) 147 | 148 | 宏的名称同样需要遵守C变量的命名规则：只能使用字符、数字和下划线，且首字符不能是数字。
149 | 可以把它看做是一种记号，程序在编译时会把记号替换为它对应的值。 150 | 151 | 例子： 152 | ``` C 153 | #include 154 | #define WORD "Hello World!" 155 | #define OP 6+6 156 | #define LINE 10 157 | 158 | int main() 159 | { 160 | char str[15] = WORD; 161 | int sum = OP; 162 | 163 | for(int i = 0; i < LINE; i++) 164 | { 165 | printf("%d\t%s\t%d\n", i, str, sum); 166 | } 167 | 168 | return 0; 169 | } 170 | ``` 171 | 172 | - **类函数宏**
173 | 类函数宏可以像函数那样传入参数，它的组成如下 174 | 175 | ![2](img/2.jpg) 176 | 177 | 例子： 178 | ``` C 179 | #include 180 | #define MEAN(X,Y) ((X)+(Y))/2 181 | 182 | int main() 183 | { 184 | int mean = MEAN(10, 20); 185 | printf("%d", mean); 186 | 187 | return 0; 188 | } 189 | ``` 190 | - 注意：`预处理器不做计算、不求值、只替换字符序列`！！ 191 | 192 | ``` C 193 | #include 194 | #define SQUARE(X) X*X 195 | 196 | int main() 197 | { 198 | int x = 5; 199 | printf("%d\n", SQUARE(x)); 200 | printf("%d\n", SQUARE(x+2)); 201 | printf("%d\n", 100/SQUARE(2)); 202 | 203 | return 0; 204 | } 205 | ``` 206 | 预处理器仅仅是在编译时替换了字符序列，所以在写替换体时，一定要注意参数的作用范围。此处出现的问题可以通过添加括号解决：`(X)*(X)`。 207 | 208 | - **常用的宏** 209 | ``` C 210 | #define MAX(X,Y) ((X) > (Y) ? (X) : (Y)) 211 | #define ABS(X) ((X) < 0 ? -(X) : (X)) 212 | #define ISSIGN(X) ((X) == '+' || (X) == '-' ? 1 : 0) 213 | ``` 214 | 再次强调，宏只是在程序编译时，替换掉记号位置的字符序列。 215 | 216 | # 常用运算符 217 | - 常用运算符 218 | 219 | 赋值|自增自减|算术|逻辑|比较|成员访问|其他 220 | |:-:|:-:|:-:|:-:|:-:|:-:|:-:| 221 | a = b
a += b
a -= b
a *= b
a /= b
a %= b
a &= b
a |= b
a ^= b
a <<= b
a >>= b|++a
--a
a++
a--
|+a
-a
a + b
a - b
a * b
a / b
a % b
~a
a & b
a | b
a ^ b
a << b
a >> b
|!a
a && b
a || b
|a == b
a != b
a < b
a > b
a <= b
a >= b
|a[b]
*a
&a
a->b
a.b
|a(...)
a, b
(type) a
? :
sizeof
_Alignof (C11 起) 222 | 223 | [关于C运算符优先级](https://zh.cppreference.com/w/c/language/operator_precedence) 224 | - 位运算符 225 | 226 | |运算符|含义|描述| 227 | |-|-|-| 228 | |&|按位与|如果两个相应的二进制位都为1，则该位的结果值为1，否则为0| 229 | |||按位或|两个相应的二进制位中只要有一个为1，该位的结果值为1| 230 | |^|按位异或|若参加运算的两个二进制位值相同则为0，否则为1| 231 | |~|取反|~是一元运算符，用来对一个二进制数按位取反，即将0变1，将1变0| 232 | |<<|左移|用来将一个数的各二进制位全部左移N位，右补0| 233 | |>>|右移|将一个数的各二进制位右移N位，移到右端的低位被舍弃，对于无符号数，高位补0| 234 | 235 | 236 | - `i++`与`++i` / `i--`与`--i` 237 | - ++ 在前面叫做前自增（例如 ++a）。前自增先进行自增操作，再进行其他操作。 238 | - ++ 在后面叫做后自增（例如 a++）。后自增先进行其他操作，再进行自增操作。 239 | - 自增自减完成后，会用新值替换旧值，并将新值保存在当前变量中。 240 | - 自增自减只能针对变量，不能针对数字。 241 | 242 | 例子： 243 | ``` C 244 | #include 245 | 246 | int main() 247 | { 248 | int a = 5; 249 | printf("%d\n", ++a); 250 | printf("%d\n", a++); 251 | 252 | return 0; 253 | } 254 | ``` 255 | - `sizeof` 256 | - 它以字节为单位返回运算对象的大小。 257 | - 对于实值，可省略括号，其他情况不能省略括号。 258 | - 根据代码的一致性，建议在所有情况下都不要省略括号。 259 | ``` C 260 | #include 261 | 262 | int main() 263 | { 264 | int a = 5; 265 | printf("%d\n", sizeof a); 266 | printf("%d\n", sizeof int); // 报错 267 | printf("%d\n", sizeof(int)); 268 | 269 | return 0; 270 | } 271 | ``` 272 | 273 | # printf()和scanf() 274 | 这两个函数都采用格式化输入输出，每种数据类型都要使用它对应`转换说明`才能正常输入输出。例如整数要用`%d`，字符要用`%c`。这些符号称为`转换说明`，它们指定了如何把数据转换成可显示的格式。 275 | 276 | ### printf() 277 | - 转换说明及其打印的输出结果 278 | 279 | 转换说明|输出 280 | |-|-| 281 | %a,%A|浮点数、十六进制数和p计数法(C99/C11) 282 | %c|一个字符 283 | %d|有符号十进制数 284 | %e,%E|浮点数,e计数法 285 | %f|浮点数，十进制计数法 286 | %g,%G|根据数值不同自动选择%f或%e, %e格式在指数小于-4或者大于等于精度时使用 287 | %i|有符号十进制整数(与%d相同) 288 | %o|无符号八进制整数 289 | %p|指针 290 | %s|字符串 291 | %u|无符号十进制数 292 | %x,%X|使用十六进制数0f的无符号十六进制整数 293 | %%|打印一个百分号 294 | 295 | - 有时字符串比较长，需要放在多行 296 | ``` C 297 | #include 298 | 299 | int main() 300 | { 301 | printf("Do not believe what is passed from mouth; \ 302 | Do not believe rumors ; Do not believe the \ 303 | infallibility of texts") ; 304 | 305 | return 0; 306 | } 307 | ``` 308 | 309 | ### scanf() 310 | scanf()函数使用空白（换行符、制表符和空格）把输入分成多个字段。在依次把转换说明和字段匹配时跳过空白。 311 | > `%c转换说明`:它是一个例外，它会读取每个字符，包括空白。 312 | 313 | - #### 格式字符串中的普通字符 314 | scanf()函数允许把普通字符放在格式字符串中，这个时候要求，除空格字符外的普通字符必须与输入字符串严格匹配。例如 315 | ``` C 316 | printf("%d,%d,%d", &a, &b, &c); 317 | ``` 318 | 那么它对应的输入必须是这种格式 319 | ``` 320 | 1,2,3 321 | ``` 322 | 323 | - #### 细化scanf()输入 324 | ![4](img/4.jpg) 325 | - 假设scanf()根据一个%d转换说明读取一个整数。 326 | 327 | scanf()函数每次读取一个字符，跳过所有空白字符，直至遇到第1个非空白字符才开始读取。scanf()不断地读取和保存字符，直至遇到非数字字符。如果遇到非数字字符，它便认为到了整数的末尾。然后scanf()把非数字字符放回输入。 328 | 329 | - 如果第1个非空白字符(记为A)不是数字会怎么样？ 330 | 331 | scanf()将会停在那里，并把A放回输入中，不会把值赋给指定变量。程序在下一次读取输入时，首先读到的字符是A。如果程序只用了%d转换说明，那么scanf()就一直无法越过A读取下一个字符。另外，如果使用带了`多个`转换说明的scanf()，C规定在第1个出错出停止读取输入。 332 | 333 | - %s: 334 | 335 | scanf()会跳过空白，读取非空白字符，也就是说通过`%s`读取的字符串不含空白。需要注意的是，当scanf()把字符串放进指定数组中时，它会在字符序列的末尾加上`\0`。 336 | 337 | - #### scanf()的返回值 338 | scanf()函数返回成功读取的项数。如果没有任何读取项，且需要读取一个数字而用户却输入一个非数值字符串，scanf()便返回0。当检测到“文件结尾”时，会返回`EOF`。
339 | 例子： 340 | ``` C 341 | #include 342 | 343 | int main() 344 | { 345 | char a[20]; 346 | int sign, b, c; 347 | while(true) 348 | { 349 | sign = scanf("%s %d %d", a, &b, &c); 350 | printf("返回:%d\n", sign); 351 | } 352 | 353 | return 0; 354 | } 355 | ``` 356 | 357 | 由此可作为输入时的循环条件 358 | ``` C 359 | while (~scanf("%d %d",&n,&m)) 等效于 while (scanf("%d %d",&n,&m) != EOF) 360 | ``` 361 | 362 | - #### 其他输入输出 363 | - getchar() 364 | - putchar() 365 | - gets() 366 | - puts() 367 | 368 | 369 | # 分支语句 370 | - #### if 371 | > **形式：** 372 | > ``` C 373 | > if ( expression2 ) 374 | > statement1 375 | > else if ( expression2 ) 376 | > statement2 377 | > else 378 | > statement3 379 | > ``` 380 | > 如果expression1为真，执行statement1部分；如果expression2为真，执行statement2部分；否则，执行statement3部分 381 | 382 | - 在写条件时，注意优先级。例如下面错误的判断是否为字母 383 | ``` C 384 | if(ch >= 'a' && ch <= 'z' || ch >= 'A' && ch <= 'Z') 385 | { 386 | printf("is alphabet") 387 | } 388 | ``` 389 | 390 | - #### 三元运算符：? : 391 | > 条件运算符需要3个运算对象，每个运算对象都是一个表达式。 392 | > *expression1* ? *expression2* : *expression3* 393 | > 如果*expression1*为真，整个条件表达式的值是*expression2*的值；否则，是*expression3*的值。 394 | 395 | 它可以与`if else`等效，例如 396 | ``` C 397 | x = (y < 0) ? -y : y; 398 | 399 | // 等效于 400 | if (y < 0) 401 | x = -y; 402 | else 403 | x = y; 404 | ``` 405 | 406 | - #### 多重选择：switch语句 407 | > **形式：** 408 | > ``` C 409 | > switch( expression ) 410 | > { 411 | > case label1: statement1 // 使用break跳出switch 412 | > case label2: statement2 413 | > default: statement3 414 | > } 415 | > ``` 416 | > 可以有多个标签语句，default语句可选。
417 | > **注解：**
418 | > 程序根据expression的值跳转至相应的case标签处，然后，执行剩下的所有语句，除非执行到break语句进行重定向。expression和case标签都必须是整数值（包括char类型），标签必须是常量或完全由常量组成的表达式，如果没有case标签与expression的值匹配，控制则转至标有default的语句（如果有的话）；否则，将转至执行紧跟在wwitch语句后面的语句。 419 | 420 | - EX：统计一段话中元音字母个数。 421 | ``` C 422 | #include 423 | 424 | int main() 425 | { 426 | int count = 0; 427 | char ch; 428 | while((ch = getchar()) != '\n') 429 | { 430 | switch(ch) 431 | { 432 | case 'a': 433 | case 'A': 434 | count++; 435 | break; 436 | case 'e': 437 | case 'E': 438 | count++; 439 | break; 440 | case 'i': 441 | case 'I': 442 | count++; 443 | break; 444 | case 'o': 445 | case 'O': 446 | count++; 447 | break; 448 | case 'u': 449 | case 'U': 450 | count++; 451 | break; 452 | } 453 | } 454 | printf("count: %d", count); 455 | 456 | return 0; 457 | } 458 | ``` 459 | 460 | 461 | # 循环语句 462 | 463 | ### 入口条件循环 464 | 顾名思义，入口条件循环就是在循环的每次迭代之前检查测试条件，所以它有可能根本不执行循环体中的内容。 465 | - #### while循环 466 | > **形式:** 467 | > ``` C 468 | > while( expression ) 469 | > statement 470 | > ``` 471 | > 在*expression*部分为假之前，重复执行*statement*部分。 472 | 473 | 循环输入的例子： 474 | ``` C 475 | #include 476 | 477 | int main() 478 | { 479 | char ch; 480 | while(scanf("%c", &ch) != EOF) 481 | { 482 | if(ch >= '0' &&ch <= '9') 483 | printf("%c", ch); 484 | } 485 | 486 | return 0; 487 | } 488 | ``` 489 | - **何为真假？**
490 | 在C语言中这个很好判断，不为0的数就是`真`，即-1,-1000,1,100都为真。只有0为`假`。
布尔型的`True == 1`、`False == 0`。 491 | - EX.1：若成功输入，预测下面代码执行结果。 492 | ``` C 493 | #include 494 | 495 | int main() 496 | { 497 | int num, status; 498 | int sum = 0; 499 | 500 | status = scanf("%d", &num); 501 | 502 | while(status = 1) 503 | { 504 | sum += num; 505 | if(sum >= 10) 506 | status = 0; 507 | } 508 | printf("%d", sum); 509 | 510 | return 0; 511 | } 512 | ``` 513 | 出现了死循环，`while(status = 1)`实际上相当于`while(1)`，此时入口条件永为真。
514 | 这种错误，程序在编译时，编译器一般不会报错（现代编译器会发出警告），为避免出现这种误用情况，经验丰富的程序员一般会把数写在等号左边，这样如果出现误写，在编译时会报错。 515 | ``` C 516 | 1 = status // 语法错误 517 | 1 == status // 返回真假 518 | ``` 519 | 520 | - **空语句**
521 | 在C语言中，单独的分号表示空语句。有时程序员会故意使用带空语句的while语句，例如，假设你想跳过输入到第1个非空白字符或数字，可以这样写。 522 | ``` C 523 | while(scanf("%d", &num) == 1) 524 | ; // 跳过整数输入 525 | ``` 526 | 防止误用空语句。以下是常见的几种误用，大括号中的语句仅执行了一次 527 | ``` C 528 | int i = 0; 529 | while(i > 5); 530 | { 531 | i++; 532 | printf("%d", i); 533 | } /* 输出：1*/ 534 | 535 | 536 | int i; 537 | for(i = 0; i < 5; i++); 538 | { 539 | printf("%d", i); 540 | } /* 输出：5*/ 541 | 542 | 543 | int i = 5; 544 | if(i > 999); 545 | { 546 | printf("%d", i); 547 | } /* 输出：5*/ 548 | ``` 549 | 550 | - #### for循环 551 | for循环把初始化、测试和更新三个行为组合在了一处。 552 | > **形式：** 553 | > ``` C 554 | > for ( initialize; test; update ) 555 | > statement 556 | > ``` 557 | > 在*test*为假或0之前，重复执行*statement*。
558 | > **注解：**
559 | > for语句使用3个表达式控制循环过程，分别用分号隔开。initialize表达式在执行for语句之前只执行一次；然后对test表达式求值，如果表达式为真（或非零），执行循环一次；接着对update表达式求值，并再次检查test表达式。for语句是一种入口条件循环，即在执行循环之前就决定了是否执行循环。因此，for循环可能一次都不执行，statement部分可以是一条简单语句或复合语句。 560 | 561 | - 输出1到200的奇数，十个为一行 562 | ``` C 563 | #include 564 | 565 | int main() 566 | { 567 | int i; 568 | for (i = 1; i <= 200; i+=2) 569 | { 570 | printf("%d", i); 571 | printf("%c", (i + 1) % 20 ? '\t': '\n' ); 572 | } 573 | 574 | return 0; 575 | } 576 | ``` 577 | 578 | - #### 逗号运算符 579 | > 逗号运算符把两个表达式连接成一个表达式，并保证最左边的表达式最先求值，逗号运算符通常在for循环头的表达式中用于包含更多的信息。整个逗号表达式的值是逗号右侧表达式的值。 580 | 581 | 上个例子还可以这样写。 582 | ``` C 583 | #include 584 | 585 | int main() 586 | { 587 | int i, k; 588 | for (i = 1, k = 1; i <= 200; i+=2, k++) 589 | { 590 | printf("%d", i); 591 | if(k % 10 == 0) 592 | printf("\n"); 593 | else 594 | printf("\t"); 595 | } 596 | 597 | return 0; 598 | } 599 | ``` 600 | - 防止误用逗号运算符
601 | 举个例子，假如你正在给一个表示房价的变量赋值，它在书上表示的是`$295,500`，然后你在输入的时候，不小心把逗号也输入进去了。 602 | ``` C 603 | houseprice = 259,500; 604 | ``` 605 | 结果是houseprice的值被赋为了500。这不是语法错误，C编译器会将其解释为一个逗号表达式。以逗号为分隔，`500`成了一条语句，由于它位于表达式的最右侧，所有就是这个表达式的值。 606 | 607 | - #### while or for 608 | 这两个循环可以做到互相等价，例如： 609 | ``` C 610 | for(; test ; ){} 611 | 612 | /* 等效于 */ 613 | while (test){} 614 | ``` 615 | ``` C 616 | 初始化; 617 | while( 测试 ) 618 | { 619 | 其他语句 620 | 更新语句 621 | } 622 | 623 | /* 等效于 */ 624 | for( 初始化; 测试 ; 更新 ) 625 | 其他语句 626 | 627 | ``` 628 | 一般而言，当循环涉及初始化和更新变量时，用for循环比较合适，而在其他情况下用while循环更好。 629 | 630 | ### 出口条件循环：do while 631 | 出口条件循环，即在循环的每次迭代之后检查测试条件，这保证了至少执行循环体中的内容一次。 632 | > **形式：** 633 | > ```C 634 | > do 635 | > statement 636 | > while( expression ); 637 | > ``` 638 | > 在*test*为假或0之前，重复执行statement部分 639 | 640 | - 验证密码 641 | ``` C 642 | #include 643 | #define PASSWORD 123456 644 | 645 | int verify_password(int num) 646 | { 647 | if(num == PASSWORD) 648 | return 0; 649 | else 650 | return 1; 651 | } 652 | 653 | int main() 654 | { 655 | int password; 656 | do 657 | { 658 | printf("Please enter password:"); 659 | scanf("%d", &password); 660 | } 661 | while(verify_password(password)); 662 | printf("success!"); 663 | 664 | return 0; 665 | } 666 | ``` 667 | 668 | - #### 跳出循环 669 | - `continue`：**结束本次**循环，进行下一次循环 670 | - `break`：**终止**循环不再进行 671 | 672 | 673 | ### 函数 674 | 代码示例： 675 | ``` C 676 | #include 677 | 678 | int max(int, int); // 函数原型 679 | 680 | int main() 681 | { 682 | int a, b, num; 683 | scanf("%d %d", &a, &b); 684 | num = max(a, b); // 函数调用 685 | printf("%d", num); 686 | 687 | return 0; 688 | } 689 | 690 | int max(int a, int b) // 函数定义 691 | { 692 | return a > b ? a : b; // 返回int类型的值 693 | } 694 | ``` 695 | - 什么是函数签名？
696 | 函数的返回类型和形参列表构成了函数签名。因此函数签名指定了传入函数的值的类型和函数值的类型。 697 | 698 | - 函数原型的作用
699 | 之所以使用函数原型，是为了让编译器在第1此执行到该函数之前就知道如何使用它。
既然是告知编译器如何使用它，那么肯定有等效的方法能省略它。例如上面的代码 700 | ``` C 701 | int max(int a, int b) // 函数定义 702 | { 703 | return a > b ? a : b; // 返回int类型的值 704 | } 705 | 706 | int main() 707 | { 708 | int a, b, num; 709 | scanf("%d %d", &a, &b); 710 | num = max(a, b); // 函数调用 711 | printf("%d", num); 712 | 713 | return 0; 714 | } 715 | ``` 716 | 只需要在调用子函数之前，让编译器知道它的存在即可。 717 | 718 | - 同名函数
719 | 在支持ANSI C的编译器下，可以使用相同的名称命名多个函数，只要它的函数签名不同即可。注意在g++编译器下，不允许这样的操作。 720 | 举个例子： 721 | ``` C 722 | #include 723 | 724 | int max(int, int); // 函数原型 725 | char max(char, char); 726 | 727 | int main() 728 | { 729 | int a, b; 730 | char ch1, ch2; 731 | 732 | scanf("%d %d", &a, &b); 733 | printf("max: %d\n\n", max(a, b)); 734 | 735 | getchar(); // 读取换行 736 | scanf("%c %c", &ch1, &ch2); 737 | printf("char is %c and %c\n", ch1, ch2); 738 | printf("max: %c\n", max(ch1, ch2)); 739 | 740 | return 0; 741 | } 742 | 743 | int max(int a, int b) // 函数定义 744 | { 745 | return a > b ? a : b; // 返回int类型的值 746 | } 747 | 748 | char max(char a, char b) 749 | { 750 | return a > b ? a : b; 751 | } 752 | ``` 753 | - #### 了解：与指针相关的运算符 754 | > **地址运算符：&** 755 | > **注解**：后跟一个变量名时，&给出该变量的地址 756 | > **示例**：&house表示变量house的地址。 757 | 758 | > **地址运算符：*** 759 | > **注解**：后跟一个指针名或地址时，*给出储存在指正指向地址上的值。 760 | > **示例**：
761 | > ``` C 762 | > house = 22; 763 | > ptr = &house; // 指向house指针 764 | > value = *ptr; // 把ptr指向的地址上的值赋给value 765 | > ``` 766 | 767 | - #### 引用 768 | 函数的形参如果是地址，可以称为引用变量。此时修改形参的值，将会直接影响实参的值。 769 | 举个例子 770 | ``` C 771 | #include 772 | 773 | void find_max(int a, int b, int &max) 774 | { 775 | max = a > b ? a : b; 776 | } 777 | 778 | int main() 779 | { 780 | int a, b, max; 781 | scanf("%d %d", &a, &b); 782 | find_max(a, b, max); 783 | printf("max: %d\n", max); 784 | 785 | return 0; 786 | } 787 | ``` 788 | 在子函数中给`max`变量赋值，也会直接影响main函数中的max的值。 789 | 790 | - #### 返回指针 791 | ``` C 792 | #include 793 | 794 | char *input() 795 | { 796 | char str[20]; 797 | scanf("%s", str); 798 | return &str[0]; 799 | } 800 | 801 | int main() 802 | { 803 | char *str = input(); 804 | printf("%s", str); 805 | 806 | return 0; 807 | } 808 | ``` 809 | - 思考：如果一个子函数，有多个同类型的值要返回怎么办呢？ 810 | 811 |
812 | 813 | 814 | 815 | ## 数组 816 | 817 | ### 为什么要用数组 818 | 819 | #### 一个典型的问题 820 | 821 | + 一次性获取用用户输入的十个整数，然后对每一个数据做平方处理然后输出，一般情况下，既然要一次获取10个整数,那么就必须定义十个变量来储存这是个数据，代码看起来已经非常的麻烦了，如果数量更大的话，就会更麻烦了，比如以下代码 822 | 823 | ```c 824 | int main() 825 | { 826 | int i1,i2,i3,i4 ... i10; 827 | scanf("%d%d%d ... %d",&i1,&i2,&i3 ... &i10); 828 | i1 *= i1; 829 | i2 *= i2; 830 | 831 | ..... 832 | 833 | printf("%d%d%d.....%d",i1,i2,i3....i10); 834 | } 835 | ``` 836 | 837 | + 为了对这种大量数据进行处理，C语言引进了数组 838 | 839 | ### 数组的定义和使用 840 | 841 | #### 定义数组 842 | 843 | + 在 C 中要声明一个数组，需要指定元素的类型和元素的数量，使用数组前，需要先定义数组，定义数组的格式如下： 844 | 845 | ```c 846 | 数据类型 数组名 [整形常量表达式], ... 847 | type arrayName [ arraySize ]; 848 | ``` 849 | 850 | + 数组由数据类型相同的一系列元素组成，需要使用该数组时，通过声明数组告诉编译器数组中含有多少元素和这些元素的类型，编译器根据这些信息正确的创建数组 ，例如： 851 | 852 | ```c 853 | int main() 854 | { 855 | float candy[365] /*内含有365个float类型元素的数组 */ 856 | char code[20]; /*内含有20个char类型元素的数组 */ 857 | int book[50]; /*内含有50个int类型元素的数组 */ 858 | } 859 | ``` 860 | 861 | #### 初始化数组 862 | 863 | + 数组的声明并不是声明一个个单独的变量，比如 number0、number1、...、number99，而是声明一个数组变量，比如 numbers 864 | + 如下代码所示，用以逗号分割的数值列表 (用花括号括起来) 来初始化数组 865 | 866 | ```c 867 | int main() 868 | { 869 | int numbers[8] = {1,2,4,5,7,9,12,435}; 870 | } 871 | ``` 872 | 873 | + 大括号 { } 之间的值的数目不能大于我们在数组声明时在方括号 [ ] 中指定的元素数目。如果你省略掉了数组的大小，数组的大小则为初始化时元素的个数。因此，如果执行以下的代码 将创建一个数组，它与前一个实例中所创建的数组是完全相同的。 874 | 875 | ```c 876 | double balance[] = {1000.0, 2.0, 3.4, 7.0, 50.0}; 877 | ``` 878 | 879 | 创建完的数组balance在内存中的结构： 880 | 881 |
882 | 883 | ![array_presentation.jpg](https://upload-images.jianshu.io/upload_images/9140378-1c77919410172241.jpg?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240) 884 | 885 |
886 | 887 | + 或者利用数组的下标进行赋值 888 | 889 | ```c 890 | //下面是一个为数组中某个元素赋值的实例： 891 | 892 | numbers[4] = 50.0; 893 | 894 | //下面是为数组的所有元素进行赋值 895 | 896 | int main() 897 | { 898 | int num[5]; 899 | for(int i = 0;i < 4;i ++) 900 | num[i] = i + 1; 901 | } 902 | ``` 903 | 904 | 创建完的数组的结构： 905 | 906 |
907 | 908 | ![train4.png](https://upload-images.jianshu.io/upload_images/9140378-67efb5f61143edf0.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/440) 909 | 910 |
911 | 912 | #### 通过数组下标访问数组的数值 913 | 914 | + 如下图所示，使用 numbers[0]、numbers[1]、...、numbers[99] 来代表一个个单独的变量。数组中的特定元素可以通过索引访问。所有的数组都是由连续的内存位置组成。最低的地址对应第一个元素，最高的地址对应最后一个元素。，数组的首位置的下标一定是0,下标的最大值一定是数组的长度 - 1 915 | 916 |
917 | 918 | ![train5.jpg](https://upload-images.jianshu.io/upload_images/9140378-a6be205a10460f5b.jpg?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240) 919 | 920 |
921 | 922 | + 数组边界 923 | 924 | 在访问数组元素时，要防止数组下标超出边界，也就是说，必须确保下标时有效的值，加入有下面的声明： 925 | 926 | ```c 927 | int bao[20]; 928 | ``` 929 | 930 | 那么在访问该数组时，要确保程序中使用的数组下标在 0 ~ 19 的范围内，因为编译器不会检查出这种错误，也就是说，编译运行照常通过，但看起来运行的结果很奇怪 931 | 假设我们访问数组下标以外的数值，例如： 932 | 933 | ```c 934 | #include "stdio.h" 935 | int main() 936 | { 937 | int lihao[3] = {1,2,3}; 938 | for(int i =0;i < 7;i ++) 939 | printf("%d\n",lihao[i]); 940 | return 0; 941 | } 942 | /* 943 | 1 944 | 2 945 | 3 946 | 3 947 | 11692832 948 | 0 949 | 4199400 950 | */ 951 | ``` 952 | 953 | + C是相信程序员能正确的编写程序，这样C可以运行的更快，所以访问数组时C是不检查边界的，但不是所有程序员可以做到这一点，所以才出现了这个数组下标越界的问题，所以建议大家在声明数组的时候使用符号常量来表达数组的大小 954 | 955 | ```c 956 | #define SIZE 4; 957 | int main() 958 | { 959 | int arr[SIZE]; 960 | for(int i = 0;i < SIZE;i ++) 961 | 962 | ... 963 | 964 | return 0; 965 | } 966 | ``` 967 | 968 | #### 数组的简单应用 969 | 970 | 两个经典的排序 971 | 972 | + 冒泡排序 973 | 974 |
975 | 976 | ![train7.png](https://upload-images.jianshu.io/upload_images/9140378-5eb8e56677da3aa4.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/350) 977 | 978 |
979 | 980 | + 比较相邻的元素。如果第一个比第二个大，就交换他们两个，就像把大的像泡泡一样“冒”到数组后面去 981 | + 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。 982 | + 针对所有的元素重复以上的步骤，除了最后一个。 983 | + 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。 984 | 985 | ```c 986 | int main() 987 | { 988 | int i = 0,j = 0; 989 | int a[10] = {3,1,4,1,5,9,2,6,5,4}; 990 | for(i = 0;i < 9;i ++) 991 | { 992 | int temp = 0; 993 | for(j = 0;j < 9 - i;j ++) 994 | { 995 | if(a[j] > a[j + 1]) 996 | { 997 | //将位置 j + 1 的数与位置j的数进行交换 998 | temp = a[j + 1]; 999 | a[j + 1] = a[j]; 1000 | a[j] = temp; 1001 | } 1002 | } 1003 | } 1004 | for (i = 0;i < 10;i ++) 1005 | printf("%d ",a[i]); 1006 | return 0; 1007 | } 1008 | 1009 | /* 1010 | 1 1 2 3 4 4 5 5 6 9 1011 | */ 1012 | ``` 1013 | 1014 | [动态演示 -- 冒泡排序算法可视化](https://visualgo.net/zh/sorting) 1015 | 1016 | + 选择排序 1017 | 1018 |
1019 | 1020 | ![train8.png](https://upload-images.jianshu.io/upload_images/9140378-0c2f621c106a60ed.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/380) 1021 | 1022 |
1023 | 1024 | + 选择排序（从小到大）的基本思想是，首先，选出最小的数，放在第一个位置；然后，选出第二小的数，放在第二个位置；以此类推，直到所有的数从小到大排序。 1025 | + 在实现上，我们通常是先确定第i小的数所在的位置，然后，将其与第i个数进行交换 1026 | 1027 | ```c 1028 | #include "stdio.h" 1029 | int main() 1030 | { 1031 | int i = 0,j = 0; 1032 | int temp = 0; 1033 | int a[10] = {3,1,4,1,5,9,2,6,5,4}; 1034 | for(i = 0;i < 9;i ++) 1035 | { 1036 | int pos = 0; 1037 | for(j = 1;j < 10 - i;j ++) 1038 | if(a[pos] < a[j]) 1039 | pos = j; 1040 | if(pos != 9 - i) 1041 | { 1042 | temp = a[9 - i]; 1043 | a[9 - i] = a[pos]; 1044 | a[pos] = temp; 1045 | } 1046 | } 1047 | for (i = 0;i < 10;i ++) 1048 | printf("%d ",a[i]); 1049 | return 0; 1050 | } 1051 | /* 1052 | 1 1 2 3 4 4 5 5 6 9 1053 | */ 1054 | ``` 1055 | 1056 | [动态演示 -- 选择排序算法可视化](https://visualgo.net/zh/sorting) 1057 | 1058 | ### 多维数组 1059 | 1060 | #### 多维数组的声明 1061 | 1062 | C 语言支持多维数组。多维数组声明的一般形式如下： 1063 | 1064 | ```c 1065 | type name[size1][size2]...[sizeN]; 1066 | ``` 1067 | 1068 | 例如，下面的声明创建了一个三维 5 . 10 . 4 整型数组： 1069 | 1070 | ```c 1071 | int threedim[5][10][4]; 1072 | ``` 1073 | 1074 | ### 二维数组 1075 | 1076 | #### 初始化二维数组 1077 | 1078 | + 初始化可以使用一个 { } 里面包含有多个数据的方式，多个数据使用逗号进行分隔,例如： 1079 | 1080 | ```c 1081 | 数据类型 数组名[整型常量][整形常量] = { {数据1,...} , {数据2,...}, {数据3,...}, ...}; 1082 | 1083 | int a[3][4] = { 1084 | {0, 1, 2, 3}, /* 初始化索引号为 0 的行 */ 1085 | {4, 5, 6, 7}, /* 初始化索引号为 1 的行 */ 1086 | {8, 9, 10, 11} /* 初始化索引号为 2 的行 */ 1087 | }; 1088 | ``` 1089 | 1090 | + 数组的第一个下标可以直接由 “{ }” 里面的包含的 “{ }” 个数决定，所以完全可以省略第一个下标： 1091 | 1092 | ```c 1093 | int a[][4] = { {0, 1, 2, 3}, {4, 5, 6, 7}, {8, 9, 10, 11} }; 1094 | ``` 1095 | 1096 | + 虽然二维数组在概念上是二维的，有行和列，但在内存中所有的数组元素都是连续排列的，它们之间没有“缝隙”,以下面的二维数组 a 为例： 1097 | 1098 | ```c 1099 | int a[3][4] = { {0, 1, 2, 3}, {4, 5, 6, 7}, {8, 9, 10, 11} }; 1100 | ``` 1101 | 1102 | + 但在内存中，a 的分布是一维线性的，整个数组占用一块连续的内存： 1103 | 1104 |
1105 | 1106 | ![train3.jpg](https://upload-images.jianshu.io/upload_images/9140378-753dc9d279810b55.jpg?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240) 1107 | 1108 |
1109 | 1110 | + C语言中的二维数组是按行排列的，也就是先存放 a[0] 行，再存放 a[1] 行，最后存放 a[2] 行；每行中的 4 个元素也是依次存放。 1111 | 1112 |
1113 | 1114 | ![train11.jpg](https://upload-images.jianshu.io/upload_images/9140378-7445afc38122c969.jpg?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240) 1115 | 1116 |
1117 | 1118 | + 数组 a 为 int 类型，每个元素占用 4 个字节，整个数组共占用 4×(3×4) = 48 个字节。 1119 | + C语言允许把一个二维数组分解成多个一维数组来处理。对于数组 a，它可以分解成三个一维数组，即 a[0]、a[1]、a[2]。每一个一维数组又包含了 4 个元素，例如 a[0] 包含 a[0][0]、a[0][1]、a[0][2]、a[0][3] 1120 | 1121 | + 假设数组 a 中第 0 个元素的地址为 1000，那么每个一维数组的首地址如下图所示： 1122 | 1123 |
1124 | 1125 | ![train9.png](https://upload-images.jianshu.io/upload_images/9140378-f382b296f8bf9418.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240) 1126 | 1127 |
1128 | 1129 | #### 为二维数组赋值并访问二维数组的元素 1130 | 1131 | + 二维数组中的元素也是通过使用下标（即数组的行索引和列索引）来访问的。例如： 1132 | 1133 | ```c 1134 | int val = a[2][3]; 1135 | ``` 1136 | 1137 | + 上面的语句将获取数组中第 3 行第 4 个元素。您可以通过上面的示意图来进行验证。让我们来看看下面的程序，我们将使用嵌套循环来处理二维数组： 1138 | 1139 | 首先定义一个二维数组 1140 | 1141 | ```c 1142 | /* 一个带有 3 行 4 列的数组 */ 1143 | int a[3][4]; 1144 | ``` 1145 | 1146 | 二维数组的赋值 1147 | 1148 | + 使用循环的嵌套来从键盘录入数据 1149 | 1150 | ```c 1151 | int i, j; 1152 | for(i = 0;i < 3;i ++ ) 1153 | { 1154 | for(j = 0;j < 4;j ++) 1155 | { 1156 | scanf("%d",&a[i][j]); 1157 | } 1158 | } 1159 | ``` 1160 | 1161 |
1162 | 1163 | ![train12.jpg](https://upload-images.jianshu.io/upload_images/9140378-a9894652810c62b5.jpg?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240) 1164 | 1165 |
1166 | 1167 | 二维数组的输出 1168 | 1169 | + 同样我们使用循环的嵌套来从输出数据 1170 | 1171 | ```c 1172 | //输出具体数值 1173 | for ( i = 0; i < 3; i++ ) 1174 | { 1175 | for ( j = 0; j < 4; j++ ) 1176 | printf("%d ",a[i][j]); 1177 | printf("\n"); 1178 | } 1179 | /* 1180 | 1 2 3 4 1181 | 3 4 5 6 1182 | 5 6 7 8 1183 | */ 1184 | for ( j = 0; j < 4; j++ ) 1185 | printf("a[%d][%d] = %d\n", i,j, a[i][j]); 1186 | /* 1187 | a[0][0] = 1 1188 | a[0][1] = 2 1189 | a[0][2] = 3 1190 | a[0][3] = 4 1191 | 1192 | a[1][0] = 3 1193 | a[1][1] = 4 1194 | a[1][2] = 5 1195 | a[1][3] = 6 1196 | 1197 | a[2][0] = 5 1198 | a[2][1] = 6 1199 | a[2][2] = 7 1200 | a[2][3] = 8 1201 | */ 1202 | } 1203 | ``` 1204 | 1205 | #### 多维数组的使用 1206 | 1207 | 从前面的学习中，大家应该都知道了，数组的维数与定数组时，数组的整型常量表达式，即下标的个数有关 1208 | 1209 | + 含有一个下标的是一维数组，包含两个下标的二维数组，很容易就可以推测出多维数组是如何定义并初始化的，如定义一个 int 型的三维数组 1210 | 1211 | ```c 1212 | int num[2][4][2]; 1213 | ``` 1214 | 1215 | + 上面所定义的三维数组的储存单元数应该是：2 * 4 * 2，即16 个储存单元，无论是有几个下标的多维数组，都可以看成是数组不断嵌套的结果,而且多维数组在程序的编写中不经常用到 1216 | + 接下来通过一个实例来让大家熟悉一下多维数组 1217 | 1218 | ```c 1219 | int mian() 1220 | { 1221 | int address[3][6][4]; 1222 | for(int i = 0;i < 3;i ++) 1223 | { 1224 | printf("第%d栋楼\n\n"，i); 1225 | for(int j = 0;j < 6;j ++) 1226 | { 1227 | printf("第%d层楼"，6 - j); 1228 | for(int k = 0;k < 4;k ++) 1229 | { 1230 | address[i][j][k] = k + 1; 1231 | printf("%d",address[i][j][k]); 1232 | } 1233 | } 1234 | } 1235 | } 1236 | ``` 1237 | 1238 | ## 指针 1239 | 1240 | ### 指针及其使用 1241 | 1242 | #### 初识指针 1243 | 1244 | 指针是什么？ 1245 | 1246 | 首先理解 " & " 和 " * " ( 取地址和指针运算符 ) 1247 | 1248 | ```c 1249 | int var1; 1250 | char var2[10]; 1251 | //打印出地址 1252 | printf("var1 变量的地址： %p\n", &var1 ); 1253 | printf("var2 变量的地址： %p\n", &var2 ); 1254 | /* 1255 | var1 变量的地址： 0x7fff5cc109d4 1256 | var2 变量的地址： 0x7fff5cc109de 1257 | */ 1258 | ``` 1259 | 1260 | ```c 1261 | scanf("%d",&i);//传入一个地址 1262 | //scanf的函数原型 1263 | int scanf(const char * restrict format,...); 1264 | ``` 1265 | 1266 | 如何定义指针变量？ 1267 | 1268 | + 指针本身是一个变量，它存储的是数据在内存中的地址而不是数据本身的值。它的定义如下: 1269 | 1270 | ```c 1271 | 数据类型* 变量名 或 数据类型 *变量名 //只是*的位置不同而已 1272 | 1273 | int *pointer; 1274 | char *name; 1275 | ``` 1276 | 1277 | + 这样就定义好了两个指针变量，int 和 char 表示该这两个指针变量指向的数据类型，*表示这是指针变量。 1278 | 1279 | + 指针变量的初始化：每一个变量都有一个内存位置，每一个内存位置都定义了可使用连字号（&）运算符访问的地址，它表示了在内存中的一个地址, 1280 | 1281 | ![train13.png](https://upload-images.jianshu.io/upload_images/9140378-ccd065db4a4c4091.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/640) 1282 | 1283 | ```c 1284 | int a = 10,*p; 1285 | p = &a 1286 | int a = 10; 1287 | int *p = &a; 1288 | ``` 1289 | 1290 | + 首先我们可以理解 int * 这个是要定义一个指针p，然后因为这个指针存储的是地址所以要对a取地址(&)将值赋给指针p，也就是说这个指针p指向a。 1291 | + 可能会对对这两种定义方法感到迷惑，其实他俩的意思是一样的。第一种定义方法定义了int型的变量 a 和 指针 p ，然后将 a 的地址赋给 p 1292 | + 第二种是在定义指针p的同时将 a 的地址赋给指针 p。我们姑且理解为" int * "是定义指针的标志。 1293 | 1294 | 在变量声明的时候，如果没有确切的地址可以赋值，为指针变量赋一个 NULL 值是一个良好的编程习惯。赋为 NULL 值的指针被称为空指针。NULL 指针是一个定义在标准库中的值为零的常量 1295 | 1296 | ```c 1297 | int *ptr = NULL; 1298 | printf("ptr 的地址是 %p\n", ptr ); 1299 | return 0; 1300 | /* 1301 | 结果： 1302 | ptr 的地址是 0x0 1303 | */ 1304 | ``` 1305 | 1306 | #### 指针有什么用 1307 | 1308 | 这样我们就可以通过*p来找到指针所指向的变量a的地址，然后对地址中的值(值是10)进行操作。 1309 | 1310 | ```c 1311 | printf("%p",p) //结果是一个地址(p指向的变量a的地址)。 1312 | printf("%d",*p) //结果是10，变量a的值。 1313 | printf("%d",&p) //结果是一个地址(指针p的地址，因为指针也是一个变量自己也有地址的) 1314 | ``` 1315 | 1316 | 题目： 1317 | 1318 | 使用指针交换两个整数变量的值，并写成函数形式，即实现void swap(int *a, int *b)函数 1319 | 1320 | #### 指针运算 1321 | 1322 | 指针就是地址，地址在内存中也是以数的形式存在，所以指针也能做加法，减法，比较等运算 1323 | 1324 | ```c 1325 | int a = 5; 1326 | int *i = &a; 1327 | printf("%p\n",i); 1328 | i ++; 1329 | printf("%p\n",i); 1330 | i -= 2; 1331 | printf("%p\n",i); 1332 | return 0; 1333 | /* 1334 | 000000000062FE44 1335 | 000000000062FE48 1336 | 000000000062FE40 1337 | */ 1338 | ``` 1339 | 1340 | ### 指向数组的指针 1341 | 1342 | #### 指向一维数组的指针 1343 | 1344 | 为指针赋数组数据的地址 1345 | 1346 | + 数组的每个数据都保存在一个储存单元里面，只要是储存单元就会有地址，既然指针变量的储存单元可以保存地址，那么就可以用指针保存数组储存单元的地址 1347 | 1348 | ```c 1349 | int *p_i = NULL; //定义指针变量 1350 | int num[5] = {1，2，3，4，5}; 1351 | for(int i = 0;i < 5;i ++) 1352 | { 1353 | p_i = &num[i]; //先让指针指向想要输出的数据 1354 | printf("%d ",*p_i); //通过指针输出数组数据 1355 | } 1356 | ``` 1357 | 1358 | 使用数组名为指针赋值 1359 | 1360 | + 对于下面的数组和指针 1361 | 1362 | ```c 1363 | int num[5] = {1,2,3,4,5}; 1364 | int *p_i; 1365 | ``` 1366 | 1367 | + 为指针赋予第一个数组数据的地址的方式为： 1368 | 1369 | ```c 1370 | p_i = &num[0]; 1371 | ``` 1372 | 1373 | + 其实还可以写成下面的形式,直接将数组名赋予指针，指针需要储存的数据就是地址，而 num 就代表的是数组的首地址 1374 | 1375 | ```c 1376 | p_i = num; 1377 | ``` 1378 | 1379 | 指向数组的指针的加减运算, -- 数组的另外一种遍历方式 1380 | 1381 | ![train14.png](https://upload-images.jianshu.io/upload_images/9140378-29428f6b9449104d.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240) 1382 | 1383 | + 对于*(num + i), num 是数组的首地址，指向数组的首元素，而num + i 则便是数组的第 i 个元素的地址，再加上指针运算符* 就得到了该元素的值 1384 | + array每次加一的时候，它自己的值都会增加sizeof(int)，加 i 的时候就增加i *sizeof ( int ) 1385 | 1386 | ```c 1387 | int num[5] = {2,4,6,8,10}; 1388 | for(int i = 0;i < 5;i ++) 1389 | { 1390 | //通过数组下标遍历数组 1391 | printf("%d",num[i]); 1392 | //通过指针变量遍历数组 1393 | printf("%d",*(num + i)); 1394 | } 1395 | ``` 1396 | 1397 | #### 指向二维数组的指针 1398 | 1399 | 跟一位数组同样的道理 1400 | 1401 | ```c 1402 | int num[3][2] = {{1,2},{3,4},{5,6}}; 1403 | int *p_i = &num[0][0]; 1404 | ``` 1405 | 1406 | + 不过在这里要注意的是，不能为指针直接赋予二维数组的数组名，即上面的代码不能写成: int *p_i = num; 1407 | 1408 |
1409 | 1410 | ![train9.png](https://upload-images.jianshu.io/upload_images/9140378-261b27c28b07feab.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240) 1411 | 1412 |
1413 | 1414 | + 假设定义一个二维数组：num[m][n];一个指针p指向了这个二维数组的首地址，那么对于数组的数据 num[i][j](0 <= i < m,0 <= j < n) ，指针变量p要想指向这个数据,那么指针变量 p = p + n * i + j; 1415 | 1416 | ```c 1417 | double arr[4][3] = { 1418 | {78.4,72.1,41.2}, 1419 | {56.4,12.4,45.1}, 1420 | {12.5,14.6,20.4}, 1421 | {23.5,34.6,67.8} 1422 | } 1423 | double *p_d = &arr[0][0]; //指针变量的类型必须要跟数组类型一致 1424 | printf("二维数组中arr[3][2]位置上的数据为：%6.11f\n",*(p_d + 3 * 3 + 2)); 1425 | ``` 1426 | 1427 | ### 保存指针的数组 1428 | 1429 |
1430 | 1431 | ![train15.png](https://upload-images.jianshu.io/upload_images/9140378-f25fae78ce0cba15.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240) 1432 | 1433 |
1434 | 1435 | 从名字的定义上来看，数组元素全为指针的数组就称为指针数组。 1436 | 1437 | + 一维指针数组的定义形式为： 类型名 *数组标识符[数组长度] 1438 | 例如，一个一维指针数组的定义： 1439 | 1440 | ```c 1441 | int *ptr_array[10] 1442 | ``` 1443 | 1444 | + 因为[]比*的优先级高，所以也可以看成是*(ptr_array[10])，括号里面ptr_array[10]表示的是一个长度为10的数组，然后括号外面的* 说明数组的元素类型是 int* 的指针类型 1445 | 1446 | + 看一个指针数组的例子 1447 | 1448 | ```c 1449 | int main() 1450 | { 1451 | int a = 16, b = 932, c = 100; 1452 | //定义一个指针数组 1453 | int *arr[3] = {&a, &b, &c}; 1454 | printf("%d %d %d\n", *arr[0], *arr[1], *arr[2]); 1455 | return 0; 1456 | } 1457 | /* 1458 | 16 932 100 1459 | */ 1460 | 1461 | ``` 1462 | 1463 | 因为数组arr里面的元素都是指针，所以在声明指针数组的时候，把a,b,c的地址&啊，&b,&c传进去了，在输出的时候先通过 数组下标得到数组内的指针，即a,b,c的地址，然后，再通过 运算符 * 将数据取出 1464 | 1465 | ### 数组指针 1466 | 1467 | 定义方式 1468 | 1469 | ```c 1470 | datatype (*ptr)[length]; 1471 | ``` 1472 | 1473 | 如果一个指针指向了数组，就称它为数组指针,例如： 1474 | 1475 | int a[4][3] = {{0,2,3},{1,5,6},{2,3,4},{7,8,9}}; 1476 | 1477 | 在概念上他是像这种矩阵的样子： 1478 | 1479 | 0 2 3 1480 | 1 5 6 1481 | 2 3 4 1482 | 7 8 9 1483 | 1484 | 但实际上他在内存中是链式的： 1485 | 1486 | 0 2 3 1 5 6 2 3 4 7 8 9 1487 | 1488 | 我们可以将这个二维数组分解成多个一维数组,a[0]包括a[0][0]、 a[0][1]、a[0][2] 三个元素 1489 | 1490 | ```c 1491 | a[][0] a[][1] a[][2] 1492 | a[0] 0 2 3 1493 | a[1] 1 5 6 1494 | a[2] 2 3 4 1495 | a[3] 7 8 9 1496 | ``` 1497 | 1498 | 这里的 a 就是那四个一维数组的组名，接着我们定义一个 数组指针 1499 | 1500 | ```c 1501 | int (*p)[3] = a; 1502 | ``` 1503 | 1504 | 括号里面的*代表 p 是一个指针，[3] 代表这个 指针 p指向了类型为 int[3] 的数组 1505 | 1506 | + *p就是代表的是第一行第一个元素的地址 1507 | + 那么 *(p + 1) 就表示的是 数组a 的第二行第一个元素的地址 1508 | + *(p + 1) + 1 则表示的是第二行的第二个数据的地址 1509 | + *(*(p + 1) + 1)表示第二行的第二个数据的值 1510 | 1511 | ### 指针在函数中的应用 1512 | 1513 | #### 指针作为函数参数 1514 | 1515 | ```c 1516 | #include "stdio.h" 1517 | 1518 | void add_five(int *); 1519 | int main() 1520 | { 1521 | int i = 10; 1522 | add_five(&i); 1523 | } 1524 | 1525 | void add_five(int *a) 1526 | { 1527 | *a = *a + 5; 1528 | } 1529 | ``` 1530 | 1531 | ## 结构体 1532 | 1533 | ### 初识结构体 1534 | 1535 | 为什么要有结构体？ 1536 | 1537 | 在程序中，经常会遇到特定类型的实物需要使用过很多不同类型的数据来表述，如果全部都用单独的变量来指代每一个数据，就要定义很多非常繁琐的变量 1538 | 1539 | ```c 1540 | #include "stdio.h" 1541 | int main() 1542 | { 1543 | char name[20] = "baoqianyue"; 1544 | int height = 175; 1545 | int weight = 70; 1546 | char sex = 'm'; 1547 | short age = 19; 1548 | long wealth = 300000; 1549 | printf("鲍骞月的个人信息：\n"); 1550 | printf("姓名：%s,身高：%d,性别：%c,年龄：%d,财产：%d\n",name,height,sex,age,wealth); 1551 | return 0; 1552 | } 1553 | ``` 1554 | 1555 | 数组允许定义可存储相同类型数据项的变量，结构是 C 编程中另一种用户自定义的可用的数据类型，它允许您存储不同类型的数据项,而结构体的出现就很好的解决了这个问题 1556 | 1557 | + 结构体的构造 1558 | 1559 | ```c 1560 | struct 结构类型名 1561 | { 1562 | 数据类型1 成员变量1; 1563 | 数据类型2 成员变量2; 1564 | 数据类型3 成员变量3; 1565 | .... 1566 | }; //<- 需要注意的地方 1567 | ``` 1568 | 1569 | + 定义结构体变量 1570 | 1571 | ```c 1572 | struct Stu{ 1573 | int height;//身高 1574 | int weight;//体重 1575 | char sex;//性别 1576 | int age; //年龄 1577 | long wealth; 1578 | }; 1579 | ``` 1580 | 1581 | 这个结构体名是Stut，它内部有五个成员，分别为身高，体重，性别，年龄。定义形式与普通变量定义的方式一样，只不过不能立即初始化。 1582 | 1583 | + 结构体变量的初始化 1584 | 1585 | 结构体也是一种数据类型，在某种意义上与int，char这些基本数据类型是同级的，所以定义变量的方式是一样的。 1586 | 1587 | ```c 1588 | struct student stu1,stu2; 1589 | ``` 1590 | 1591 | 对于结构体，初始化并赋值的一般形式为 1592 | 1593 | ```c 1594 | strcut 结构类型名 结构变量 = {数据1，数据2,...}; 1595 | ``` 1596 | 1597 | + 结构体成员的读取和赋值 1598 | 1599 | 结构体成员的获取形式为： 1600 | 1601 | ```c 1602 | 结构体变量名.成员名; 1603 | ``` 1604 | 1605 | 为单个结构体变量赋值,定义结构体变量并赋值，在这里我们定义了一个名stu1的结构体变量，并且为这个结构体 1606 | 1607 | ```c 1608 | Stu stu1; 1609 | stu1.age = 19; 1610 | stu1.height = 175; 1611 | stu1.sex = 'm'; 1612 | stu1.wealth = 30000; 1613 | stu1.weight = 70; 1614 | printf("身高：%d,性别：%c,年龄：%d,财产：%d\n",stu1.height,stu1.sex,stu1.age,stu1.wealth); 1615 | ``` 1616 | 1617 | + 使用typedef简化变量名 1618 | 1619 | ```c 1620 | typedef StudentInfo Stu; 1621 | typedef int integer; 1622 | ``` 1623 | 1624 | ### 结构体的使用 1625 | 1626 | #### 结构体与数组 1627 | 1628 | + 数组作为结构体的变量 1629 | 1630 | 举个例子：一家店雇佣了三个兼职人员，只需要他们在一个星期内来4天就可以，此时如何定义结构体？ 1631 | 1632 | ```c 1633 | struct schedule{ 1634 | char name; 1635 | char sex; 1636 | int week1; 1637 | int week2; 1638 | int week3; 1639 | int week4; 1640 | }; 1641 | ``` 1642 | 1643 | 使用数组节省没必要的变量 1644 | 1645 | ```c 1646 | struct schedule{ 1647 | char name; 1648 | char sex; 1649 | int week[4]; 1650 | }; 1651 | //简化结构体的名字 1652 | typedef schedule S; 1653 | ``` 1654 | 1655 | ```c 1656 | int main() 1657 | { 1658 | S sd1 = {'A','m',1,2,4,6}; 1659 | S sd2 = {'A','m',3,5,6,7}; 1660 | S sd3 = {'A','m',2,3,5,7}; 1661 | printf("姓名：%c,性别：%c,工作日：%d %d %d %d", 1662 | sd1.name,sd1.sex,sd1.week[0],sd1.week[1],sd1.week[2],sd1.week[3]); 1663 | return 0; 1664 | } 1665 | ``` 1666 | 1667 | + 保存结构的数组 1668 | 1669 | ```c 1670 | int main() 1671 | { 1672 | S st[3] = { {'A','m',1,2,4,6 } , {'A','m',3,5,6,7} , {'A','m',2,3,5,7} }; 1673 | for(int i = 0;i < 3;i ++) 1674 | printf("姓名：%c,性别：%c,工作日：%d %d %d %d\n", 1675 | st[i].name,st[i].sex,st[i].week[i],st[i].week[1],st[i].week[2],st[i].week[3]); 1676 | return 0; 1677 | } 1678 | ``` 1679 | 1680 | #### 结构体与指针 1681 | 1682 | + 结构体与函数 1683 | 1684 | 结构体作为函数参数，传入函数进行赋值，并将赋值完的结构体返回给主函数 1685 | 传参方式与其他类型的变量或指针类似 1686 | 1687 | ```c 1688 | #include "stdio.h" 1689 | struct complex_num{ 1690 | int real; 1691 | int image; 1692 | }; 1693 | typedef complex_num comp; 1694 | 1695 | comp assign(comp num) 1696 | { 1697 | puts("输入复数的实部："); 1698 | scanf("%d",&(num.real)); 1699 | puts("输入复数的实部："); 1700 | scanf("%d",&(num.image)); 1701 | return num; 1702 | } 1703 | 1704 | int main() 1705 | { 1706 | comp com1; 1707 | com1 = assign(com1); 1708 | printf("%d + %di",com1.real,com1.image); 1709 | return 0; 1710 | } 1711 | ``` 1712 | 1713 | 1714 | ### 结构体的应用 1715 | 1716 | 结构体的应用 -- 链表 1717 | 1718 | #### 结构体变量指针 1719 | 1720 | ![train.png](https://upload-images.jianshu.io/upload_images/9140378-105df5dddce29c6a.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/640) 1721 | 1722 | + 结构体变量成员指向自身 1723 | 1724 | 即将定义的结构体变量的地址赋予给所定义的结构体，这样定义的该结构体的指针域就只想了结构体本身 1725 | 1726 | ```c 1727 | struct table{ 1728 | int i; 1729 | char c; 1730 | struct table *st; 1731 | }; 1732 | int main() 1733 | { 1734 | table st1 = {1,'a'}; 1735 | st1.st = &st1; 1736 | //使用结构体变量输出自身的2个成员的值 1737 | printf("%d %c\n",st1.i,st1.c); 1738 | //使用结构体指针域所指向的结构体输出数值 1739 | printf("%d %c\n",st1.st->i,st1.st->c); 1740 | return 0; 1741 | } 1742 | /* 1743 | 1 a 1744 | 1 a 1745 | */ 1746 | ``` 1747 | 1748 | + 结构体变量成员指向其他结构变量 1749 | 1750 | 即将定义的两个结构体变量，比方说定义了 st1 和 st2两个结构体变量，只需要将st2 的地址 赋给 st1 的指针域，这样 st1 的指针就指向了 st2 1751 | 1752 | ![train1.png](https://upload-images.jianshu.io/upload_images/9140378-b8b80be836c3d74a.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/440) 1753 | 1754 | ```c 1755 | int main() 1756 | { 1757 | table st1 = {1,'a'}; 1758 | table st2 = {2,'b'}; 1759 | st1.st = &st2; 1760 | 1761 | //使用结构体变量输出st1自身的2个成员的值 1762 | printf("%d %c\n",st1.i,st1.c); 1763 | 1764 | //使用结构体指针域所指向的结构体输出数值,即 st2 中的数值 1765 | printf("%d %c\n",st1.st->i,st1.st->c); 1766 | 1767 | //使用结构体变量输出st2自身的2个成员的值 1768 | printf("%d %c\n",st2.i,st2.c); 1769 | 1770 | return 0; 1771 | } 1772 | /* 1773 | 1 a 1774 | 2 b 1775 | 2 b 1776 | */ 1777 | ``` 1778 | 1779 | #### 数组与链表 1780 | 1781 | 数组是由同类型的多个数据组成的，链表是由是由多个相同结构连接而成 1782 | 但是数组中就可以存放结构体，为啥还要单独专门独立出来一个链表呢？这是因为数组的长度总是固定的，没办法动态的储存数据 1783 | 1784 | ```c 1785 | #include "stdio.h" 1786 | struct table{ 1787 | int i; 1788 | char c; 1789 | struct table *st; 1790 | }; 1791 | int main() 1792 | { 1793 | table tal[3] = { 1794 | {1,'a'}, 1795 | {2,'b'}, 1796 | {3,'c'} 1797 | }; 1798 | return 0; 1799 | } 1800 | ``` 1801 | 1802 | 上面的代码也能做到和链表一样的效果，甚至比链表还要简洁，但是如果程序中的结构数目是用户自己决定的话，或者说结构体的数目是位未知的，那怎么办?数组的长度可以在程序运行时不能被更改，所以说，数组跟结构体搭配的前提时数组的长度固定并且已知 1803 | 1804 | #### 链表概述 1805 | 1806 | ![timg.jpg](https://upload-images.jianshu.io/upload_images/9140378-c16769111551b03e.jpg?imageMogr2/auto-orient/strip%7CimageView2/2/w/840) 1807 | 1808 | 链表的最小单元 -- 结点 1809 | 1810 | ```c 1811 | struct table 1812 | { 1813 | int i; 1814 | char c; 1815 | struct table *next; 1816 | } 1817 | strcut table st1 = {1,'a'}; 1818 | struct table st2 = {2,'b'}; 1819 | st1.next = &st2; 1820 | ``` 1821 | 1822 | 链表的组成部分 1823 | 1824 | 一个连边通常由3部分组成：投机欸但、数据结点和尾结点 1825 | 1826 | + 头节点：数据域的变量不指代数据，指针域的指针变量指向链表的第一个数据结点。通常情况下，使用‘ 单链表 ’ 的程序只记录头节点，其他节点都是通过头节点一次获取得到的 1827 | + 数据结点：数据域的变量指代实实在在的数据，指针域的指针变量用于指向下一个数据结点 1828 | + 尾结点：数据域的变量指代实实在在的数据，指针域的指针变量被赋予为空，便是没有指向任何地方 1829 | 1830 | #### 动态创建链表 1831 | 1832 | 构建3步骤 1833 | 1834 | + 构造一个结构类型，此结构类型必须包含至少一个成员指针，此指针要指向此结构类型， 1835 | + 定义3个结构体类型的指针，按照用途可以命名为，p_head,p_rail,p_new 1836 | + 动态生成新的结点，为各成员变量赋值，最后加到链表当中 1837 | 1838 | 构造专用于链表的结构 1839 | 1840 | ```c 1841 | struct node 1842 | { 1843 | short i; 数据域 1844 | char c; ///数据域 1845 | struct node *next; //指针域，用于指向下一个结点 1846 | } 1847 | ``` 1848 | 1849 | 定义结构体指针 1850 | 1851 | ```c 1852 | struct node *p_head,*p_rail,*p_new ; 1853 | ``` 1854 | 1855 | 使用malloc() 动态申请储存空间作为新节点，声明形式： 1856 | 1857 | ```c 1858 | void malloc(unsigned int num_bytes); 1859 | ``` 1860 | 1861 | + num_bytes声明的空间大小 1862 | + 返回void类型的指针 1863 | + 要注意的是，生命完要把空间释放掉，盗用的函数为 free(); 1864 | 1865 | ![train20.png](https://upload-images.jianshu.io/upload_images/9140378-e9fbe3bdd6db4850.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/540) 1866 | 1867 | 接下来写一个动态创建链表的实例： 1868 | 1869 | 首先构造结构体 1870 | 1871 | ```c 1872 | struct node { 1873 | short i; 1874 | char c; 1875 | struct node *next; 1876 | }; 1877 | ``` 1878 | 1879 | 构造一个含有3个结点的链表 1880 | 1881 | ```c 1882 | struct node node1 = {1,'A'}; 1883 | struct node node2 = {2,'B'}; 1884 | struct node node3 = {3,'C'}; 1885 | node1.next = &node2; 1886 | node2.next = &node3; 1887 | ``` 1888 | 1889 |
1890 | 1891 | ![train21.png](https://upload-images.jianshu.io/upload_images/9140378-32814c518bae8414.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/540) 1892 | 1893 |
1894 | 1895 | 遍历链表输出数据 1896 | 1897 | ```c 1898 | struct node *p; 1899 | p = &node1; 1900 | for(int j = 0;j < 3;j ++) 1901 | { 1902 | printf("node:%d %c",p->i,p->c); 1903 | p = p->next; 1904 | } 1905 | ``` 1906 | 1907 | 动态生成新节点 1908 | 1909 | ```c 1910 | struct node *p_new; 1911 | p_new = (struct node *)malloc(sizeof(struct node)); 1912 | p_new->i = 4; 1913 | p_new->c = 'd'; 1914 | ``` 1915 | 1916 | 添加到链表当中 1917 | 1918 | ```c 1919 | node3.next = p_new; 1920 | ``` 1921 | 1922 | #### 链表操作 1923 | 1924 | 插入结点到链表 1925 | 1926 | + 插入结点到第一个数据结点前 1927 | 1928 |
1929 | 1930 | ![train22.png](https://upload-images.jianshu.io/upload_images/9140378-884b75f47c63a109.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/740) 1931 | 1932 |
1933 | 1934 | ```c 1935 | struct node p_new = (struct node *)malloc(sizeof(struct node)); //创建新结点，并为其开辟空间 1936 | scanf("%d%c",&(p_new->i),&(p_new->c)); //录入结点数据 1937 | //插入节点 1938 | p_new->next = p_head-next; 1939 | p_head->next = p_new; 1940 | ``` 1941 | 1942 | + 插入结点到链表中间 1943 | 1944 |
1945 | 1946 | ![train23.png](https://upload-images.jianshu.io/upload_images/9140378-320eb2dd5952ee8f.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/740) 1947 | 1948 |
1949 | 1950 | ```c 1951 | struct node p_new = (struct node *)malloc(sizeof(struct node)); //创建新结点，并为其开辟空间 1952 | p_new->i = 2; 1953 | p_new->c = 'B'; 1954 | 1955 | struct node *p_front = p_head->next; 1956 | p_new->next = p_front->next; 1957 | p_front->next = p_new; 1958 | ``` 1959 | 1960 | + 插入节点到链表末尾 1961 | 1962 | ![train24.png](https://upload-images.jianshu.io/upload_images/9140378-b772cb8890126923.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240) 1963 | 1964 | ```c 1965 | while(1) 1966 | { 1967 | if(p-next == NULL) 1968 | { 1969 | p_rail = p; 1970 | break; 1971 | } 1972 | p = p->next; 1973 | } 1974 | p_rail->next = p_new; 1975 | p_tail = p_new; 1976 | ``` 1977 | 1978 | + 删除链表中的结点 1979 | 1980 |
1981 | 1982 | ![train25.png](https://upload-images.jianshu.io/upload_images/9140378-3582fbb7b736eb09.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/440) 1983 | 1984 |
1985 | 1986 | ```c 1987 | void del_list(struct node *p_head,int pos) 1988 | { 1989 | strct node *p_front,*p_del; 1990 | p_front = p_head; 1991 | for(int i = 0;i <= pos - 1;i ++) 1992 | { 1993 | p_front = p_front->next; 1994 | } 1995 | p_del = p_front->next; 1996 | p_front->next = p_del->next; 1997 | free(p_del); 1998 | } 1999 | 2000 | ``` 2001 | 2002 | ## 字符串 2003 | 2004 | ### 初识字符串 2005 | 2006 | 什么是字符串？ 2007 | 2008 | 在 C 语言中，字符串实际上是使用 null 字符 '\0' 终止的一维字符数组。因此，一个以 null 结尾的字符串，包含了组成字符串的字符。 2009 | 2010 | 下面的声明和初始化创建了一个 "Hello" 字符串。由于在数组的末尾存储了空字符，所以字符数组的大小比单词 "Hello" 的字符数多一个 2011 | 2012 | ```c 2013 | char greeting[6] = {'H', 'e', 'l', 'l', 'o', '\0'}; 2014 | ``` 2015 | 2016 | 依据数组初始化规则，您可以把上面的语句写成以下语句： 2017 | 2018 | ```c 2019 | char greeting[] = "Hello"; 2020 | ``` 2021 | 2022 | 定义的字符串的内存表示： 2023 | 2024 | ![train17.jpg](https://upload-images.jianshu.io/upload_images/9140378-c4e53c41e194053a.jpg?imageMogr2/auto-orient/strip%7CimageView2/2/w/540) 2025 | 2026 | ### 字符串的输入与输出 2027 | 2028 | #### 输出 2029 | 2030 | 普通方式 2031 | 2032 | ```c 2033 | char arr[] = "Hello!"; 2034 | int i = 0; 2035 | while(arr[i] != '\0') 2036 | { 2037 | printf("%c",arr[i]); 2038 | i ++; 2039 | } 2040 | ``` 2041 | 2042 | 特殊方式 2043 | 2044 | ```c 2045 | char arr[] = "Hello!"; 2046 | printf("%s\n",arr); 2047 | ``` 2048 | 2049 | 其他方式,函数 putchar(); 2050 | 2051 | ```c 2052 | char arr[] = "Hello!"; 2053 | int i = 0; 2054 | while(arr[i] != '\0') 2055 | { 2056 | putchar(arr[i]); 2057 | i ++; 2058 | } 2059 | ``` 2060 | 2061 | #### 输入 2062 | 2063 | 普通方式 2064 | 2065 | ```c 2066 | int i = -1; 2067 | do 2068 | { 2069 | i ++; 2070 | scanf("%c",&arr[i]); 2071 | }while(arr[i] != '\n'); 2072 | arr[i] = '\0'; 2073 | ``` 2074 | 2075 | 特殊方式 2076 | 2077 | ```c 2078 | scanf("%s",arr); 2079 | ``` 2080 | 2081 | 其他方式 2082 | 2083 | ```c 2084 | arr[i] = getchar(); 2085 | ``` 2086 | 2087 | ### 指向字符串的指针 2088 | 2089 | ```c 2090 | char arr[10] = {0}; 2091 | char *p = arr; 2092 | int i = -1; 2093 | do 2094 | { 2095 | i ++; 2096 | scanf("%d",p + i); 2097 | }while(*(p + i) != '\n'); 2098 | *(p + i) = '\0'; 2099 | i = 0; 2100 | while(*(p + i) != '\0') 2101 | { 2102 | printf("%c",*(p + i)); 2103 | i ++; 2104 | } 2105 | ``` 2106 | 2107 | gets 和 puts() 2108 | 2109 | ```c 2110 | cahr arr[20] = {0}; 2111 | char *p = arr; 2112 | gets(p); 2113 | puts(p); 2114 | ``` 2115 | 2116 | ### 常见的字符串操作 2117 | 2118 | + strcpy(p, p1) 复制字符串 2119 | + strncpy(p, p1, n) 复制指定长度字符串 2120 | + strcat(p, p1) 附加字符串 2121 | + strncat(p, p1, n) 附加指定长度字符串 2122 | + strlen(p) 取字符串长度 2123 | + strcmp(p, p1) 比较字符串 2124 | + strcasecmp忽略大小写比较字符串 2125 | + strncmp(p, p1, n) 比较指定长度字符串 2126 | + strchr(p, c) 在字符串中查找指定字符 2127 | + strrchr(p, c) 在字符串中反向查找 2128 | + strstr(p, p1) 查找字符串 2129 | 2130 | #### 赋值 2131 | 2132 | 何为赋值？ 2133 | 2134 | ```c 2135 | float f1 = 3.654; 2136 | float f2; 2137 | f2 = f1; 2138 | ``` 2139 | 2140 | 字符串拷贝函数 2141 | 2142 | 将src指向的字符串拷贝到des指向的字符串数组中去，结束符也一同进行拷贝，size参数也可以拷贝制定长度的字符串，建议des为字符数组 2143 | 2144 | ```c 2145 | char *strcpy(char*des,char*src); 2146 | char *strncpy(char *des,char *src,int size); 2147 | ``` 2148 | 2149 | #### 加法 2150 | 2151 | 字符串的连接函数 2152 | 2153 | 将str2指向的字符串连接到str1指向的字符后面，同时会删除str1后面的’\0’,返回的是str1指向字符串的首地址重点内容 2154 | 2155 | ```c 2156 | char * strcat(const *char str1,const *char str2); 2157 | char *strncat(const *char str1,const *char str2,int size); 2158 | ``` 2159 | 2160 | 错误的加法运算 2161 | 2162 | ```c 2163 | char *p1 = "super"; 2164 | char *p2 = "market"; 2165 | char *p3 = p1 + p2; //错误的加法 2166 | ``` 2167 | 2168 | ```c 2169 | char arr[30] = {0}; 2170 | char *p3 = arr; 2171 | p3 = strcat(p3,p1); 2172 | p3 = strcat(p3,p2); 2173 | p3 = strncat(p3,p1,1); //将p1所指向的字符的第一个字符加到p3所指字符串的末尾 2174 | // p3 = supermarkets 2175 | ``` 2176 | 2177 | #### 修改 2178 | 2179 | ```c 2180 | cahr arr[] = "Nes!"; 2181 | cahr *p = arr; 2182 | *p = 'Y'; 2183 | ``` 2184 | 2185 | 指针p指向了arr字符串的字符串，借助 p 可以任意修改字符串中的任意字符,但是借助指针修改一个字符还比较容易，批量的话就需要 库函数 strset() 2186 | 2187 | ```c 2188 | char *strset(char *s,char c); //将字符串s中的字符全部设成字符 c 2189 | char *strnset(char *s,char c,int n); //将s指向的字符串的前n个字符都设成c 2190 | ``` 2191 | 2192 | ```c 2193 | char p1[] = "Are you ok"; 2194 | strset(p1,'a'); 2195 | // p1 aaaaaaaaaa 2196 | 2197 | strset(p2,'b',2); 2198 | 2199 | //p1 bbaaaaaaaa 2200 | ``` 2201 | 2202 | #### 比较 2203 | 2204 | 字符串比较函数 2205 | 2206 | 错误的比较方式 2207 | 2208 | ```c 2209 | char arr[] = "What"; 2210 | char arr2[] = "That"; 2211 | if(arr1 == arr2)//错误的比较方式 2212 | { 2213 | ... 2214 | } 2215 | ``` 2216 | 2217 | 按照ascii码来进行比较，并由函数返回值进行判断 2218 | 返回0,字符串1等于字符串2, 2219 | 大于0,字符串1大于字符串2, 2220 | 小于0,字符串1小于字符串2, 2221 | 2222 | ```c 2223 | int strcmp(const char *str1,const char *str2); 2224 | int strncmp(const char *str1,const char *str2,int size); 2225 | 2226 | char buf1[] = "aaa"; 2227 | char buf2 = "bbb"; 2228 | int ptr = strcmp(buf2,buf1);//ptr < 0 2229 | ``` 2230 | 2231 | ## 文件 2232 | 2233 |
2234 | 2235 | ![train19.gif](https://upload-images.jianshu.io/upload_images/9140378-68d9870e8f7a4e41.gif?imageMogr2/auto-orient/strip%7CimageView2/2/w/440) 2236 | 2237 |
2238 | 2239 | ### 为什么要有文件操作 2240 | 2241 | 两个没有解决的问题 2242 | 2243 | 不得不再次运行程序 2244 | 2245 | + 我们运行计算机上的程序，然后不断输入数据给程序，然后得到程序对程序的处理结果，如果关掉程序的话，再想看到那些数据，就不得不再次运行程序。而且如果数据量过大的话，没办法留住这些数据 2246 | 2247 | 不得不重新输入数据 2248 | 2249 | + 每次在循行程序的时候吗，每运行一次都要重新的从简盘再次录入数据，而文件的运用帮我们解决了这个繁琐的问题 2250 | 2251 | ### 文件概述 2252 | 2253 | + 定位文件 2254 | + 读取、写入文件 2255 | + 关闭文件 2256 | 2257 |
2258 | 2259 | ![train16.png](https://upload-images.jianshu.io/upload_images/9140378-3e2ccfe2d81cd5ba.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/540) 2260 | 2261 |
2262 | 2263 | ### 文件的打开和关闭 2264 | 2265 | #### 打开文件 2266 | 2267 | 可以使用 fopen( ) 函数来创建一个新的文件或者打开一个已有的文件，这个调用会初始化类型 FILE 的一个对象，类型 FILE 包含了所有用来控制流的必要的信息。下面是这个函数调用的原型： 2268 | 2269 | ```c 2270 | FILE *fopen( const char * filename, const char * mode ); 2271 | ``` 2272 | 2273 | 在这上面的函数原型里面，filename 是字符串，用来命名文件，访问模式 mode 的值可以是下列值中的一个： 2274 | 2275 | ||| 2276 | |:--|:--| 2277 | |模式|描述| 2278 | |r|打开一个已有的文本文件，允许读取文件。| 2279 | |w|打开一个文本文件，允许写入文件。如果文件不存在，则会创建一个新文件。在这里，您的程序会从文件的开头写入内容。如果文件存在，则该会被截断为零长度，重新写入。| 2280 | |a|打开一个文本文件，以追加模式写入文件。如果文件不存在，则会创建一个新文件。在这里，您的程序会在已有的文件内容中追加内容。| 2281 | |r+|打开一个文本文件，允许读写文件。| 2282 | |w+|打开一个文本文件，允许读写文件。如果文件已存在，则文件会被截断为零长度，如果文件不存在，则会创建一个新文件。| 2283 | |a+|打开一个文本文件，允许读写文件。如果文件不存在，则会创建一个新文件。读取会从文件的开头开始，写入则只能是追加模式。| 2284 | 2285 | 如果处理的是二进制文件，则需使用下面的访问模式来取代上面的访问模式： 2286 | 2287 | ```c 2288 | "rb", "wb", "ab", "rb+", "r+b", "wb+", "w+b", "ab+", "a+b" 2289 | ``` 2290 | 2291 | #### 关闭文件 2292 | 2293 | 为了关闭文件，请使用 fclose( ) 函数。函数的原型如下： 2294 | 2295 | ```c 2296 | int fclose( FILE *fp ); 2297 | ``` 2298 | 2299 | 如果成功的关闭了文件，会清空缓冲区中的数据，并释放用于该文件的所有内存，这个函数就会返回0，如果关闭文件的时候放生错误，函数会返回EOF，而EFO是一个常量 2300 | 2301 | ```c 2302 | #include "stdio.h" 2303 | #include "stdlib.h" 2304 | int main() 2305 | { 2306 | //定义一个指向文件类型的指针 2307 | FILE *fp; 2308 | //打开一个已有的文件 2309 | fp = fopen(text.txt,"r"); //错误的方式 2310 | fp = fopen("D:\Desktop\text.txt","r"); //错误的方式 2311 | if(fp == NULL ) 2312 | { 2313 | printf("打开文件失败！\n"); 2314 | exit(0); 2315 | } 2316 | printf("打开文件成功！\n"); 2317 | fclose(fp); 2318 | 2319 | 2320 | //如果想要在字符串中使用 '\' 必须要写成 '\\' 来转义 2321 | fp = fopen("D:\\Desktop\\text.txt","r"); 2322 | //printf("D:\\Desktop\\text.txt\n"); 2323 | //printf("D:\Desktop\text.txt\n"); 2324 | 2325 | //使用访问模式 'w' 打开文件，会发现文件之前保存的内容被清零 2326 | fp = fopen("D:\\Desktop\\text.txt","w"); 2327 | 2328 | return 0; 2329 | } 2330 | ``` 2331 | 2332 | ### 文件的读写操作 2333 | 2334 | #### 写入数据 2335 | 2336 | 想要让程序在文件中写入文件，在程序与文件建立关联的时候，必须保证打开方是可写的，有 4 中方式可以将数据写入文件当中 2337 | 2338 | 字符方式 2339 | 2340 | 程序可以以字符为单位，一个字符一个字符的将数据写入到文件当中，需要的函数是 fputc(),声明如下： 2341 | 2342 | ```c 2343 | int fputc(char c,FILE *stream); 2344 | ``` 2345 | 2346 | + 参数 c 指代的是一个将要被写入文件的字符 2347 | + 参数 stream 是一个文件指针，指向将要被写入的文件 2348 | + 写入成功，返回 写入字符的ASCII 码值 2349 | 2350 | ```c 2351 | char ch; //定义一个字符串 2352 | int i = 0; 2353 | while((ch = getchar()) != '\n') 2354 | { 2355 | i = fputc(ch,fp); // 以字符为单位，写入到text.txt文件 2356 | if(i == -1) 2357 | { 2358 | puts("字符写入失败！"); 2359 | exit(0); 2360 | } 2361 | } 2362 | ``` 2363 | 2364 | 格式化方式 2365 | 2366 | 如果写入文件的内容有特定的格式要求，可以使用格式化的方式将数据写入到文本 2367 | 2368 | stdio.h 提供了一个库函数 fprintf(),可以达到这个目的，声明如下： 2369 | 2370 | ```c 2371 | int fprintf(FILE *stream,const char *format[, argument ] ...); 2372 | ``` 2373 | 2374 | 和 printf()的使用方法一致 2375 | 2376 | + 参数的 stream 是指向将要被写入数据的文件的文件指针 2377 | + 参数 format 是格式化的字符串 2378 | + 参数 argument 是可选的，如果 format 中有格式符，argument 就是对应的变量 2379 | + 函数 fprintf() 返回实际输入到文件中的字符的个数 2380 | 2381 | ```c 2382 | struct info 2383 | { 2384 | short no; 2385 | char name[10]; 2386 | char sex[6]; 2387 | }; 2388 | 2389 | struct info info_st[3] ={ 2390 | {1,"baoqianyue","men"}, 2391 | {2,"lihao","men"}, 2392 | {3,"wanghao","men"} 2393 | }; 2394 | for(int i = 0;i < 3;i ++) 2395 | { 2396 | fprintf(fp,"No = %d\tname = %-8s\tsex = %-6s\n",info_st[i].no, 2397 | info_st[i].name,info_st[i].sex); 2398 | } 2399 | ``` 2400 | 2401 | 字符串方式 2402 | 2403 | 对于程序中的字符串，除了以字符串为单位，一个字符一个字符的录入之外，还可以以字符串为单位，一次性的写入一串字符，需要用到的路函数是 fputs(),它的声明是： 2404 | 2405 | ```c 2406 | int puts(const char *str,FILE *stream); 2407 | ``` 2408 | 2409 | + str 写入文件的字符串指针 2410 | + stream 文件指针 2411 | + 字符串写入失败的话，同样也是会返回 -1 2412 | 2413 | ```c 2414 | char c[100]; 2415 | gets(c); 2416 | int value = fputs(c,fp); 2417 | if(value == -1) 2418 | { 2419 | puts("字符串写入失败！\n"); 2420 | exit(0); 2421 | } 2422 | ``` 2423 | 2424 | 二进制方式 2425 | 2426 | 储存为文件的数据形式一般为两种，分别是字符形式 和 二进制 形式，使用二进制方式向文件写入数据，需要用到的库函数是 fwrite(),它的声明是： 2427 | 2428 | ```c 2429 | int fwrite(const void *buffer,int size,int count,FILE *stream); 2430 | ``` 2431 | 2432 | + buffer 无类型指针 2433 | + size 是要被写入到文件的数据的大小 2434 | + count 是size 为单元的单元的个数 2435 | + stream 文件指针 2436 | 2437 | ```c 2438 | struct info 2439 | { 2440 | short no; 2441 | char name[10]; 2442 | char sex[6]; 2443 | }; 2444 | 2445 | struct info info_st[3] ={ 2446 | {1,"baoqianyue","men"}, 2447 | {2,"lihao","men"}, 2448 | {3,"wanghao","men"} 2449 | }; 2450 | 2451 | int count = fwrite(info_st,sizeof(struct info),3,fp); //写入数据到文件 2452 | 2453 | ``` 2454 | 2455 | #### 读取数据 2456 | 2457 | 字符方式 2458 | 2459 | 以字符为单位，一个一个从文本文件读取数据，使用的库函数为 fgetc()，声明方式如下: 2460 | 2461 | ```c 2462 | int fgetc(FILE *stream); 2463 | ``` 2464 | 2465 | + 参数 stream 是一个文件指针，指向将要被写入的文件 2466 | + 写入成功，返回 写入字符的ASCII 码值，写入失败，返回 -1 2467 | 2468 | ```c 2469 | char ch = fgetc(fp); 2470 | while(ch != -1) 2471 | { 2472 | putchar(ch); 2473 | ch = fgetc(fp); 2474 | } 2475 | ``` 2476 | 2477 | 格式化方式 2478 | 2479 | 要格式化的一次性从一个文件读取多个字符，用到的库函数是fscanf(),声明方式如下： 2480 | 2481 | ```c 2482 | int fscanf(FILE *stream,const char *format[, argument ]...); 2483 | ``` 2484 | 2485 | + 参数的 stream 是指向将要被写入数据的文件的文件指针 2486 | + 参数 format 是格式化的字符串 2487 | + 参数 argument 是可选的，如果 format 中有格式符，argument 就是对应的变量 2488 | + 函数 fprintf() 返回读取到的文件中的字符的个数 2489 | 2490 | ```c 2491 | struct info 2492 | { 2493 | short no; 2494 | char name[10]; 2495 | char sex[6]; 2496 | }; 2497 | 2498 | struct info info_st[3] ={ 2499 | {1,"baoqianyue","men"}, 2500 | {2,"lihao","men"}, 2501 | {3,"wanghao","men"} 2502 | }; 2503 | for(int i = 0;i < 3;i ++) 2504 | { 2505 | fscanf(fp,"No = %d\tname = %-8s\tsex = %-6s\n",&info_st[i].no, 2506 | &info_st[i].name,&info_st[i].sex); 2507 | } 2508 | ``` 2509 | 2510 | 字符串方式 2511 | 2512 | 一次性全部取出字符串，用到的库函数为 fgets(),它的声明如下： 2513 | 2514 | ```c 2515 | char *fgets(char *str,int n,FILE *stream); 2516 | ``` 2517 | 2518 | + str 写入文件的字符串指针 2519 | + n 是读取字符串结束标志 "\0" 2520 | + stream 文件指针 2521 | + 字符串读取成功的话，返回指向字符串的指针，否则返回NULL 2522 | 2523 | ```c 2524 | char arr[15] = {0}; 2525 | char *p = fgets(arr,15,fp); 2526 | while(p != NULL) 2527 | { 2528 | printf("%s",arr); 2529 | p = fgets(arr,15,fp); 2530 | } 2531 | ``` 2532 | 2533 | 二进制方式 2534 | 2535 | 以二进制写入文件通常是给程序自己看的，就是俗称的乱码，用到的库函数是fread(),它的声明方式是： 2536 | 2537 | ```c 2538 | int fr(eadconst void *buffer,int size,int count,FILE *stream); 2539 | ``` 2540 | 2541 | ```c 2542 | int count = fread(info_st,sizeof(struct info),3,fp); //从文件读取数据 2543 | ``` 2544 | -------------------------------------------------------------------------------- /img/1.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/android-nuc/18-C-Train/ecd72ca41c1b261aef18b4960dda889c798cbbd1/img/1.jpg -------------------------------------------------------------------------------- /img/2.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/android-nuc/18-C-Train/ecd72ca41c1b261aef18b4960dda889c798cbbd1/img/2.jpg -------------------------------------------------------------------------------- /img/3.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/android-nuc/18-C-Train/ecd72ca41c1b261aef18b4960dda889c798cbbd1/img/3.jpg -------------------------------------------------------------------------------- /img/4.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/android-nuc/18-C-Train/ecd72ca41c1b261aef18b4960dda889c798cbbd1/img/4.jpg --------------------------------------------------------------------------------