《21天学通C语言》总结(2)

-《21天学通C语言》第六版

第8天：数组

声明数组

int array[10];

c语言中数组从0开始，并且c语言编译器不对程序使用的下标是否越界进行判断，程序会顺利编译和链接，但下标越界通常导致错误的结果。

多维数组

#define MONTHS 12
int array[MONTHS];

使用常量定义数组，方便修改，规定常量名大写。
无法使用const定义的常量：
const int MONTHS = 12;
int array[MONTHS] // 错误
数组维数尽可能不要超过三维。

多维数组初始化

#include <stdio.h>
#include <stdlib.h>int x, y, randarray[5][4];int main(void)
{for (x = 0; x < 5; x++){for (y = 0; y < 4; y++){randarray[x][y] = rand();}}for (x = 0; x < 5; x++){for (y = 0; y < 4; y++){printf("\t%d", randarray[x][y]);}printf("\n");}getchar();  //暂停return 0;
}

上面程序初始化数组中的元素为随机值并打印，stdlib.h包含随机函数rand()。
最后使用getchar()可以暂停程序，直到用户输入。
没有初始化数组时，如果数组是全局变量则会被设置为0，而局部变量为随机值。

可以使用sizeof()运算符获得数组的大小，也可以使用size()获得大小后除以数组类型对应的元素长度确定包含的元素数。

c语言中数组无法直接相加，但可以写一个函数让它们直接相加。

第9天：指针

指针是一个变量，其值为另一个变量的地址。

指针的声明
typename *ptrname ( * )为间接运算符，表明ptrname是一个指向typename类型变量的指针。编译器根据上下文判断 * 为乘法还是间接运算符。

初始化指针
使用地址运算符初始化指针，pointer = &variable

直接存取，间接存取
printf("%d", rate); printf("%d", *p_rate)
间接运算符 * 提供存储在指针指向位置的值（称为解除引用）

指针处理多字节变量时，变量的地址为它占用的第一个字节的地址。

指针和数组

不带方括号的数组名是一个常量指针，指向数组第一个元素，即date &date[0]，等价。
常量指针无法修改，将其赋值给一个指针即可。
指针递增，递减。pointer++会自动指向下一个元素，而不是加一个字节。

如果数组类型为int，则pointer+4，而pointer += 4则将pointer加16。对指向数组元素的指针递增或递减时，编译器不会跟踪数组开始和结束的位置，因此需要注意指针指向的位置。

可以对两个指针相减，返回两个元素之间相差的元素数，而不是字节差。
ptr1 - ptr2
还可以对指针进行比较，==,<,>,<=,>=,!=等。
无法对指针进行乘除运算。

数组下标法和指针解除引用
下面关系成立：

*(array) == array[0];
*(array + 1) == array[1];
...
*(array + n) == array[n];

将数组传递给函数

函数无法之间接受数组，因此可以通过传递指针和数组的长度给函数，或者在数组最后面加一个标志表示数组结束。
例如：int function(int [], int);，int function(int *, int);。
上面两个等价，int []，int *，表示该参数是一个指针，推荐使用第一个形式。

/* 使用指针传递数组给函数 */#include <stdio.h>#define MAX 10int array[MAX], count;int largest(int [], int);int main(void)
{for (count = 0; count < MAX; count++){printf("Enter a integer value: ");scanf("%d", &array[count]);}printf("\n\nthe largest value is : %d", largest(array, MAX));return 0;
}int largest(int num_array[], int length)
{int count, biggest = num_array[0];for (count = 1; count < MAX; count++){if (num_array[count] > biggest)biggest = num_array[count];}return biggest;
}

fflush(stdin)会把存进缓冲区的数据刷掉，以便正确输入

#include <stdio.h>
#include <conio.h>void main( void )
{int integer;char string[81];/* Read each word as a string. */printf( "Enter a sentence of four words with scanf: " );for( integer = 0; integer < 4; integer++ ){scanf( "%s", string );printf( "%s\n", string );}/* You must flush the input buffer before using gets. */fflush( stdin );printf( "Enter the same sentence with gets: " );gets( string );printf( "%s\n", string );
}

第10天：字符和字符串

单字符和字符数组
char code = 'x'
char string[10]
字符初始化时只能用单引号，字符串初始化时用双引号。字符数组能够存储的最长字符串包含的字符数比数组元素数少1，因为字符串以空字符结尾，/0，其acsii码为0。
字面字符串：用双引号括起来的一个或多个字符。
数组字符串：用数组表示的字符串。

不存储在数组中的字符串
char *message = "Great Caesar's Ghost ! ";
char message[] = "Great Caesar's Ghost ! ";
使用指针初始化字符数组，编译时自动分配存储空间。*message与message[]等价，此时message未被初始化，会导致错误？？

malloc()函数
返回一个void类型的指针，void类型的指针能与所有的数据类型兼容。头文件stdlib.h，无法分配内存时返回NULL。应该总是检查malloc()的返回值。

#include <stdio.h>
#include <stdlib.h>char count, *ptr, *p;int main(void)
{ptr = malloc(35 * sizeof(char));if (ptr == NULL){puts("Memory allocation error.");return 1;}p = ptr;for (count = 65; count < 91; count++)*p++ = count;*p = '\0';puts(ptr);free(ptr); //动态分配内存使用完毕后，释放return 0;
}

使用malloc(number * sizeof(type));sizeof可以确保代码的可移植性。
不应将过大的字符串赋给数组，例如：
char a_string[] = 'NO';
如果将’YES’赋给该数组，第4个字符会覆盖后面的内容。

puts函数，printf函数
puts接受一个参数——指向要显示字符串的指针，打印结束后自动换行。
printf使用格式化字符串和转换说明符来格式化其输出。%s，参数为指向字符串的指针。

gets函数，scanf函数
gets遇到换行符结束，scanf遇到空白字符(空格、制表符、换行符)结束。

gets从键盘读取一个字符串。直到遇到换行符，丢弃换行符添加一个空字符，字符串存储到gets()的char指针指向的位置，返回一个指向开始位置的指针。
可以使用该指针判断是否输入空字符串：
while ( *(ptr = gets(input) ) != NULL )
使用gets()或其他指针来存储数据的函数时，指针一定要指向已分配空间。

scanf()使用地址作为参数，数组名即为地址因此不需要&，常规变量则需要&。
使用%s第一个非空白字符为开始，下一个空白字符(空格，制表符或换行符)之前结束。
使用%ns则读取n个字符或遇到下一个空白字符。

有些程序员使用gets()输入所以数据，然后让程序将数组分离出来，并将其转换为数值。

使用指针初始化数组时，可以把所指向的地址赋值给另一个指针，但不能把地址赋值给另一个数组。
char *m = "asdfgh";// 实际使用需要初始化。
char *m1;
char m2[];
m1 = m; 正确
m2 = m;错误，应使用数组赋值函数，例如：strcpy()。
char *ptr; gets(ptr);如果这样，该字符串可能覆盖重要信息！ 因此必须初始化。

第11天：结构、共用体和TypeDef

简单结构

struct tag{structure_member(s);
}instance;

可以结构的定义和声明同时进行，也可以分开，只有声明才会为数据对象预留内存空间，例如：
struct coord{
int x;
int y;
};
struct coord first, second;
coord即结构的名称叫做结构的标记(tag)，存取结构使用句点运算符(.)，例如：

first.x = 10;
first.y = 20;

结构的优点在于可以使用简单的赋值语句在同类型的结构直接复制信息：
first = second;
等价于：
first.x = second.x;
first.y = second.y;
结构体是为易于操作而被组合在一起的一个或多个变量，其中变量的数据类型不要求相同，也不要求是简单变量，可以包含数组、指针和其他结构体。

复杂结构

包含其他结构体的结构体

#include <stdio.h>int length, width;
int area;struct coord{int x;int y;
};struct rectangle{struct coord topleft;struct coord bottomrt;
} mybox;

mybox的两个成员均为coord结构，因此包含x,y两个成员。

包含数组的结构体

#include <stdio.h>struct data{float amount;char fname[30];char lname[30];
};

结构数组

包含结构体的数组

/* 使用包含数组的结构体 */
#include <stdio.h>struct entry{char fname[20];char lname[20];char phone[10];
};struct entry list[4];

初始化结构

可以在定义结构体时进行初始化：

struct customer{char firm[20];char contact[25];
};struct sale{struct customer buyer;char item[20];float amount;
};struct sale y1990[1000] = {{ { "Ac bb", "gg"},"LEFTDDADA",100.00}{ {"albb", "may"},"qwerttt";4458.98}
};

结构和指针

将指针作为结构成员
struct data
{
char *p1;
char *p2;
}myptrs;
char s1[] = "avcs", s2[] = "sdasdq";
myptrs.p1 = s1;
myptrs.p2 = s2;
使用指针时必须先对其初始化！
指向结构的指针

struct part
{short number;char name[10];
};
struct part gizmo;
struct part *p_part;p_part = &gizmo;

而以下用指针表示成员的表达式等价：

gizmo.number; // str.memb
(*p_part).number; // (*p_str.memb)
p_part->number   // p_str.memb

其中第二个括号必须加，因为成员运算符(.)的优先级比间接运算符(*)高。

-使用指针的结构数组
接着上面的代码

struct part data[10];
struct part *p_part;
p_part = &data[0]; //p_part = data;

p_part即指向数组第一个结构的指针，p_part++即指向数组的下一个结构。
p_part++与p_part += sizeof(obj)不等价，书上似乎错了。

将结构作为参数传递给函数

...print_rec(rec);
...
void print_rec(struct data DispalyRec)
{printf("donor %s %s gave %.2f.\n", DispalyRec.fname, DispalyRec.lname, DispalyRec.amount);
}

直接将实例名传递给函数即可。

共用体

类似于结构体，特点是同一时间只有一个成员可用，长度为最长成员的长度。

#include <stdio.h>#define CHARACTER 'c'
#define INTEGRAL 'i'
#define FLOAT 'f'struct generic_tag{char type;union shared_tag {char c;int i;float f;} shared;
};...
struct generic_tag var;
var.type = CHARACTER;
var.shared.c = '^';

初始化共用体时只能初始其第一个成员。

使用typedef给结构创建别名

typedef struct{int x;int y;
} coord;coord topleft, bottomright;

struct coord{int x;int y;
};struct coord topleft, bottomright;

二者等价，但使用typedef时不需要关键字struct，不过此时标志符coord不是结构名。

第12天：变量作用域

外部变量(全局变量)：
程序中大部分或全部函数都需要使用的变量，应将其声明为外部变量。

外部静态变量：外部静态变量值位于它所在的文件中，且在它的定义之后的函数中可见。
常规外部变量：对于其所在文件中所有函数都可见，且其他文件中的函数也可以使用。
外部变量不初始化则默认初始化为0。
extern关键字
使用外部变量时，用extern来声明是个好习惯。
int x = 999;
int main(void)
{
extern int x;
}

局部变量：

静态变量：static int x，只在首次调用时被初始化1次，之后会保留前一次退出时的值。
不要在main函数中定义静态局部变量，这样毫无意义。
动态变量：auto int x，auto可以不加，只有在调用的时候存在。
局部变量不初始化其值不确定。

寄存器变量：register int x;对于频繁使用的变量，有极大的好处。

register关键字只是建议，而不是命令
register只能用于简单的数值变量，不能用于数组和结构，也不能用于静态变量和外部变量，不能定义指向寄存器变量的指针。

局部变量和代码块

可以在代码块(用花括号括起来的代码段)中声明局部变量，变量的声明必须在开头位置，对函数也一样。

#include <stdio.h>
int main(void)
{int count = 0;{int count = 999;}
}

很少用，常见用途是隔离程序的问题，并在其中创建局部变量来查找问题。

总结

通过在函数中声明大多数变量，可以提高函数间的独立性，除非有特殊的原因要求将变量声明为外部的或静态的，否则应将变量声明为动态局部。
定义结构时且没有声明实例，则不会占用内存，因此，最好将常用的结构定义放在外面，一般程序员都放在头文件中。
可以声明名称相同但类型不同的局部变量和全局变量，有些程序员在命名全局变量时，总是以g打头(例如gCount)，这样全局和局部一目了然。
局部变量和全局变量重名时会覆盖全局变量。

练习10
下面的程序若把ctr定义为全局变量，则会无限循环

/* 判断循环的参数若被修改可能无限循环 */
#include <stdio.h>
void print_letter2(void);
int main(void)
{int ctr;char letter1 = 'x';for (ctr = 0; ctr < 10; ctr++){printf("%c", letter1);print_letter2();}return 0;
}
void print_letter2(void)
{int ctr;char letter2 = '=';for (ctr = 0; ctr < 2; ctr++){printf("%c", letter2);}
}

第13天：高级程序流程控制

提早结束循环

只能位于for、while和do…while中。

break语句：跳出break所在的那一层循环。
continue语句：进入continue所在那层循环的下一次循环。

putchar();将一个字符显示到屏幕上。

goto语句

无条件跳转语句，goto语句和它要跳转的语句必须位于同一函数中，但可以位于不同的代码块中。
不要用goto语句。

死循环

while (1) 在循环内判断条件，用break跳出循环。

switch语句

switch是c语言中最灵活的程序控制语句。

case: statement; break；如果想执行一个case后结束switch语句，需要添加break，否则会一直执行到下一个break或最后一个case(或defalut)。与matlab不同。
如果case之后想结束程序，使用exit(0)。
如果要检查同一变量的两种以上的值，使用switch而不是if。
对齐case，一定要使用default。

表达式为多个值的任意一个时，都执行相同的语句块，可以利用break。例如：

        puts("\nenter number 1-5 0 for exit:");scanf("%d", &reply);switch (reply){case 0:exit(0);case 1:case 2:case 3:case 4:case 5:{printf("congradulation!!!oumeidaitou!\n");break;}default:puts("please be serious!\n");

退出程序

正常执行到main()函数的右花括号时结束，但可以随时调用库函数exit()来终止程序，也可以指定一个或多个在程序结束时自动执行的函数。
exit必须要包含头文件stdlib.h，它定义了两个符号常量，作为exit()的参数。
#define EXIT_SUCCESS 0
#defube EXIT_FAILURE 1
正常终止0，错误终止1。

程序中执行操作系统命令

c语言提供一个system()函数，可以在一个正在运行的程序中执行操作系统命令。可以无需退出程序就能读取磁盘的目录列表或对磁盘进行格式化。头文件stdlib.h。

system(command);
获得目录列表：

system("dir");
or
char *command = "dir";
system(command);

使用system的程序示例：

...
int main(void)
{char input[40];while (1){puts("enter command . blank to exit: ");gets(input);if (input[0] == 0)exit(0);system(input);}return 0;}

总结

goto语句(不用)，switch语句，case后面加break，否则会一直执行到下一个break。死循环。exit()。system()。

case可以检查long,int,char型变量，char型加单引号’’。

第14天：操纵屏幕、打印机和键盘

流和c语言

c语言采用流的方式执行输入和输出操作。

流是一个字符序列，准确的说，数据字节序列。
流的优点是，输入/输出编程是独立于设备的。
每个流都与一个文件相连，并不是磁盘文件，是程序处理的流和用于输入/输出的设备之间的桥梁。

流的模式有两种：文本流和二进制流。

ANSI预定义的流：stdin:键盘，stdout:屏幕，stderr:屏幕。

标准输入流会被自动打开，如gets()，scanf()，其他流(如操纵磁盘中信息的流)必须显示的打开。

while ((ch = getchar()) != '\n' && x < MAX)buffer[x++] = ch;
while ((ch = getchar()) != '\n' && x < MAX)buffer[++x] = ch;

c语言的流函数

c语言包含很多处理流输入和输出的函数，主要分为两个版本一个使用标准流，另一个需要指定一个流。

printf, vprintf, puts, putchar, scanf, vscanf, gets, getchar, perror使用标准流。
fprintf, vfp…, fputs, putc, fputc, fsc…, vfsc…, fgets, getc, fgetc 等需要指定流。

读取屏幕输入

c程序从键盘(stdin流)读取输入，输入函数分为三类：字符输入、行输入和格式化输入。

字符输入

字符输入每次从流中读取一个字符，这些函数被调用时，返回下一个字符或EOF(到达文件末尾或出错)。
可以根据是否缓存与回显对字符输入进行分类。缓存指所有字符保存在一个临时存储空间中，按下Enter后再发送到stdin。回显指的是是否将输入的字符回显到stdout(即屏幕)中。

getchar()
int getchar(void);
具备缓冲和回显功能。
while ( (ch = getchar() ) != '\n' )
putchar(ch);
上面输入一串字符并回车后会显示两行字符。
getch() //不是ANSI标准的一部分
int getch(void);
不缓冲也不回显。
while( (ch = getch() ) != '\r') //;
putchar(ch);
上面输入只显示一行，回车后结束。’\r’是转义字符，表示回车。对输入进行缓存的函数会把回车转换为换行，不缓存的回车仍为’\r’。
getche() //不是ANSI标准
类似于getch()，不过会回显。
getc()和fgetc()函数
不会自动使用stdin，让程序指定输入流，主要是从磁盘文件读取字符。
ungetc()恢复一个字符
原型为：
int ungetc(int ch, FILE *fp);
ch：要恢复的字符。*fp：指定将字符归还到哪个流。FILE *fp用于与磁盘文件相关联的流。
恢复成功返回ch；否则返回EOF(stdio.h中定义的符号常量，值为-1)。

行输入

gets()
之前说过，讲一个char指针作为参数，返回一个char指针。读取stdin中的字符，直到到达换行符(\n)或文件末尾，并将换行符替换为空字符，之后存储到str指定的位置。原型为：
char *gets(char *str);
返回值是指向字符串的指针(str)，发生错误或读取字符前到达文件末尾，返回空指针。
fgets()
可以指定输入流和最多读取的字符数。
char *fgets(char *str, int n, FILE *fp);
str指定存储位置，n指定最多输入字符数(n-1)，FILE *fp指定输入流。
读取字符直到，遇到换行符、文件末尾或n-1个字符。

格式化输入

输入数字时，需要用格式化输入。

scanf("%d", &x);

可以再两个%d后面添加字符(%除外)，%d qwer %d则两次输入的字符直接必须加qwer。
添加的空格和制表符会被忽略。
常用转换说明符(%+)，d：十进制整数，u：无符号十进制整数，f：浮点数，[…]：只读取方括号内列出的字符，[^…]：只读取方括号没列出的字符。
精度限定符，改变它后面的类型说明符的含义，常用：%lld：long long 。 %llu：unsigned long long。 %lf：double。%Lf：long double。
%%读取%且不执行任何操作。

处理多余的字符

防止多余的输入留在stdin中，导致问题。
1.使用gets()。
2.使用fflush()。
int fflush(FILE *stream);，stream是要清洗的流。

    puts("Enter an integer and a floating point number.");scanf("%ld qwer %lf", &l1, &l2);printf("you enterd %ld and %lf.\n", l1, l2);fflush(stdin);

控制屏幕输出

同样分为字符输出、行输出和格式化输出三类。

字符输出

putchar()、putc()、fputc()。
int putchar(int c);将变量c中字符写入stdout，返回写入的字符，错误返回EOF。
putc()以宏的方式实现fputs()。
int fputc(intc, FILE *fp);如果指定的流为stdout，则fputc与putchar相同。

putchar('x');
// =
fputc('x', stdout);

行输出

puts()、fputs()。
int puts(char *cp);
fputs可以指定流。

格式化输出

printf()、fprintf()。
fprintf()可以指定输出流，通常用于将数据输出到磁盘文件。
printf必须包含格式化字符。格式化可以是一个字符串的指针：

char *fmt = "the answer is wrong!";
printf(fmt);

格式化字符中除转换命令以外的字符将按原样显示。

转化命令的组成部分如下：
%[flag][field_width][.[precision]][l/ll]conversion_char
常用转换字符包括：d, u, o, x, c, e, f, s ,%。

l：指定参数为long或double。ll：指定为long long。
精度指定小数位数或输出的字符数，如果只包含小数点，则精度为0。
*，用于指定字段宽度。例如: printf("%*f", n, d1);
flag有四种：-、+、’ '、#。
-：输出左对齐
+：有符号数显示符号
’ '：正数前加空格
#：%-#15o %-#15x分别是显示八进制和十六进制。

格式化字符串中可以包含转义序列：\n等。

重新定向输入/输出

可以在命令提示符里输入指令，使：

发送到stdout的输出重新定向到磁盘或打印机
让stdin的程序输入来自磁盘文件而不是键盘。

例如：
redirection > test.txt
redirection >> test.txt
后者>>为附加模式，>为覆盖模式。
redirection < INPUT.TXT
redirecton < INPUT.TXT > junk.txt

因为在vscode的poweshell里输入出错，查了一下原来和cmd不是一个同东西。

使用fprintf()

fprintf()主要用于处理磁盘文件。也可以重新指定到别的输出流。例如：
fprintf(stderr, "error");
因为stdout的输出可被重新定向，stderr不能把重新定向，因此应保证错误信息总是显示在屏幕上，所以此时使用fprintf()。

fprintf(stdprn, "xxx");
输出发送到打印机。

总结

学习了流，ANSI C有三个预定义的流，stdin，stdout，stderr。
读取字符分为字符输入，行输入和格式化输入，字符输入根据是否缓冲和回显分类
输出同样分为三类。printf中%后面可以加[flag] [field_width] [.[precision]] [l/ll]转换说明符
错误消息应发给stderr。

发现这种总结一本书的学习方式还是比较浪费时间的，并且也没有多么大的意义，写完这个21天c之后我打算换一种方式，不把每一个细节都写上来。只写重点，关键的理解。