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 (一般由系统自动添加 )
        'a'为一个字符, "a"为两个字符

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

赋值结果和类型转换
1、实型赋值给整形时,把小数部分直接舍去
2、整形赋值实型时, 数值不变,但以浮点数的形式存储到变量中
3、长度相同的有符号与无符号整数间,原样复制(但数值可能会变化)
4char 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可是整形、字符型、枚举型 但不可以是实型
        

循环的四种:
    1goto + if构成的循环
        格式:goto 语句标识符 无条件的转到标号所指的语句
        语句标识符:用于定义程序中的某个位置,用标识符表示,不能只用数字
        滥用goto语句会破坏结构化,应限制使用
    2while
    3do while
    4for
    
//要求用户必须输入 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]
    ''表示空字符 null, ascii为0

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

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

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

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

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

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

puts(gets());

strcpy(字符数组1, 字符串/字符数组2); //讲后面的拷贝到前面的字符数组中
 注意:1、前面的长度要大于后面的长度
       2、拷贝时连同 ''一起拷贝
       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后面的先去掉

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

strlen(字符数组/字符串); //计算字符串长度,不含('')

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 
", *p++ , *(q++) ); 
    
    p=&a, q=&a;
    printf("%d %d 
", *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)
指针相减:表示地址的间距
指针:比较运算符     指针 运算符 指针

字符串指针:
    用字符数组存放字符串(即含 '' 的字符数组看做字符串)
    字符串指针就是字符数组的首地址
    
原文地址:https://www.cnblogs.com/siqi/p/4033103.html