精华内容
下载资源
问答
  • C语言重难点

    2020-11-23 16:17:03
    C语言 编译过程 GCC概述 GCC最初的全名是GNU C Compiler 随着GCC支持的语言越来越多,它的名称变成了GNU Compiler Collection 翻译官 翻译组织 文件后缀名 gcc .c gcc -o output gcc -o 输出的文件名 输入文件名 gcc...

    C语言

    编译过程

    GCC概述

    GCC最初的全名是GNU C Compiler
    随着GCC支持的语言越来越多,它的名称变成了GNU Compiler Collection
    翻译官 翻译组织

    文件后缀名 gcc
    .c

    gcc -o output
    gcc -o 输出的文件名 输入文件名

    gcc -v -o

    c语言的编译过程

    预处理—编译—汇编—链接

    预处理: .I 文件 替换过程,没有include define等

    编译: 汇编文件 .s

    汇编: 生成目标文件 .o

    链接: 链接资源 build

    gcc的语法所对应的内容

    预处理:cpp -o a.i 001.c 【gcc -E】
    编译 :/usr/lib/gcc/i486-linux-gnu/4.4.3/cc1 -o a.s 001.c 【gcc -S】
    汇编:as -o a.o a.s 【gcc -c】
    链接:/usr/lib/gcc/i486-linux-gnu/4.4.3/collect2 -o build a.o+… 【gcc -o】 gcc -o build 001.c
    【问题】
    define include是关键字吗? 是预处理命令

    预处理

    Include

    < > 尖括号是系统中的

    " "是自定义的

    #include 包含头文件

    #define 宏 替换 不进行语法检查

    #ifdef #else #endif 条件预处理

    #include <stdio>
    #define ABC
    int main(){
        #ifdef ABC
        		printf("=====%s=====",——FILE__);
        #endif
        		printf("hello world\n“)return 0;
    }
    

    发行版本不希望别人看到自己的代码结构,可以设置#ifdef #else#endif ,来调节是否打印。

    gcc -DABC == #define ABC

    预定义宏(两个下划线)

    _FUNCTION_ :函数名

    _LINE_: 行号

    _FILE_ : 文件名

    宏体# ## 区别:

    # 字符串化

    ## 连接符号

    #include <stdio>
    #define ABC(x)		#x
    #define DAY(x)		myday##x
    
    int main()
    {
        int myday1 = 10;
        int myday2 = 20;
        printf(ABC(ab\n));
        printf("the day is %d\n",DAY(1));
        return 0;
    }
    

    结果:

    ab

    10

    DAY(1)调用的是myday1,通过#连接myday

    关键字

    数据类型

    硬件芯片操作的最小单位:
    bit 1 0
    软件操作的最小单位: 8bit == 1B

    网速之间的转换:

    ​ 4M 4Mbit Kbit/s KB/S

    char

    硬件芯片操作的最小单位: bit

    软件操作的最小单位: char

    8bit = 1B

    硬件处理的最小的单位: char

    最大的是256

    int

    大小: 根据编译器来决定。

    编译器最优的处理大小:

    系统一个周期,所能接受的最大处理单位 int

    32bit的系统,4B 恰好能接收int类型

    16bit的系统 , 2B int

    300L 后面的L表示long类型的,可以表示一个很大的数,

    long short

    特殊长度

    unsigned、signed

    无符号:数据

    有符号:数字

    区别:内存空间的最高字节是符号位还是数据

    float、double

    浮点数

    float 代表 4B

    double代表 8B

    浮点型常量

    1.0f 是float类型

    1.1 是double 的类型

    void

    一般是声明标志,不是使用标志

    void fun() 表示函数不反悔。

    自定义数据类型

    C编译器默认定义的内存分配不符合实际资源的形式(例如定义寄存器的大小)

    struct 、union、enum、typedef

    struct

    元素之间的和

    struct myabc{
        unsigned int a;
        unsigned int b;
        unsigned int c;
    };
    struct myabc mybuf;
    

    结构体最后加分号,abc的顺序不同,可能结构的大小也不相同(涉及字节对齐的问题)

    union

    共用起始地址的一段内存(共用体

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-o8qu2Rvm-1606119305231)(file:///C:/Users/15890/AppData/Local/Packages/Microsoft.Office.OneNote_8wekyb3d8bbwe/TempState/msohtmlclip/clip_image001.png)]

    定义b,a可能发生改变。

    enum

    enumerate 一一列举

    被命名的整型常数的集合

    #define MON  0
    #define TUE   1
    #define WED  2
    /* 上述的宏可以表示为 */
    enum abc{ MOD = 0,TUE,WED }
    

    enum 枚举名称{ 常量列表 };

    #include <stdio.h>
    
    enum week{            
              Monday = 0 ,Tuesday =1 ,Wednesday = 2,
              Thursday,Friday,
              Saturday,Sunday
    };
    int main()
    {
        enum weel a1;			/* 定义了这样的空间 */
        printf("the a1 is %lu\n",sizeof(a1));
        printf ("the %d\n",WED);
        
        return 0;
    }
    

    运行结果:

    4

    2

    枚举变量就是个整数,只是这个整数可以取这集合面所有的值

    enum DAY{}day;定义枚举类型同时定义枚举变量;

    enum {}day; 可以省略名称,直接定义枚举变量;

    typedef

    数据类型的别名

    typedef int a_t;      /* a是一个int类型的外号 */
    a_t mysize;
    

    杂项

    Sizeof

    它是关键字

    编译器给我们查看内存空间容量的一个工具

    return

    :返回函数

    逻辑结构

    cpu是顺序执行程序

    PC 指针分支 --> 选择

    代码周期性的循环,节约内存。

    条件选择

    if else 、switch、case、default、

    循环

    do、while(条件)、for(次数)、

    循环中的控制符

    continue、break、goto(在同一个函数中可以跳)

    switch(整形数)

    {case 整形数i:

    }

    类型修饰符

    对内存资源存放位置的限定

    auto、register、static、const、extern、volatile

    有的可读可写,有的可读,有的可写

    Auto

    可读可写的内存空间 默认平时就是 auto char a;如果放入大括号里,就是存放在栈里;

    register

    register int a;限定变量定义在寄存器上的修饰符; 寄存器速度快,内存上面慢

    编译器会尽量的安排CPU的寄存器取存放这个a,如果寄存器不足,a还是放在存储器中。

    **&**这个符号对register不起作用;

    内存(存储器) 寄存器

    0x100 R0,R2

    static

    静态变量

    **修饰3种数据:**函数内部的变量;函数外部的变量;函数的修饰符;

    修饰3种数据:
    1)、函数内部的变量

    int fun()
     { 
       int a; ==> static int a;
     }
    

    2)、函数外部的变量

    int a;     ==>  static int a;
    int fun()
    {
    
    }
    

    3)、函数的修饰符

    int fun();  ==> static int fun();
    

    const

    常量定义、只读的变量,不能修改

    可以通过指针的技巧去修改

    extern

    外部申明;也是再全局变量中使用;

    volatile

    告知编译器编译不优化

    修饰变量的值的修改,不仅仅可以通过软件,也可以通过其他方式(硬件外部的用户)

    int a = 100;
    
    while( a==100 );
    
    mylcd();
    

    [a] 表示 a 的地址

    f1:  LDR  R0,[a]
    f2:  CMP  R0,#100
    f3:  JMPeq  f1        ---->     JMPEQ  f2
    f4:  mylcd();
    

    修饰变量的值的修改,不仅仅通过软件,也可以通过其他方式。例如: 如果外界接了键盘来键入a,则就会发生错误;

    运算符

    算术运算符

    +、-、*、/、%

    * 、/ 大部分是不支持的。

    CPU可以在一个周期处理+ ,但是 * 在一个周期处理不了,需要利用软件进行模拟实现乘法

    % 取模,4%3 = 1; 1%3=1;

    应用场景:

    1. 任意一个N,我们模上M过后,得到M进制的个位数;

    2. 取一个范围的数;

      ​ eg:给一个任意的数,得到一个1到100以内的数:(m%100)+1

    3. 循环数据结构的下标。

    逻辑运算

    真与假 返回结果为 1 和 0

    || 、 & 、

    A || B \neq B || A 不相等

    #include <stdio.h>
    int main()
    {
       int a =10;
       int res;
       
       res = ((a==10) || printf("======\n"));
       
       printf("the res is %d\n",res);
       return 0;
    }
    

    结果:1

    a若足,则不看式子后面的内容了,若把a != 10,则会输出 ====

    < 、>= 、 <= 、 >、!、? :

    位运算

    << 、 >>

    左移 : 乘法 *2 二进制下的移位
    m << 1; m×2\times2
    m << n m×2n\times2^n

    4:      0 0 1 0 0
    8:      0 1 0 0 0
     
    int a = b*32;    ===>  b <<5
    

    [数据、数字]
    -1 *2 -2:
    8bit (负数先取反,再加一)
    1 0 0 0 0 0 0 1 1 0 0 0 0 0 1 0
    1 1 1 1 1 1 1 0 1 1 1 1 1 1 0 1
    1 1 1 1 1 1 1 1 === -1 1 1 1 1 1 1 1 0 == -2

    负数也满足

    右移:除以2
    m >> n m/2^n
    符号变量有关 有符号数整数填1,无符号数填0.

    int a;          a>>n
    unsigned int a      a>>n
    int a = xxx;
    while(a){
         a = a>>1;
    }
    printf("-------------\n");
    

    如果a为负数,永远也不会为0;

    如果a为正数,可以为0;

    & 、 |

    A & 0 ----> 0
    &: 屏蔽
    int a = 0x1234;
    a & 0xff00; 屏蔽低8bit,取出高8bit

    &:取出

    A & 1 —> A

    &:清零器 clr

    |
    A | 0 = A
    保留
    A | 1 = 1
    设置为高电平的方法,设置set

    设置一个资源的bit5为高电平,其他位不变
    int a;
    a = (a | (0x1<<5)); =====> a | (0x1<<n)

    清除第五位

    int a;
    a = a & 0 1 1 1 1 1 31 a & 31 31 : 32bit
    ~(0x1<<5)

    a = a & ~(0x1<<5); =====> a = a & (~(0x1<<n));

    我们想资源456bit设置为101?

    ^

    相同位为假

    a = a ^ b

    b = a ^ b

    a = a ^ b

    可以交换 a ,b的值

    内存访问

    ( ) 限制符号

    ​ 函数访问符号

    [ ] 数组,内存访问的 ID 符号

    { } 函数体的限制符

    –> 地址访问

    . 变量访问

    C语言内存空间的使用

    指针

    指针的概述

    内存类型资源地址、门牌号的代名词
    指针变量 : 存放指针这个概念的盒子

    int a;
    int *p;
    char *p;

    C语言编译器对指针这个特殊的概念,有2个疑问?
    1、分配一个盒子,盒子要多大?
    在32bit系统中,指针就4个字节
    2、盒子里存放的地址 所指向 内存的读取方法是什么?

    ​ 声明,得到大小,一次读多少字节。确定位置

    指针指向内存空间,一定要保证合法性

    浮点数在内存中表现形式很奇怪

    浮点数读取,指针定义为unsigned,无符号类型。

    指针修饰符

    const

    常量、只读【不能变】

    双引号就是常量,不可改变 const char型

    内存属性:
    1、内存操作的大小
    2、内存的变化性,可写可读

    char *p;

    const char *p; 【T】 字符串 “ hello world” “aaa”

    char const *p;

    指向的内容不可以变,指针可以指向其他的地址 字符串

    char * const p; 【T】 硬件资源 LCD

    char *p const;

    指向的内容可以改变,指针不能指向别的地方 硬件资源 LCD

    const char * const p ROM

    第三种,都不可以变 ROM

    volatile

    防止优化指向内存地址

    char *p;

    volatile char *p ;
    
    *p == 0x10
    与之前的相同:
        while( *p == 0x10 );
    		xxxx;
    
    typedef

    char *p;

    什么类型 变量名称;

    xxx a;

    int  (*p[10])(int ,void (*p)(int));
    
    char *name_t  :             name_t是一个指针,指向了一个char类型的内存
    typedef char *name_t;   name_t是一个指针类型的名称,指向了一个char类型的内存
    
    name_t abc;
    

    指针运算符

    ++ 、–、+、-

    int a = 100;
    a+1

    int *p = xxx [0x12]

    p+1 [0x12 + 1*(sizeof(*p))]

    指针的加法、减法运算,实际上加的是一个单位,单位的大小可以使用sizeof(p[0])

    int *p p+1
    char *p p+1

    p++ p-- : 更新地址

    [ ]

    变量名[ n ]

    n:ID 标签
    地址内容的标签访问方式
    取出标签里的内存值

    操作逻辑符

    >= 、<= 、== 、 !=

    int *p1;
    int *p2;

    p1 > p2
    *p1 > *p2

    --------- == !=
    1、跟一个特殊值进行比较 0x0 : 地址的无效值,结束标志
    if( p == 0x0)
    NULL
    2、指针必须是同类型的比较才有意义
    char *
    int *

    多级指针

    int **p;

    存放地址的地址空间

    char **p;

    p[0] p[1] … p[n]

    p[m] == NULL ----> 结束了

    数组

    数组的定义

    内存的一种分配形式

    定义一个空间:
    1、大小
    2、读取方式

    数据类型 数组名[m] m 的作用域是在申请的时候

    数组名是一个常量符号,一定不要放到=的左边 ,举例。

    char buf[100];

    buf = “hello world”;

    数组名不能 a++,数组名就是数组的常量标签

    int a[100];

    越界
    a[10]

    数组空间的初始化

    空间的赋值
    按照标签逐一处理
    int a[10]; [ 0 - 9 ]
    a[0] = xx
    a[1] = yy;

    程序员这样赋值,工作量比较大,能不能让编译器进行一些自动处理,帮助程序员写如上的程序
    ----》空间定义时,就告知编译器的初始化情况,空间的第一次赋值,初始化操作

    int a[10] = 空间;
    C语言本身,CPU内部本身一般不支持空间和空间的拷贝
    int a[10] = {10,20,30};

    ====> a[0] = 10; a[1] = 20; a[2] = 30; a[3]=0;

    数组空间的初始化 和 变量的初始化 本质不同,尤其在嵌入式的裸机开发中,空间的初始化往往需要库函数的辅助

    char

    char buf[10] = {‘a’,‘b’,‘c’}; 3个字节

    buf当成普通内存来看,没有问题
    buf当成一个字符串来看,最后加上一个’\0’ 字符串的重要属性,结尾一定有个’\0’

    char buf[10] = {"abc"}; //4个字节
    char buf[10] = "abc"; //此时是**常量对变量的拷贝**,
    
    buf[2] = 'e';  //对的
    char *p = "abc";
       p[2] = 'e';  //会出现段错误
    
    char buf[] = "abcd";     //5个字节
    char buf[10] = "abc";
    buf = "hello world"  //错误 数组名不应该放到等号的左边,数组标签不能改。
    

    第二次内存初始化,赋值?
    逐一处理
    buf[0] = ‘h’ buf[1] = ‘e’ … buf[n] = ‘d’, buf[n+1] = 0; (不要忘了0)

    strcpy、strncpy

    一块空间,当成字符空间,提供了一套字符拷贝函数

    字符拷贝函数的原则:
    内存空间和内存空间的逐一赋值的功能的一个封装体
    一旦空间中出现了0这个特殊值,函数就即将结束。

    strcpy();
    
    char buf[10] = "abc";
    buf = "hello world";  //错误的 应该是下面这个
    strcpy(buf,"hello world"); 内存泄漏函数
    
    非字符串空间

    字符空间
    ASCII码编码来解码的空间,----》给人看
    %s abc ‘a ’ ‘b’ ’ c’
    \0作为结束标志
    非字符空间
    数据采集 0x00 - 0xff 8bit
    开辟一个存储这些数据盒子

    ​ char buf[10]; ----> string 字符
    unsigned char buf[10];----> data 数据

    buf = “abc”;
    unsigned char *p = sensor_base;
    只管逐一拷贝,结束在哪里?只能定义个数

    拷贝三要素:
    1、src
    2、dest
    3、个数

    memcpy
    int buf[10];
    int sensor_buf[100];
    
    memcpy(buf,sensor_buf,10*sizeof(int));
    
    unsigned char buf1[10];
    unsigned char sensor_buf[100];// 00 00 00 23 45 78
    strncpy(buf,sensor_buf,10)
    memcpy(buf,sensor_buf,10*sizeof(unsigned char));
    

    指针数组

    int a[100]
    char * a[100];  //100个地址
    
    sizeof(a) = 100 * 4;
    
    int b;
    sizeof(b)
    
    char **a;  //地址里面还是地址
    

    多维数组

    定义一个指针,指向int a[10]的首地址
    定义一个指针,指向int b[5][6]的首地址

    二维数组是一块一块读的,

    int *p1 = a;
    int **p2 = b;  //无效的指针类型
    
       int *p;           int *p[5];
       int a;             int a[5];
    
    int *p[5]; //p是5个空间,5个空间里存int*  与我们定义的一块一块读是不一样的。
    int (*p)[5]; //5个int指针 和int a[5] 相似
    

    结构体

    字节对齐

    strcuct abc
    {char a;
    int b};
    

    1 + 4 = 5

    效率,希望牺牲一点空间换取时间的效率
    最终结构体的大小一定是4的倍数

    结构体里成员变量的顺序不一致,也会影响到他的大小

    位域

    内存的分布图

    int a; 默认方式

    编译 —》汇编 —》链接
    *.o build

    4G的大小

    内核空间 应用程序不许访问 (占用1G


    栈空间 局部变量 RW


    运行时的堆空间 malloc


    全局的数据空间 (初始化的,未初始化) static RW data bss

    只读数据段 “hello world” 字符串常量 R TEXT

    代码段 code R TEXT


    0x0 :

    局部变量;

    函数结束后就会“销毁”失效了。

    局部的都在栈上

    全局未初始化—bss,初始化—data

    static 的变量也在全局 ,但是出了大括号就没用了(访问的局部变量),还是存在在全局变量的区域

    生成可执行文件,一般打包最后一个段中的内容。 text在代码段会代入build文件中,占据内存,release版本会把字符进行处理

    栈空间

    运行时,函数内部使用的变量,函数一旦返回,就释放,生存周期是函数内

    堆空间

    运行时,可以自由,自我管理的分配和释放的空间,生存周期是由程序员来决定

    分配:
    malloc(),一旦成功,返回分配好的地址给我们,只需要接受,对于这个新地址的读法,由程序员灵活把握,输入参数指定分配的大小,单位就是B。

     char *p;
     p = (char *)malloc(100);
    if(p == NULL){
      error
    }
    
    void fun()
    {
      char *p;
       p = (char *)malloc(100);
      return ;
    }
    
     int a[5];     malloc(5*sizeof(int))
    
    

    释放:
    free§;

    只读空间

    静态空间,整个程序结束时释放内存,生存周期最长

    C语言函数的使用

    函数概述

    一堆代码的集合,用一个标签去描述它

    函数 数组,函数具备3要素: int *p; int a[100];
    1、函数名 (地址)
    2、输入参数
    3、返回值
    在定义函数时,必须将3要素告知编译器。
    int fun(int,int,char)
    { xxx }

    如何用指针保存函数那?
    char *p;
    char (*p)[10];
    int (*p)(int,int,char);

    定义函数,调用函数

    int fun(int a,char b)
    {
      xxxx
    }
    int main()
    {
      fun(10,2);
    }
    
    char buf[100];
    buf[10];
    

    输入参数

    承上启下的功能

    调用者:
    函数名(要传递的数据) //实参
    被调者:
    函数的具体实现
    函数的返回值 函数名(接收的数据) //形参
    {
    xx xxx
    }

    实参 传递给 形参
    传递的形式:
    拷贝

    值传递

    特点:

    void fun(int a)
    {
         a = xx;
         a = sha md5 yy
    }
     
    int main()
    {
         int a = 20;
     
         fun(a);
     
         printf   a ==?
    }
    

    上层调用者 保护自己空间值不被修改的能力

    地址传递

    上层,调用者 让下层 子函数 修改自己空间值的方式,类似结构体这样的空间,函数与函数之间调用关系—> 连续空间的传递 (不传地址的话,只是 拿来看一下,并不改变本身的值)

    void fun(char a);    
       int main()
    {
          char a = 'e';
          fun(a);
          a == 'c'
    }
    void fun(char *b);
    
    int a = 10;
    
    fun(&a);
    
    a ===? 10
    
    int a;
    scanf("%d",a);    scanf("%d",&a)
    

    将a的值传递给函数,不能保证a还为10

    连续空间的传递

    1、数组
    数组名 — 标签
    实参:
    int abc[10];

    fun(abc)

    形参:
    void fun(int *p) void fun(int p[10])

    2、结构体
    结构体变量

    struct abc{int a;int b;int c;};
    struct abc buf;

    实参:
    fun(buf); fun(&buf)
    形参:
    void fun(struct abc a1) void fun(struct abc *a2)

    **" " —> 初始化const char *

    承上启下的功能

    调用者:
    函数名(要传递的数据) //实参
    被调者:
    函数的具体实现
    函数的返回值 函数名(接收的数据) //形参
    {
    xx xxx
    }

    实参 传递给 形参
    传递的形式:
    拷贝

    值传递

    特点:

    void fun(int a)
    {
         a = xx;
         a = sha md5 yy
    }
     
    int main()
    {
         int a = 20;
     
         fun(a);
     
         printf   a ==?
    }
    

    上层调用者 保护自己空间值不被修改的能力

    地址传递

    上层,调用者 让下层 子函数 修改自己空间值的方式,类似结构体这样的空间,函数与函数之间调用关系—> 连续空间的传递 (不传地址的话,只是 拿来看一下,并不改变本身的值)

    void fun(char a);    
       int main()
    {
          char a = 'e';
          fun(a);
          a == 'c'
    }
    void fun(char *b);
    
    int a = 10;
    
    fun(&a);
    
    a ===? 10
    
    int a;
    scanf("%d",a);    scanf("%d",&a)
    

    将a的值传递给函数,不能保证a还为10

    连续空间的传递

    1、数组
    数组名 — 标签
    实参:
    int abc[10];

    fun(abc)

    形参:
    void fun(int *p) void fun(int p[10])

    2、结构体
    结构体变量

    struct abc{int a;int b;int c;};
    struct abc buf;

    实参:
    fun(buf); fun(&buf)
    形参:
    void fun(struct abc a1) void fun(struct abc *a2)

    " " —> 初始化const char *
    char buf[10] —> 初始化char *

    展开全文
  • C语言重难点及分析

    2018-08-05 15:04:38
    C语言重难点及分析 。
  • 二级C语言重难点分析

    2008-11-20 19:43:21
    C语言重难点分析 需要注意的各个细节,基础的问题都有解答
  • C语言重难点分析

    2007-09-03 16:05:30
    C语言重难点分析,看一下吧,反正对我的帮助很大。
  • C语言重难点复习

    2018-09-02 11:40:01
    一、字节 1byte : char 2byte: short 4byte; int long 8byte : double long double 二、位 1字节=8bits 三、标识符 C语言规定,标识符必须由...(注:自定义的标识符不能与C语言规定的标识符相同,eg:...

    一、字节
    1byte : char
    2byte: short
    4byte; int long
    8byte : double long double

    二、位
    1字节=8bits

    三、标识符
    C语言规定,标识符必须由字母、下划线、数字三类符号
    组成,并且第一个字符必须为字母或下划线。
    (注:自定义的标识符不能与C语言规定的标识符相同,eg:int (错误) nit (没毛病))

    四、数据类型转换
    C语言标准建议:
    (1) 长->短
    低字节直接拷贝,高字节直接discards(抛弃,丢弃),也没办法要啦。

    (2) 短->长
    低字节直接拷贝,那么高字节呢?
    如果短的是无符号的,那么高字节全部补0;
    如果短的是有符号的,那么高字节全部符号位。

    优先级: 在含有多个运算符的表达式中,先算哪个运算符的问题。

            单目运算符 > 算术运算符 > 关系运算符 > 逻辑运算符 > 条件运算符
            > 赋值运算符 > 逗号运算符
    
            (当选官,罗条幅,逗)
    

    把变量a的第5bit置1,其他bit位不变,代码该如何写?
    a = a | (1 << 5);

    一个bit位与0进行“按位异或 ^”,保留原值
    x ^ 0 == x
    一个bit位与1进行“按位异或 ^”,结果取反
    x ^ 1 == ~x

    (1) 有一个整型变量a,要使a的第5bit保留,其他位取反,
    代码该如何写?

                    a =     a ^  (~(1  << 5)) ;
    

    (2)如把变量a的第5bit位清掉,其他bit位不变,代码该怎么写?
    a = a & ~(1 << 5)

    (3) 我们在程序中,有时候,经常需要交换两个变量的值
    int a = 5, b = 6;

                使用中间变量t 
                    int t;
                    t = a;
                    a = b;
                    b = t;
    

    假设要求不使用中间变量呢? (两个数相互异或)
    a = 3 b = 4
    011
    100
    a = a ^ b => 111
    b = b ^ a => 011 3
    100
    111
    a = a ^ b => 100 4
    111
    011

    **(1) 有一个整型变量a,要使a的第4bit到第8bit变为0,其他位不变
        该如何操作?**
        ( &4~8位为0->5个1取反->0~4:按位左移4位——>a=a&~(0x1f<<4))
    
    
            a:          b31 b30.... b9 b8 b7 b6 b5 b4 b3 b2 b1 b0
                      &  1  1  ..... 1 0  0   0  0  0  1 1  1  1 
    
                            0x1f  =>   11111
                            0x1f << 4   0000000..00 11111 0000
                            ~(0x1f << 4) 111111..11 00000 1111
    
            a =     a & ~(0x1f << 4);
    
    
    **(2) 有一个整型变量a,我想取这个变量的第4bit到第8bit的值,该
        如何操作?**
        (去后&1:右移四位&5个1——>a = (a>>4)&0x1f)
    
    
            a:          b31 b30.... b9 b8 b7 b6 b5 b4 b3 b2 b1 b0
                a >> 4
                      xxxxx b31 b30.... b9 b8 b7 b6 b5 b4
                      00000000000000000000  1 1  1    1  1
    
    
                (a >> 4) & 0x1f  ;
    
    展开全文
  • C语言重难点复习课件

    2009-01-20 10:20:16
    ppt格式 归纳总结各C语言学习中的重难点
  • c语言重难点,方法

    2013-09-15 16:28:07
    个人觉得不错;计算机的思维来源于数学,但是又不等同于数学。数学的思维是抽象的,它是建立在公理、定义、定理以及独特的推导方式上的。例如高等数学的基础是连续,推导方式是从现有条件出发,根据定义或定理,经过...
  • 2.C语言重难点罗列

    千次阅读 2017-10-15 21:46:59
    C语言难点罗列 运算符:自增,自减运算符 进制:各种进制转换,原码,反码,补码 数组:一维数组,二维数组,多维数组 循环:多重循环的嵌套,排序,查找 函数:递归函数,递归调用 指针:一级指针,多级指针,...

    C语言中难点罗列

    1. 运算符:自增,自减运算符
    2. 进制:各种进制转换,原码,反码,补码
    3. 数组:一维数组,二维数组,多维数组
    4. 循环:多重循环的嵌套,排序,查找
    5. 函数:递归函数,递归调用
    6. 指针:一级指针,多级指针,指针和数组,函数,结构体之间的关系
    7. 内存管理:C语言的内存管理问题,内存泄漏,野指针
    8. 有参宏及条件编译
    9. 多文件开发:多文件编译,多文件开发

    要说的,进制转换,其实我接触16进制挺多的,比如说RFID破解的dump数据,都是16进制,要算校验位的话就需要反码,补码什么的,亦或,与或什么的。

    展开全文
  • 文章目录一:指针和数组名的关系(1)[]运算符(2)指针和数组名的关系二:const修饰指针问题三:指针数组和数组指针四:函数指针 一:指针和数组名的关系 (1)[]运算符 []运算符的作用:,编译器会这样处理a[i]==*...

    一:指针和数组名的关系

    (1)[]运算符

    []运算符的作用:,编译器会这样处理a[i]==*(a+i)

    在这里插入图片描述

    (2)指针和数组名的关系

    数组名是指针常量,普通指针是指针变量

    在这里插入图片描述
    所以如果执行int* const p=a,表示将指针修饰为常量,因此此时的p和a就基本一致了,也是不允许修改的
    在这里插入图片描述

    二:const修饰指针问题

    简记:const放在谁后面就修饰谁

    1:const int iint const i等价,表示i的内容不可被修改

    2:const int* iint const* i等价

    首先i是指针,const修饰了int,表示指针可以变化,但是指针指向的内容不能被修改
    在这里插入图片描述
    3:int* const i

    const修饰的是指针,指针不可变,但是指向内容可以修改
    在这里插入图片描述
    4: const int* const i = &a;

    这个就是上面的综合情况,指针不能修改,指向的内容也不能修改
    在这里插入图片描述

    三:指针数组和数组指针

    如果没有()就是指针数组,如果有()就是数组指针

    在这里插入图片描述

    在这里插入图片描述

    • 所谓指针数组,就是存放指针的数组,它的里面存放的全部是指针
    • 数组指针,其主语就是指针,数组指针也就是指向数组

    四:函数指针

    数组指针是指向数组的,函数指针就是指向函数的,也就是函数也是有自己的地址的

    在这里插入图片描述

    展开全文
  • 文章目录运算符优先级算数运算符关系运算符逻辑运算符位运算符(点击)赋值运算符其他 运算符优先级 算数运算符 关系运算符 逻辑运算符 位运算符(点击) 赋值运算符 其他
  • C语言重点复习回顾1不是新手教程 不是新手教程 而是最近自己重新复习而记录下的概念 1.+++i 先运算再赋值 2.i++ 先赋值在运算只作用于变量不能作用于常量或者表达式 3.逗号运算符(for语句) 单独使用可以把初始化...
  • C语言学习的重难点 写程序的三个境界: 照抄的境界,翻译的境界,创新的境界 1 伪代码: 描述C语言的编程范式 范式: 规范的一种表示 对于C的范式学会的话,C, C++ Java 都会了 2 运算符的自曾与自减 3 进制转换与...
  • C语言重难点:内存对齐和位段

    多人点赞 2021-05-06 16:38:54
    一:结构体内存对齐 (1)为什么要存在内存对齐 平台原因(移植原因): 不是所有的硬件平台都能访问任意地址上的任意数据的;某些平台只能在某些地址处取得某些特定类型的数据,否则抛出硬件异常。...
  • 一:printf (1)格式字符总结 int main() { int a = 10;//有符号十进制数 unsigned int b = -1;//无符号十进制数 double c = 3.1415926;... const char* str = "just a test!... printf("以八进制形式输出符号整数a=%...
  • 这篇文章主要是介绍一些在复习C语言的过程中笔者个人认为比较重点的地方,较好的掌握这些重点会使对C的运用更加得心应手。此外会包括一些细节、易错的地方。涉及的主要内容包括:变量的作用域和存储类别、函数、数组...
  • 1.使用JetBrains_Clion编译环境搭建入门指南 2.VisualStudio运行后一闪而过和scanf函数的4996报错问题 1.一闪而过 VS右边的解决方案,找到对应的项目后:属性–>...scanf原本书C语言标准输入函数,
  • ------Java培训、Android培训、iOS培训、.Net培训、期待与您交流...一、C语言学习中的重难点 1)运算符 :自增、自减; 2)进制:各种进制转换、原码、反码、补码; 3)数组:一维数组、二维数组、多维数组; ...
  • 文章目录一:大端和小端二:经典问题 一:大端和小端 大端(存储)模式,是指数据的低位保存在内存的高地址中,而数据的高位,保存在内存的低地中; 小端(存储)模式,是指数据的低位保存在内存的低地址中,而数据...
  • C语言核心重难点精讲

    2019-09-29 10:30:45
    很多人都学过C语言,但却很少有人敢说把C语言学明白了。 C语言很难学,因为重点也是难点; C语言也很容易学,只要突破重难点... 本课程主要围绕C语言重难点进行讲解,让学员从内存角度去理解指针,掌握指针的核心用法。
  • C语言核心重难点

    2021-06-01 10:43:57
    1、基本数据类型(包括字符串)、结构体类型 2、常量、变量 3、数组、指针 4、函数、函数指针 5、内存管理 6、位操作
  • C语言重难点知识

    2021-01-07 16:47:01
    #define 理解:"define" 关键词,只是“替换”功能;本身不附带“计算规则”属性,因此,执行替换功能后,需要考虑所在环境的计算规则,整句代码有效性才算完整(*)。 #define用法(*)例子: ...
  • C语言基础知识重难点总结,帮您掌握c语言的核心部分
  • C语言核心重难点精讲 曾先后在电信、金融领域做后端开发多年,在linux平台...
  • 讲述C语言二级中的难点知识.方便你更快掌握C语言的内涵!

空空如也

空空如也

1 2 3 4 5 ... 9
收藏数 169
精华内容 67
关键字:

c语言重难点

c语言 订阅