第三周：C语言第一天

basketball610

今天开始是刘羽华讲课，把C语言的基本概念都讲了一遍：

讲了：变量类型，枚举，隐式声明和显示声明的区别，外部变量和静态变量

位操作是重点！
流控制讲了折半查找，还有冒泡排序

编程实例：

1.折半查找：对一组有序的排列来说，折半查找是最快捷的方法：

#include <stdio.h>
#include <stdlib.h>
int binsearch(int number,int arr[],int size)
{
    int start=0,end=size-1;
    int middle=(start+end)/2;
    
    while(end > start)
    {
    middle=(start+end)/2;
    //printf("%d\n",middle);
    if(number == arr[middle])
        return middle;
    else if(number < arr[middle])
        end = middle-1;
    else
        start = middle+1;
    }
    return -1;
}

main(void)
{
    int arr[]={1,3,5,7,9,11,13,15,17,19,21,23,25};
    int ind;
    ind = binsearch(15,arr,13);
    printf("%d\n",ind);
}

2.冒泡排序：

void my_sort(int arr[],int n)
{
    int i,k;
    int temp;
    for(i=0;i<n;i++)
    {
        for(k=0;k<n-i;k++)
        {
            if(arr[k]>arr[k+1])
            {
                temp=arr[k];
                arr[k]=arr[k+1];
                arr[k+1]=temp;
            }
        }
    }
}

3.位操作
1）一些有用的函数：
#include <stdio.h>
#include <stdlib.h>

#define BITMAX    32

void showbits(int number) //将一个int 整数以2进制方式显示出来
{
    int temp = number;
    int bit;
    int i;
       for(i=BITMAX-1;i>=0;i--)
       {
    bit = (temp & (1 << i)) >> i;
    printf("%d",bit);
       }
}

int bit_num(void) //查看本机器支持的最大位数，i386机器一般为32位
{
       int i=1;
       int count=1;
        while(i>0)
        {
        i=i<<1;
        count++;
        }
    return count;
}
/*
main(void)
{
    int a=28;
    printf("The number of bit in this machine is %d\n",bit_num());
    showbits(a);
}
*/

2）
第三位取1 a | (1<<3)
第三位取0 a & ~(1<<3)
取第三位数值 bit = (a & 8) >> 3
非零整数的二进位取值 (！！a)

#include <stdio.h>
#include <stdlib.h>
#include "usefull.c"

void showbits(int number);
int bit_num(void);

main(void)
{
    int a=115;
    int a1,a2,bit;
    printf("a =%d:",a);
    a1=a|(1<<3);
    a2=a&~(1<<3);
    showbits(a);
    printf("\na1=%d:", a1 );
    showbits(a1);
    printf("\na2=%d:", a2 );
    showbits(a2);
    bit = (a & 8) >> 3;

    printf("\nThe 3rd position of a is %d\n",bit);
}


课堂笔记

/***********************
 *  快速的旅行
 **********************/

1、Hello world

每一个C语言程序都由函数和变量组成。
函数中包含一些语句，用以指定要执行的操作；
变量用于存储计算过程中使用的值。

通常函数名和变量名都没有限制，但main是一个特殊的函数。
C程序都有且只有一个main函数，程序会从main函数开始执行。
可以用传参数的方式在函数间交换数据。
函数中的语句用一对花括号｛｝括起来。

2、变量与算术表达式

考虑一个程序，用公式 C = (5/9)(F-32)打印温度对照表：
华氏（Fahrenheit）    摄氏（Celsius）
0            -17
20            -6
40            4
60            15
80            26
100            37
...            ...
...            ...
280            137
300            148

基本数据类型：
char
short
int
long
float
double

3、控制语句

for
if
goto

4、符号常量

#define 名字 替换文本

5、数组

6、函数

7、字符输入/输出

int getchar(void)
int putchar(int c)

int mygetline(char *s, int len);

大整数加法(可选)








/***********************
 *  类型、运算符与表达式
 **********************/

1、变量名

名字是由字母和数字组成的序列，第一个字符必须为字母。下划线"_"被看做是字母。
变量实际上是一段带有名字、类型的存储空间。

位与上下文

2、数据类型和长度

C语言只提供了下列几种基本数据类型：
char
int
float
double

类型决定了程序将如何使用一段存储空间。

3、常量

类似 1234 的整数常量为 int 类型
long 类型的常量以字母 l 或 L 结尾
无符号常量以字母 u 或 U 结尾
后缀 ul 或 UL 表示 unsigned long 类型

浮点常量中包含一个小数点（如12.3）或一个指数（如12e-3），也可以两者皆有。
没有后缀的浮点数常量为 double 类型
后缀 f 或 F 表示 float 类型
后缀 l 或 L 表示 long double 类型

带前缀 0 的整数常量表示它为八进制格式
带前缀 0x 或 0X 的整数常量表示它为十六进制格式

一个字符常量是一个整数。例如：在ASCII字符集中，字符‘0’的值为 48
某些字符可以用转义序列表示，如 '\n'

字符串常量 "hello, world!"
C风格的字符串包含尾0
编译时可以将多个字符串常量连接起来。例如：
"hello, ""world" 等价于 "hello, world!"

常量表达式是仅仅包含常量的表达式。这种表达式在编译时求值。

枚举是一个常量整型值的列表。
enum boolen {NO, YES};

4、声明

所有的变量及函数都必须先声明后使用。
一个声明指定一种变量类型，后面所带的变量表可以包含一个或多个该类型的变量。
int i, j, foo[16];

变量可以在声明的时候初始化。
int i = 0;

外部变量和靜态变量默认初始化为 0

变量的声明可以使用 const 限定符。
该限定符指定的变量的值不能被修改。

5、算术运算符

＋ － ＊ / %
% 不能用于浮点类型

6、关系运算符和逻辑运算符

关系运算符
＞  ＞＝  ＜  ＜＝  ＝＝  ！＝

逻辑运算符
&&  ||  !

由 && 和  || 连接的表达式按从左到右的顺序进行求值，并且在知道结果值为真或假后立即停止计算。

根据定义，在关系表达式或逻辑表达式中，如果关系为真，则表达式的结果值为数值1；如果为假，结果值为数值0。

7、类型转换

当一个运算符的几个操作数类型不同时，需要通过一些规则把它们转换成某种共同的类型。

类型转换分为自动转换（隐式）和强制转换（显式）两种。

一般来说，自动转换是指把表达能力弱的操作数类型转换成表达能力强的操作数的类型。
详细规则参见 ISO/IEC 9899:1999(E) 6.3.1.8

强制转换：
（类型名）表达式

8、自增和自减运算符

++   --

9、按位运算符

& 按位与
| 按位或
^ 按位异或
<< 左移
>> 右移
~ 按位求反

10、赋值运算符

=  +=  -=

大多数二元运算符都有一个相应的赋值运算符 op= ，op 可以是下面运算符之一：
+  -  *  /  %  <<  >>  &  |  ^

赋值语句本身也具有值，并且可以用在表达式中。

11、条件表达式

expr1 ? expr2 : expr3

12、优先级与求值顺序








/***********************
 *  控制流
 **********************/

1、语句与程序块

在表达式之后加上一个分号 ";" ，它们就成了语句。

用一对花括号 "{" 和 "}" 把一组声明和语句括起来就构成一个复合语句（也叫程序块）。
复合语句在语法上等价于单条语句。
右花括号 "}" 用于结束程序块，其后不需要分号。

2、if-else 语句

if-else 语句用于条件判断。语法如下：
if (expression)
    statement1
else
    statement2

else 部分可选。该语句执行时，先判断 expression 的值，如果其值为真（非 0），则执行 statement1 。
反之，如果其值为假（expression 的值为 0），则执行 statement2 。

因为 else 部分可选，所以在嵌套的 if 语句中会导致歧义。
C语言规定每个 else 与最近的前一个没有 else 配对的 if 进行匹配。
建议在有 if 语句嵌套的情况下使用花括号。

3、else-if 语句

折半查找

4、switch 语句

switch (expression) {
case const-expr: statements
     break;
case const-expr: statements
default: statements
}

5、while 循环和 for 循环

冒泡排序

void reverse(char s[])

逗号运算符

6、do-while

itoa()

7、break 和 continue 语句

8、goto









/***********************
 *  函数与程序结构
 **********************/

函数可以把大的计算任务分解成若干个较小的任务，程序员可以基于函数进一步构造程序，而不需要重新编写所有代码。
函数还可以将程序中不需要了解的具体细节隐藏起来，从而使程序结构更清晰，并降低修改程序的难度。

1、函数的基础知识

返回值类型 函数名（参数表）
｛
    声明和表达式

    return 返回值或表达式
｝

grep

2、外部变量

函数都是外部的。

栈

逆波兰序计算器（可选）

3、作用域规则

名字的作用域是指程序中可以使用该名字的部分。

变量
函数

4、头文件

5、静态变量

6、寄存器变量 register

7、const 和 volatile

8、程序块结构

9、初始化

10、递归（可选）

itoa()

11、C预处理器

文件包含
#include "文件名"
#include <文件名>

宏替换

#define 名字 替换文本

#define max(A, B) ((A) > (B) ? (A) : (B))

#undef

条件包含

#if
#else or #elif
#endif

defined(identifier)
defined identifier

#if !defined(identifier)
#define identifier
    ...
    ...
#endif

#ifdef
#ifndef

12、函数的实现（可选）









/***********************
 *  指针与数组
 **********************/

指针是一种保存变量地址的变量。

1、指针与地址

＆取地址，只能用于变量和数组元素。
指针的声明，赋值，类型。
间接引用。&*a

2、指针与函数参数

swap()

用指针传结构体（可选）

3、指针与数组

数组声明。含义。
数组初始化，赋值。
数组名，与指针的对应关系。
类似的操作方式。

在函数定义中，形参
char s[] 等价于 char *s

4、地址算术运算

指针的比较，运算，＋、－、自增。强调类型。强调(*ip)++的括号。
指针和整型的关系。互相可以转化，不可移植。

5、字符指针与函数

字符串常量是一个字符数组。

char amessage[] = "hello world!";
char *pmessage = "hello world!";

strcpy
strcat
strcmp

6、指针数组以及指向指针的指针

指针数组与数组指针。

7、多维数组

8、指针与多维数组

9、命令行参数

10、指向函数的指针

11、复杂声明











/***********************
 *  结构
 **********************/

1、结构的基本知识

考虑一下，如果我们要存储一个复数，或者是一个矢量，或者是一个坐标值。

struct point {
    int x;
    int y;
};

关键字 struct 引入结构声明。结构声明由包含在花括号内的一系列声明组成。
关键字 struct 后面的名字是可选的，称为结构标记。结构标记为结构命名。
在定义之后，结构标记就代表花括号内的声明，可以用它作为该声明的简写形式。

结构中定义的变量称为成员。结构成员、结构标记和普通变量可以重名。

struct point a, b, c;
struct {...} x, y, z;
int x, y, z;

初始化，必须是常量表达式
struct point foo = {3000, 8000};

引用
结构名.成员

结构可以嵌套。

sizeof 对象
sizeof(类型名)

2、结构与函数

结构的合法操作只有几种：
作为一个整体复制和赋值，通过 & 运算符取地址，访问其成员。

结构指针
struct point *p;
p->结构成员

3、自引用结构

malloc()
单链表

4、表查找 （可选）

5、类型定义

typedef int LENGTH;
typedef char *STRING;

typedef int (*PFI)(char *, char *);

6、联合

联合提供了一种方式，在单块存储区中管理不同类型的数据。

union a {
    int a;
    float b;
    char *c;
} d;

联合名.成员
联合指针->成员

7、位字段 （位域）

struct {
    unsigned int a : 1;
    unsigned int b : 2;
    unsigned int c : 1;
} flags;

位序的问题：
据说常有公司出有关位域的面试题。
不同机器的位序不一致。
X86平台从低到高。

例：
union {
    struct {
        char a:1;
        char b:2;
        char c:1;
    } s;
    char d;
} u;
u.d = 1;
printf("%d\n", u.s.a);







/***********************
 *  再论函数
 **********************/

1、变量的类型

2、栈

3、x86 平台 linux 进程的内存结构

4、函数的参数传递

5、用一个反汇编代码来观察函数的栈实现

6、递归

数学归纳法

7、变长参数表









/***********************
 *  标准库
 **********************/

1、stdio.h

2、stdlib.h

3、string.h