zoukankan      html  css  js  c++  java
  • 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)
    指针相减:表示地址的间距
    指针:比较运算符     指针 运算符 指针
    
    字符串指针:
        用字符数组存放字符串(即含 '' 的字符数组看做字符串)
        字符串指针就是字符数组的首地址
        
  • 相关阅读:
    PhpStorm函数注释的设置
    thinkphp5 返回数组提示variable type error: array
    js获取json对象中的key和value,并组成新数组
    PHP生成随机字符串与唯一字符串
    yii2-admin扩展自定义目录
    PHP7.3发布啦
    服务器环境从PHP5升级到PHP7
    亲测能用的mysqli类,挺好用的
    PHP必用代码片段
    git flow的使用
  • 原文地址:https://www.cnblogs.com/siqi/p/4033103.html
Copyright © 2011-2022 走看看