C语言基础学习

汇编语言又叫符号语言

出来机器语言和汇编语言外其他语言必须经过翻译（编译，和解释行）才可以执行

.c --> 编译（翻译成二进制代码 .obj）
链接 把目标程序和库函数以及其他目标程序链接起来，生成可执行的 exe 文件

//从命令行输入
scanf("%d", &a);

c程序总是从 main 函数开始执行

程序=数据结构+算法

两大类计算机算法：
    数值型运算算法 非数值运算算法

算法特性：有穷性、确定性、有效性

流程图：缺点 箭头太多，程序复杂的时候会很乱
N-S图（盒图） ：去掉了箭头 表示简单、符合结构化思想

结构化程序：顺序、选择、循环


结构化程序共同点；
    1、单入口，但出口
    2、结构体内的每一部分代码都有机会被
    3、不存在死循环

都区分大小写    

数据类型：
    1、基本类型
    2、构造类型（由基本类型组成）
    3、指针类型
    4、空类型
    
常量：程序运行时不能改变的量
    1、常量区分为不同类型（表示形式）
        如： 12 2.3 ‘a‘(字符型常量)
    2、符号常量：用一个标识符来代表一个常量
        #define 标识符 常量
        #define NAME "sjk"
        
变量先定义在使用，一般符号常量用大写，变量名用小写

十六进制中字母不区分大小写

整形数据在内存中以二进制的补码表示
    整数的源码和补码相同
    负数：源码取反 +1
    
    符号位：0整数 1负数
    
    short int: 1
    int      : 2
    long int : 4
    
    有符号（signed）(默认)
    无符号(unsigned)
        
整数后有后缀 u 或 U ，认为是unsigned类型
整数后有后缀 l 或 L ，认为是长整形(在严格要求类型匹配的场合有用，如函数参数)
    如： 123u 123l

实数又称浮点数
    1、十进制形式 0.345 .345 0.0 .0 0.
    2、指数形式: e的前后必须要有数字,且必须是整数 .3e3 3e3 3.e3
    3、缺省 为 double 
        后缀f或F为 float ， l或L为 long double类型
        
    float: 4byte 7位有效位
    double：8byte 15~16有效位
    long double 10byte 15~16有效位
    
    实数在内存中均是以指数形式存放
    
    超过有效位则被舍去，会产生误差
    
字符型：
    用单引号括起来的一个字符
    转义字符(代表一个字符) 特殊的字符常量
    
    \ddd 1~3位八进制表示的字符（ascii码） ‘\101‘ 表示 ‘A‘
    \xhh 1~2位十六进制表示的字符（ascii码） ‘\x41‘ 表示 ‘A‘
    
unsigned char c1 = ‘a‘; //无符号字符型
char c2=‘\101‘;
    
    字符变量中存储的是这个字符对应的ascii
    字符数与整形数据可以相互赋值
    字符数据可以以字符型输出也可以以整形输出 
    
    默认为有符号的

字符串常量：
        用一对双引号括起来的字符序列
        字符串结束标记 ‘\0‘ ,每一个字符串常量结尾都有一个 \0 (一般由系统自动添加 )
        ‘a‘为一个字符， "a"为两个字符

变量如果不赋值，则里面的值是随机的
    不可以连续赋值
    
不同类型的混合运算：
    先转换成同一类型，在运算 
        按类型级别由低到高的顺序转换
        float在运行时一律先转成double
        字符型和short型在运算时一律先转成int类型
        
运算符：
    %要求两侧为整形数据 
    
强制类型转换：
    (double)a
    (int)(x+y)
    
-i++ <==> -(i++)    

赋值结果和类型转换
1、实型赋值给整形时，把小数部分直接舍去
2、整形赋值实型时， 数值不变，但以浮点数的形式存储到变量中
3、长度相同的有符号与无符号整数间，原样复制(但数值可能会变化)
4、char int long类型转换
    短数据赋给长变量 
    符号扩展：短->长 若最高位为1（负数）， 则变量高字节位补1，反之补0
              长->短 只是将低字节位原封不动发送到变量中(数据可能有差错)


逗号表运算符和逗号表达式
    表达式1，表达式2 ... 表达式i
    计算过程：表达式依次求解，表达式的结果为最后一个表达式的值
    逗号运算符是运算级别最低的
    
    a = (1+3,2+8); //a=10
    
    int a=1;
    printf("%d", a=a+1, a=a+2); //从右往左开始运算，没有输出控制符则不输出
    
    
putchar:输出一个字符 参数可以是字符型或整形
getchar:从键盘缓冲区读取一个字符，多余的字符舍去 按回车后才开始接收字符
    
    
    
printf：

    % - 0 m.n l/h 格式字符
    
%：格式说明的引导符
-：指定左对齐输出
0：指定空位置填0
m.n：指定输出域宽度及精度
l/h:输出长度的修正
格式字符： 指定输出的数据类型

        d:十进制整数
        o:无符号八进制
        x:无符号十六进制
        u:无符号十进制
        c:输出一个字符
        s:输出一个字符串
        e:以指数形式输出
        f:以小数的形式输出实型数
        g:自动决定输出格式为e或f
        
        l:对整形指长整形
            %ld, %lx , %lo, %lu
          对实型指双精度
            %lf
        h:只是用于整形 short的修正
            %hd, %hx, %ho, %hu
            
        m:域宽 占字符个数(小数算一位)
        n:精度 小数位数        
        
注意：1、编译程序只检查printf函数的调用形式，不分析格式字符和后面的类型是否匹配，不进行类型转换, 
         所以要前后保持类型的一致
      2、格式字符要用小写
       
scanf:
    输入数据的分割：
        1、采用隐含的分隔符：空格 回车键 tab键
        2、根据格式中指定的域宽分隔数据（不提倡） scanf("%2d3d", &a, &b); // 12345 ==> a=12, b=345
        3、采用用户指定的分隔符（不提倡） scanf("%2d,3d", &a, &b); // 12,345 ==> a=12, b=345

注意：不能使用u说明符，对unsigned型数据用 d,o,x说明输入
      不能规定数据的精度
      %c 一次接收一个字符，无需单引号，空格字符是个有效的字符
      
优先级：算数运算符>关系运算符>赋值运算符>逗号运算符      
      
关系表达式：
        数值量比较：数字的大小
        字符量比较：ascii大小
        
值：真（1） 假（0）      
非零--真
零--假

条件运算符与条件表达式 ? : 
    高于赋值运算低于算数、关系、逻辑运算
    
        
对于单精度使用 %f 时前7位为有效位 小数6位    
对于双精度使用 %lf 时前16位为有效位 小数6位    
    
开关语句：
        switch(e) e可是整形、字符型、枚举型 但不可以是实型
        

循环的四种：
    1、goto + if构成的循环
        格式：goto 语句标识符 无条件的转到标号所指的语句
        语句标识符：用于定义程序中的某个位置，用标识符表示，不能只用数字
        滥用goto语句会破坏结构化，应限制使用
    2、while
    3、do while
    4、for
    
//要求用户必须输入 a    
char c;
while((c=getchar()) != ‘a‘);

基础类型都是单独存储的

构造类型：是由基本类型构造而成的（如：数组、结构体、共同体、枚举型）
构造类型的每一个分量是一个变量或一个简单类型或构造类型
构造类型的分量的使用方法和简单变量相同
构造类型的分量占用相邻的存储空间

数组： 有序、类型相同的变量的集合 用连续的内存单元来存放各个元素

数组的个数必须是常量 int a[10];

sizeof:占用字节数

数组只能引用数组元素、而不能一次引用整个数组

标准c只有静态存储(static) 数组和外部存储数组(extern)数组才能初始化,但其他有的编译系统自动的也可以初始化

int a[2]={1,2};  //赋初值
int a[3]={1} ;   //其他为0
int a[3]; //值为随机的
int a[] = {1,2,3}; //数组长度为3

注意：对static数组不赋初值，系统会对所有数组元素自动赋值0


二维数组：
    存储器是一维的，但需要一定规则进行转换
    二维数组在内存中的排列顺序是按行排列

初始化：
    int x[2][3] = {1,2,3,4,5,6}; //按存放顺序
    int x[2][3] = {{1,2,3},{4,5,6}}; //按行赋值
    
    //部分赋值
    static int x[2][3]={1,2,3} //以顺序 , 其余为0
    static int x[2][3]={{1,2},{4}} //以行, 其余为0
    
    //省略一维的长度, 但二维的长度不能省
    static int x[][3] = {1,2,3,4,5,6};
    
字符数组：
    字符数组可以用来表示字符串，没有专门的字符串变量 
    
    int a[2] <==> char a[2]
    ‘\0‘表示空字符 null， ascii为0

c语言中将字符串用字符数组处理，为了测定字符串长度、规定字符串结束标记 ‘\0‘(null), 即遇到null时表示字符串结束 

赋初值：
        static char c[4] = {"abc"};
        char c[4] = {"abc"};
        char c[4] = "abc";
        char c[] = "abc";
    
        数组元素个数>=字符个数+1
        
        char c[3] = "abc"; //没有 ‘\0‘

单个字符:"%c"
整个字符串（数组）输入输出：用 %s 格式符描述 
 
 char a[10];
scanf("%s", a); printf("%s", a); //对于一维数组数组名就是地址, 对于二维数组，只写行下标时是地址
用 %s 输出，无论数组有多少个元素，只要扫描到‘\0‘遍结束

用%s输入时遇到空格或回车便认为一个字符串结束

&a[0][0] <==> a[0]

字符串处理函数：
gets（字符数组名） //从键盘输入一个字符串（以回车结束 ），放到数组中并且得到一个数组值，该函数值是字符数组的起始地址
puts(字符数组名/字符串) //将数组中的字符串（以‘\0‘结束的字符序列）输出到终端上，输完换行  ==> printf("%s\n", str);

puts(gets());

strcpy(字符数组1, 字符串/字符数组2); //讲后面的拷贝到前面的字符数组中
 注意：1、前面的长度要大于后面的长度
       2、拷贝时连同 ‘\0‘一起拷贝
       3、不能把字符串或字符数组直接赋值给一个字符数组
       
       char str[6], str2[6];
       str="china";（X） str表示一个地址，赋值语句要求左侧必须是一个变量 
       str[0]=‘c‘;（Y） //数组的每一个元素则是一个变量 
       
       str=str2; (x); //strcpy(str, str2)

strcat(字符数组1, 字符串/字符数组2)); 2连接到1的后面，并放在字符数组1中
链接时会吧字符数组1后面的\0先去掉

strcmp(字符串1/字符数组1, 字符串2/字符数组2); //逐个字符按ascii码进行比较
字符串1>字符串2 整数
字符串1=字符串2 0
字符串1<字符串2 负数

strlen(字符数组/字符串); //计算字符串长度，不含（‘\0‘）

strlwr(字符串) //大写转小写
strupr(字符串) //小写转大写


函数：
    形参只能是简单变量或数组不能是常量或表达式
    实参到形参的传递为值传递
    return 后的括号可以省略,后面的值可以是一个表达式,要与函数的类型一致
    省略了函数的说明，则默认为 int类型
    不同系统中实参的计算方向不一样，微机中参数从右往左计算实参的值
    
    函数要先定义后使用，否则在main前要有函数的说明 void max(int x,int y);
    库函数的原型说明放在头文件（.h）中，通过include预处理命令将这些原型插入到程序中
    
数组元素做实参-->同变量
若函数的形参是数组，对应的实参必须是数组名，用数组名做参数时传递的是数组的首地址，也可以不指定数组的大小，但需要设置一个参数来传递数组元素的个数

数组作为实参传递的是地址，共享同一单元的内存

int max(int a[], int n){}   调用 max(a, 10);

如果形参是多维数组，可以省略一维的大小，但不能省略其他维大小

多维数组实参传递数组名
int max(int a[][5]){}   调用 int a[4][5]; max(a);


变量的作用域：
    局部变量：函数内部定义的/形参/某个复合语句中定义的变量
              注意：如果局部变量范围有重叠，范围小的优先
            
    全局变量：函数体外部定义的变量， 从定义位置开始到源文件结束
              可以在函数之间传递数据
              局部变量和全局变量同名则局部变量优先
              
变量的存储类别：              
    生存期
    内存共用户使用的存储区空间：
        程序区
        静态存储区
        动态存储区
        
    自动型 auto(默认)  动态存储区 用完遍释放
    
    静态型 static 静态存储区 程序整个运行期间都不释放空间，知道程序运行结束才释放
                在编译时赋初值（仅赋一次初值）,如果没有赋初值，编译系统根据类型自动赋初值
                
    寄存器型 register 存储在寄存器中
        计算机的寄存器有限
        读写寄存器比读写内存速度要快，频繁操作的变量可以设置为
        寄存器变量对寄存器的占用是动态的
        
    外部型 extern
        
    
全局变量都是静态的    
    用extern说明一个在其他源文件中定义的全局变量
    用static说明一个不能在其他源文件中引用的全局变量
    
    应尽量减少全局变量
    
函数的递归调用：
    许多数学定义是用递归形式定义的
    !n = n*!(n-1)
    x^n
    
    直接递归调用
    间接递归调用 fn1->fn2->fn1   栈


内存单元采用线性编码，每个单元(8bit=1byte)具有唯一一个地址编码
变量的地址：系统为变量分配的内存单元的地址，是一个无符号整形数

变量的访问方式：
    1、直接访问
    2、间接访问  定义一个变量p，放a的地址，通过p访问a
    
指针变量：存放地址的变量
    p为指针变量，它存放着整形变量a的首地址，我们称指针变量p指向整形变量a
    
指针变量定义： 类型符  *指针变量名  // int *p1, *p2;
指针变量的类型所指向内存存放的数据的类型

值为地址，是一个无符号的整形数,但不可直接将整形常量赋值给指针变量

求地址运算符&
int a,*p;
p=&a;

相同类型的指针变量可以相互赋值
注意：若指针变量没有赋值则值是随机的

赋空值 NULL /0, p=null/p=0; 区别于没有赋值的情况

&任意类型的变量 //取地址
*指针变量       //指针运算符

?=*p //取内容
*p=? //存内容

例子：
    int a=2,*p=&a,*q=&a;
    
    // 2 2
    printf("%d %d \n", *p++ , *(q++) ); 
    
    p=&a, q=&a;
    printf("%d %d \n", *p, (*q)++ /*相当于 a++ */); //参数从右开始计算
    
1、左结合：自左至右的结合方向  e.g.: a-y+z
2、右结合：自右至左的结合方向  e.g.:a=b=c=2;
3、一个运算量两侧的运算符 优先级相同时，则按运算符的结合性所规定的结合方向处理
4、所有的单目运算符具有相同的优先级,又由于他们都是从右往左结合，因此 *p++ <==> *(q++)
参考：http://baike.baidu.com/view/1516130.htm?fr=aladdin

//只是交换的 x,y的地址
void swap(int *x, int *y)
{
    int *t;
    t=x;
    x=y;
    y=t;    
}

void swap(int *x, int *y)
{
    int *t; //t的地址指向是随机的，存在潜在的问题
    *t=*x;
    *x=*y;
    *y=*t;    
}

//right
void swap(int *x, int *y)
{
    int t; 
    t=*x;
    *x=*y;
    *y=t;    
}

一维数组和指针
数组名就是指向数组第一个元素的指针（首地址）
eg: int a[10],*p; 则 p=a <==> p=&a[0];

某一个元素的地址： p=&a[i]; //数组第二个元素的地址 即 *p == a[i];
数组元素的下标在内部实现时，统一按 基地址+位移 方式处理 即：a a+1 a+2
所以表示数组元素的地址可以用：p+i, a+i
表示数组元素的内容： a[i](下标表示法)、*(p+i)(指针表示法)、*(a+i)(指针表示法)

数组名a（数组的指针）是常量不可以改变， 指针变量p则为变量

指针可以进行加减运算 : *(p+_i)
指针相减：表示地址的间距
指针：比较运算符     指针 运算符 指针

字符串指针：
    用字符数组存放字符串（即含 ‘\0‘ 的字符数组看做字符串）
    字符串指针就是字符数组的首地址