C语言程序设计-谭浩强

文章目录

1 C语言
2 算法
3 顺序程序设计
- 3.1 数据的表示形式
- 3.2 输入和输出
4 选择程序结构
5 循环程序结构
6 数组
7 函数模块化
8 指针
- 8.1 动态内存分配
9 结构类型
10 对文件的输入输出
- 10.1 顺序读写
- 10.2 随机读写

1 C语言

1.1 计算机语言发展史

机器语言，二进制，计算机发展早期一般计算机指令长度为 16，即以 16 个二进制数组成一条指令

符号语言，用一些字母和数字表示一条指令，计算机通过汇编程序将其转换为机器指令。

高级语言，1950s出现了第一个高级语言 — Fortran。计算机通过编译程序将源程序转为机器指令的目标程序。

1.2 C语言简介

1972年，贝尔在 B 语言的基础上设计了 C 语言。C语言有两个标准，美国国家标准协会ANSI 和国家标准化组织 ISO。

C 语言是面向过程的编程语言，有下面一些特点：

允许直接访问物理地址，进行位操作，能实现汇编语言的大部分功能，可以直接对硬件进行操作
C 程序的可移植性好，编译系统简洁
生成的目标代码质量高，程序执行效率高。广泛运用于编写嵌入式程序

#include <stdio.h>             // 编译预处理指令 — 包含头文件
int main(){                    // 主函数
	printf("Hello World!\n");
	return 0;
}

1.3 运行 C 程序的步骤

1、编辑源程序文件，如 test.c

2、编译源程序。分为预编译和正式编译，对源文件首部的预处理指令，如#include<stdio.h> ，将头文件的内容读进来合并，代替预处理指令。

编译的作用：Ⅰ，语法检查；Ⅱ，生成二进制的目标文件，如 test.obj

一次编译只能生成一个源程序的目标文件

3、链接处理。目标文件不可执行，且一个程序可能包含多个源程序文件，编译后需要将所有的目标文件链接装配起来，得到一个整体的可执行程序。

4、运行可执行程序。

2 算法

$程序 = 算法 + 数据结构$
算法，解决问题的方法和步骤；数据结构，数据及其类型和组织形式

算法的特性：

有穷性，不会陷入死循环
确定性，没有歧义，每个步骤明确无误
输入和输出
有效性，没有bug，能够得到确定的结果

算法表示方式：流程图、伪代码，伪代码写算法并无固定严格的语法规则

3 顺序程序设计

例. 华氏温度转为摄氏温度

#include<stdio.h>
int main(){
	float f, c; scanf("%f", &f);
	printf("%f", (5.0/9) * (f-32));
}

3.1 数据的表示形式

#define Pi 3.14159        // 符号常量, 预处理时直接代替, 不分配存储单元
const float Pi = 3.14159; // 常变量, 分配存储单元

标识符，只允许字母、数字和下划线，且数字不打头

类型	字节数	范围		其他
char	1	-128~127	%c
short	2	-32768~32767	%hd	$-2^{15}\sim2^{15}-1$
int	4	$-2.15×10^9\sim 2.15×10^9$	%d	$-2^{31}\sim2^{31}-1$
long long	8	$-9.2×10^{18}\sim 9.2×10^{18}$	%lld	$-2^{63}\sim2^{63}-1$
unsigned int	4	$0\sim 4.3×10^9$	%u	$0\sim 2^{32}-1$
float	4	$3.4×10^{38}$	%f	有效数字 6位
double	8	$1.7×10^{308}$	%lf	15

基本整型 int，一般是 4 个字节，在存储单元中的存储方式是用整数的补码形式存放

负数的补码：其绝对值的二进制，对所有位取反，然后加一

对无符号整型赋值 -1，并不会报错，而是取表示范围内的最大值，以 unsigned short 为例，1 的原码为 0000 0000 0000 0001，则 -1 的补码为 1111 1111 1111 1111（取反加一），表示 $2^{16}-1$ .

#include<stdio.h>
int main(){
	float a = 2.0/3; double b = 20.0/3;
	// float, double 默认都显示6位
	printf("%f\t%f", a, b); // 0.666667   6.666667
	printf("%.10f", a);  // 0.6666666865 精度丢失
	printf("%.10lf", b); // 6.6666666667
}

3.2 输入和输出

#include "test.h"
#include "C:/temp/test.h"

尖括号表示的头文件，编译器从自己的根目录下去找所要的文件，如各种C库文件；
双引号，用于包含用户自己编写的文件，先在当前目录下找，找不到再在编译器目录下找

printf(格式控制, 参数)

字符串类型 %s
浮点型指定宽度和小数位数 %m.nf ，宽度m右对齐，保留n位小数，float的有效位是 6，double的有效位是 15（不是小数位，是全部数字位）。
- 左对齐 %-m.nf

谭浩强《C语言程序设计》 3.5.3 用printf函数输出数据，格式控制这里写的还算不错

char ch = getchar(); // 接收一个字符, 从输入缓冲区
putchar(ch);         // 打印一个字符

4 选择程序结构

控制语句

if … else
switch() case
break, return
逻辑运算符：与(&&)，或(||)，非(!)
条件运算符：a>b?(max=a):(max=b); 或 max = (a>b)?a:b;

switch(grade){ // switch case只支持整型数, 字符串或其他类型不支持
case 'A': printf("85~100\n"); break;
case 'B': printf("70~84\n"); break;
default : printf("other\n"); break;
}

5 循环程序结构

for(;;);
while() ;
do.. while();

continue, 结束本轮循环，开始下一轮循环；break，退出循环

6 数组

数组是一组有序数据的集合，所有元素属于同一个数据类型

int a[  ] = {1,2,3,4,5,6}; // 自动判断数组长度 6
int a[10] = {1,2,3,4,5,6}; // 系统自动给后4个元素赋值0
int a[10] = {0}; // 全部赋初值 0

二维数组

int a[3][4] = {{1,2,3,4}, {5,6,7,8}, {9,10,11,12}};
int a[][4] = {1,2,3,4,5,6,7,8,9,10,11,12}; // 自动判断行数

int a[3][4] = {{1}, {}, {9,10,11}}; 
int a[3][4] = {{1}, {5,6}, {9,10,11}}; //其他置0

字符数组

char c[] = "helloworld";

'\0' 代表 ASCII 码值为 0 的字符，并不是可见字符，是字符数组表示的字符串或字符常量的结束标志。

字符串处理函数

gets(char *); // 输入
puts(char *); // 打印

strcat(char [], char []);

char str1[30] = "Hello "; char str2[] = "World";
strcat(str1, str2); // 合并后的结果存入str1, 因此str1需要足够大
printf("%s", str1); // Hello World

strcpy(char[], const char *);

char str1[10], str2[]="hello";
strcpy(str1, str2); // strcpy(str1, "hello");
strncpy(str1, str2, 3); // str2的前3个字符拷贝到str1, 不影响str1其他元素

strcmp()
strlen()
strlwr()
strupr()

7 函数模块化

C程序的执行是从main函数开始的，期间可能调用其他函数，最终回到main函数，结束程序运行

主要分为系统提供的库函数和用户自定义函数

函数调用之前需要先声明或者定义，函数的首行称为函数原型(function prototype)

7.1 函数递归 — 汉诺塔问题

void hanoi(char a, char b, char c, int n){
    if(n==1)cout<<a<<"->"<<c<<endl;
    else{
        hanoi(a, c, b, n-1);
        cout<<a<<"->"<<c<<endl;
        hanoi(b, a, c, n-1);
    }
}
int main(){
    int n; cin>>n; // 移动 n 个盘子需要经历 2^n-1 步
    hanoi('A', 'B', 'C', n);
}

7.2 数组作为函数参数

float average(float array[]);
float average(float array[][4]); // 列数不可省(第二维)

数组名为函数实参时，是将实参数组的首元素的地址传给形参数组。改变形参数组会导致实参数组元素的值同时发生变化。

静态存储区：全局变量，静态变量 (static)
动态存储区：局部变量，函数形参，函数调用时的返回地址。

一般情况下，变量存储在内存中，使用时控制器会发出指令读取，再由运算器计算；对于使用频繁的变量，C提供 register关键字声明，直接将其存放到CPU中的寄存器，省去了从内存读取的过程。现在，编译器性能好，register基本弃用deprecated

extern

8 指针

指针就是地址

int a[] = {1,3,5,7,9};
int *p = a; // &a[0] 指向数组首元素
cout<< *p << " " << *(p+1) << " " << *(a+2);

指针运算

p+1 并不是将p值简单加 1，而是加上一个数组元素的字节数，这里是int 4字节，故指向数组下一个元素，即 a[1]
指针减法 p2-p1 = 两个元素的下标相减，而不是地址相减
两个地址不能想加

二维数组的指针

int a[][4] = { // 3 × 4
	{0, 1, 2, 3}, {4, 5, 6, 7}, {8, 9, 10, 11}
};
int (*p)[4] = a;
for(int i=0; i<3; i++){
	for(int j=0; j<4; j++)
		cout<< *(*(p+i) + j)<<'\t';
	cout<<endl;
}

指针数组（元素为指针类型的数组）

int* p[4]; // 该数组存放 4 个指针变量

指向指针的指针

char* name[] = { "Alice", "Bob", "Carle", "Daniel" };
char **p = name; 
cout<< *(p+1);

8.1 动态内存分配

函数执行成功，返回新内存首地址；内存分配失败会返回一个空指针（NULL）

void *malloc(unsigned size); // 开辟 size 个字节的连续空间
void *calloc(unsigned n, unsigned size); // 开辟 n 个长size的连续空间
void *realloc(void *p, unsigned size); // 给指针p指向的空间重新分配

void free(void *p);

9 结构类型

struct Student{
	char name[10];
	char sex;
	int age;
};

struct Student stu1; stu1.name = "Tom";

struct Student stu2 = {"Kitty", 'w', 18};

9.1 链表

头指针head，指向第一个元素结点的地址

struct ListNode{
	int data;
	struct ListNode * next;
};
struct ListNode* create(){ // 尾插
	int n; cin>>n;
	ListNode* p, *rear, *head;
	p = new ListNode; cin>>p->data;  // 头结点
    head = p; rear = p; // 首尾指针均指向头结点 
	
    while(n-- -1){
		p = new ListNode;
		cin>> p->data; 
		rear->next = p;
		rear = p;
	}rear->next = NULL;
    return head;
}
void print(ListNode* head){
	ListNode * p = head;
	while(p!=NULL){
		cout<< p-> data<<'\t';
		p = p->next;
	}
}

9.2 共用体 union

同一段内存单元，存放不同类型的变量，但一个时刻只有其中一个变量有效。

union Data{
	int i; char j; float k;
};

9.3 枚举 enum

每个枚举元素代表一个整数常量，默认 0,1,2,…

enum Weekday{
	sun, mon, tue, wed, thu, fri, sat
};

9.4 typedef

typedef long long ll;

10 对文件的输入输出

// 文件类型 FILE
FILE * fp;
fp = fopen("test.txt", "r");
if(fp == NULL) cout<<"cannot open this file\n";
fclose(fp);

mode	文件打开模式	文件不存在
r（默认）	只读方式打开，文件指针指向文件头	❌
r+	读写模式，文件指针指向文件头	❌
w	写入模式。文件指针指向文件头，原有内容清空。	创建
a	打开文件以写入，如果文件存在则在末尾追加	❌
b	二进制模式	❌

10.1 顺序读写

1、fputc

FILE *in = fopen("src.dat", "r");
FILE *out= fopen("dest.dat", "w");

char ch = fgetc(in);
while(!feof(in)){  // 文件复制 in to out
	fputc(ch, out);
	putchar(ch);
	ch = fgetc(in);
}
fclose(in); fclose(out);

2、fputs

char str[3][10];
for(int i=0; i<3; i++) cin>>str[i];
FILE * fp = fopen("test.txt", "w");
for(int i=0; i<3; i++) {fputs(str[i], fp);fputs("\n", fp);}

3、fprintf / fscanf 效果相同，都是写入文件

char s[] = "world";
FILE * fp = fopen("test.txt", "w");
fscanf(fp, "%d, %d", &i, &j);
fprintf(fp, "hello %s", s);

这种方法不适合频繁读写，ASCII <—> 二进制，下面介绍二进制读写 fread 和 fwrite

4、fread 和 fwrite

10.2 随机读写

rewind()，reseek()