按位运算

C语言有这些按位运算的运算符

  • &   按位的与
  • |    按位的或
  • ~  按位取反
  • ^   按位的异或
  • << 左移
  • >> 右移

按位与&

  • 如果x的第i位是1且y的第i位是1,那么(x&y)的第i位是1,否则的话(x&y)的第i位是0
  • 按位与常用于两种应用:
  • 让某一位或某些位为0
  • 取一个数中的一段

按位或|

  • 如果x的第i位是1或y的第i位是1,那么(x|y)的第i位是1,否则的话(x|y)的第i位是0
  • 按位或常用于两种应用:
  • 让某一位或某些位为1
  • 把两个数拼起来

按位取反~

  • 把1位变0,0位变1
  • 想要得到全部位为1的数:~0

逻辑运算VS按位运算

  • 对于逻辑运算,它只看到两个值:0和1
  • 可以认为逻辑运算相当于把所有非0值都变成1,然后做按位运算

按位异或

  • 如果x的第i位和y的第i位相等,那么(x^y)的第i位是0,否则的话(x^y)的第i位是1
  • 如果两个位相等,那么结果为0;不相等,结果为1
  • 对一个变量用同一个值异或两次,等于什么也没做

曾经面试金山WPS的时候有一道题问到:不使用额外的空间,交换两个整形数字。

有两种方法

方法一:算术方法

x = x + y;
y = x - y;
x = x - y;

方法二:异或方法

x = x^y;// 只能对int,char..
y = x^y;
x = x^y;

移位运算:左移<<

  • i << j
  • i中所有的位向左移动j个位置,而右边填入0
  • 所有小于int的类型,移位以int的方式来做,结果是int
  • x = x<<1 等价于 x = x*2
  • x = x<<n 在范围内等价于x = x*(2的n次方)

移位运算:右移>>

  • i >> j
  • i中所有的位向右移j位
  • 所有小于int的类型,移位以int的方式来做,结果是int
  • 对于unsigned的类型,左边填入0
  • 对于signed的类型,左边填入原来的最高位
  • x = x>>1 等价于 x = x/2
  • x = x>>n 等价于 x = x/(2的n次方)

no zuo no die

  • 移位的位数不要用负数,这是没有定义的行为

利用按位与和移位操作实现输出一个数的二进制:

#include<stdio.h>

int main(int argc,int *argv[])
{
    int number;
    scanf("%d",&number);
    unsigned int mask = 1;
    mask = mask << 31;
    while(mask)
    {
        if(number & mask)
        {
            printf("1");
        }
        else
        {
            printf("0");
        }
        mask = mask>>1;
    }
    return 0;
}

 

位段

把一个int的若干位组合成一个结构

如:

struct U0
{
    unsigned int leading : 3;
    unsigned int FLAG1:1;
    unsigned int FLAG2:1;
    int trailing :27;
};

 

  • 这样就可以直接用位段的成员名称来访问,以移位、与、或更方便
  • 编译器会安排其中的位的排列,不具有可移植性
  • 当所需的位超过一个int时会采用多个int

 

文件输入输出

  • 用>和<做重定向
  • 使用FILE

FILE

  • FILE *fopen(const char * restrict path,const char * restrict mode);
  • int fclose(FILE *stream);
  • fscanf(FILE* , …)
  • fprintf(FILE* , …)

打开文件的标准代码

FILE *fp = fopen("file","r");//文件名,只读模式
if(fp){
   fscanf(fp,...);
   fclose(fp);
  }else{
   ...
}

 

例子:(打开当前.c源代码目录下的1.txt文件中的数字并输出到终端。)

#include<stdio.h>

int main(int argc,int *argv[])
{
    FILE *fp = fopen("1.txt","r");
    if(fp)
    {
        int num;
        fscanf(fp,"%d",&num);
        printf("%d\n",num);
        fclose(fp);
    }
    else
    {
        printf("无法打开文件\n");
    }
    return 0;
}

 

fopen

第一个字符串参数为文件名,第二个字符串参数为模式

  • r   打开只读
  • r+   打开读写,从文件头开始
  • w   打开只写。如果不存在则新建,如果存在则清空
  • w+   打开读写。如果不存在则新建,如果存在则清空
  • a   打开追加。如果不存在则新建,如果存在则从文件尾开始
  • 在上述后面可以加x,代表只新建,如果文件已存在则不能打开

二进制文件

  • 其实所有的文件最终都是二进制的
  • 文本文件无非是用最简单的方式可以读写的文件
  • 而二进制文件是需要专门的程序来读写的文件
  • 文本文件的输入输出是格式化,可能经过转码

文本文件VS二进制文件

  • 文本的优势是方便人类读写,而且跨平台
  • 文本的缺点是程序输入输出需要经过格式化,开销大
  • 二进制的缺点是人类读写困难,可能因为int的大小不一致,大小端等问题导致不跨平台
  • 二进制的优点是程序读写快

程序为什么要文件

  • 配置:Unix用文本,Windows用注册表
  • 数据:稍微有点量的数据都放数据库了
  • 媒体:通过二进制,现实是程序通过第三方库来读写文件,很少直接读写二进制文件了

printf()

格式:%[flags][width][.prec][hlL]type

flag

  • –   左对齐
  • +   在前面放+或者-
  • (space) 正数留空
  • 0   0填充

width和pres

  • number   最小字符数
  • *   下一个参数是字符数
  • .number   小数点后面的位数
  • .*   下一个参数是小数点后的位数

hlL

  • hh   单个字节
  • h   short
  • l   long
  • ll   long long
  • L   long double

type

  • i或d   int
  • u   unsigned int
  • o   八进制
  • x   十六进制
  • X   大写十六进制
  • f或F   float
  • e或E   指数
  • g或G   float
  • a或A   十六进制浮点
  • c   char
  • s   字符串
  • p   指针
  • n   读入/写出的个数

scanf()

格式:%[flag]type

flag

  • *   跳过
  • 数字   最大字符数
  • hh   char
  • h   short
  • l   long,double
  • ll   long long
  • L   long double

type

  • d   int
  • i   整数,可能为十六进制或者八进制
  • u   unsigned int
  • o   八进制
  • x   十六进制
  • a,e,f,g   float
  • c   char
  • s   字符串
  • […]   所允许的字符
  • p   指针

printf()和scanf()的返回值

  • 读入的项目数
  • 输出的字符数
  • 在要求严格的程序中,应该判断每次调用scanf()或printf()的返回值,从而了解程序运行中是否存在问题

在程序的世界里,我们往往在做一些分而治之的事情。

一开始我们写的所有程序都在main()里面,然后写着写着呢我们会觉得main()太大了,于是我们会分出一些函数出来,所以我们有了函数,把一个又一个功能从main()中剥离出来放在函数里面。

后来我们会发现一个.c文件里函数越来越多,于是我们开始把函数从一个.c文件里拿出来放到很多个.c文件中去,可是当我们把函数从一个.c文件里拿出来放到很多个.c文件中去之后,又该怎么组合成一个有效的程序呢?

从编译器的角度来看,一个.c文件是一个编译单元,编译器每次编译只处理一个编译单元,编译完之后形成.o文件(目标代码文件),然后由链接器去链接起来。

头文件

把函数原型放到一个头文件(以.h结尾)中,在需要调用这个函数的源代码文件(.c文件)中#include这个头文件,就能让编译器在编译的时候知道函数的原型,否则程序有可能编译成功,但参数类型是由编译器推测出来的,导致出现异常的情况。

#include

  • #include是一个编译预处理指令,和宏一样,在编译之前就处理了
  • 它把那个文件的全部文本内容原封不动地插入到它所在的地方
  • 所以也不是一定要在.c文件的最前面用#include

“”还是<>

  • #include有两种形式来指出要插入的文件
  • “”要求编译器首先在当前目录(.c文件所在的目录)寻找这个文件,如果没有,到编译器指定的目录去找
  • <>让编译器只在指定的目录去找
  • 编译器知道自己的标准库头文件在哪里
  • 环境变量和编译器命令行参数也可以指定寻找头文件的目录

#include的误区

  • #include不是用来引入库的
  • stdio.h里只有printf()的原型,printf()的代码在另外的地方,某个.lib(Windows)或.a(Unix)中
  • 现在的C语言编译器默认会引入所有的标准库
  • #include<stdio.h>只是为了让编译器知道printf()函数的原型,保证你调用时给出的参数值是正确的类型

不对外公开的函数

  • 在函数前面加上static就使得它成为只能在所在的编译单元中(当前.c文件中)被使用的函数
  • 在全局变量前面加上static就使得它成为只能在所有的编译单元中被使用的全局变量

变量的声明

  • int i;//变量的定义
  • extern int i;//变量的声明

声明和定义

  • 声明是不产生代码的东西
  • 定义是产生代码的东西

标准头文件结构

  • 运用条件编译和宏,保证这个头文件在一个编译单元中只会被#include一次
  • #pragma once也能起到相同的作用,但是不是所有的编译器都支持

编译预处理指令

  • #开头的是编译预处理指令
  • 它们不是C语言的成分,但是C语言离不开它们
  • #define用来定义一个宏
  • #include用来包含一个头文件

C语言程序在编译之前会进行编译预处理,在编译预处理过程中会把所有的#define定义的宏进行替换。

C语言编译过程中会产生一些临时文件,在GCC编译器编译过程中如下:

main.c->main.i->main.s->main.o->a.out

  1. 由源代码main.c进行编译预处理得到main.i
  2. 由编译预处理后的代码文件main.i进行编译得到汇编代码文件main.s
  3. 汇编代码文件main.s做汇编得到目标代码文件main.o
  4. 目标代码文件main.o进行链接形成可执行文件a.out

#define

  • #define <名字><值>
  • 注意没有结尾的分号,因为不是C的语句
  • 名字必须是一个单词,值可以是各种东西
  • 在C语言的编译器开始编译之前,编译预处理程序会把程序中的名字换成对应的值,仅仅是做的完全的文本替换
  • 使用gcc –save-temps可以保存编译过程中的临时文件

  • 如果一个宏的值中有其他的宏的名字,也是会被替换的
  • 如果一个宏的值超过一行,最后一行之前的行末要加\
  • 宏的值后面出现的注释不会被当作宏的值的一部分

没有值的宏

  • #define _DEBUG
  • 这类宏是用于条件编译的,后面有其他的编译预处理指令来检查这个宏是否已经被定义过了
  • 在金山WPS实习开发WPS for Mac的时候遇到过,只有在Mac环境下编译才执行的一段代码

预定义的宏

  • __func__ //函数的函数名
  • __LINE__ //源代码文件的行号
  • __FILE__ //源代码文件的文件名
  • __DATE__ //编译时的日期
  • __TIME__ //编译时的时间
  • __STDC__ //判断该文件是不是标准C程序,当要求程序严格遵循ANSIC标准时该标识符被赋值为1
#include<stdio.h>

int dxf(void);

int main(int argc,int *argv[])
{
    dxf();
    return 0;
}

int dxf(void)
{
    printf("%s:%d\n",__FILE__,__LINE__);//输出源代码文件名和目前的行号
    printf("%s\n",__func__);//输出函数名
    printf("%s,%s\n",__DATE__,__TIME__);//输出编译的日期和时间
}

 

运行结果如下:

带参数的宏和像函数的宏

  • #define cube(x) ((x)*(x)*(x))
  • 宏可以带参数

由于预编译过程中#define仅仅是简单的文本替换,所以容易出现运算优先级问题,因此在定义带参数的宏的时候应该遵循一些原则

带参数的宏的原则

  • 一切都要括号(整个值要括号,参数出现的每个地方都要括号)
  • #define RADTODEG(x) ((x)*57.29578)

带参数的宏

  • 可以带多个参数,如#define MIN(a,b) ((a)>(b)?(b):(a))
  • 也可以组合嵌套使用其他宏
  • 在大型程序的代码中使用非常普遍
  • 部分宏会被inline函数替代

宏的缺点

  • 宏的参数没有类型检查,处理不了特殊的输入,而内联函数inline的引入正是为了解决这个问题

宏展开的灵活运用

在Arduino的Ethernet库的w5100.cpp里有这样的函数调用:

writeTMSR(0x55);

但是遍寻整个.cpp和对应的w5100.h也找不到这个writeTMSR()函数,即使把所有的源代码目录拿来搜索一遍都没有。但是,编译显然是通过了的,那么,这个函数在哪里呢?

在w5100.h,我们发现了这样的代码:

#define __GP_REGISTER8(name, address)             \
  static inline void write##name(uint8_t _data) { \
    write(address, _data);                        \
  }                                               \
  static inline uint8_t read##name() {            \
    return read(address);                         \
  }

于是,在w5100.h里接下去的代码:

__GP_REGISTER8 (TMSR,   0x001B);    // Transmit memory size

在编译预处理后,就会被展开成为:

static inline void writeTMSR(uint8_t _data) {
    write(0x001B, _data);            
}
static inline uint8_t readTMSR() {
    return read(0x001B);             
}

其中##是一种分隔连接方式,它的作用是先分隔,然后进行强制连接。

全局变量

  • 定义在函数外面的变量是全局变量
  • 全局变量具有全局的生存期和作用域,它们与任何函数都无关,在任何函数内部都可以使用它们

例子:

#include<stdio.h>

int f(void);
int gAll = 12;

int main(int argc,int *argv[])
{
    printf("in %s gAll=%d\n",__func__,gAll);
    f();
    printf("in %s gAll=%d\n",__func__,gAll);
    return 0;
}

int f(void)
{
    printf("in %s gAll=%d\n",__func__,gAll);
    gAll = gAll + 2;
    printf("in %s gAll=%d\n",__func__,gAll);
    return gAll;
}

其中__func__为当前函数的名字。

该代码的输出

说明全局变量和任何函数都没有关系。

全局变量初始化

  • 没有做初始化的全局变量会得到0值
  • 没有做初始化的指针会得到NULL值
  • 只能用编译时刻已知的值来初始化全局变量
  • 它们的初始化发生在main函数之前

被隐藏的全局变量

  • 如果函数内部存在与全局变量同名的变量,则全局变量被隐藏

静态本地变量

  • 在本地变量定义时加上static修饰符就成为静态本地变量
  • 当函数离开的时候,静态本地变量会继续存在并保持其值(生存期全局,作用域本地)
  • 静态本地变量的初始化只会在第一次进入这个函数时做,以后进入函数时会保持上次离开时的值
  • 静态本地变量实际上是特殊的全局变量,它们位于相同的内存区域

例子:

#include<stdio.h>

int f(void);

int main(int argc,int *argv[])
{
    f();
    f();
    f();
    return 0;
}

int f(void)
{
    static int all = 1;
    printf("in %s all=%d\n",__func__,all);
    all = all + 2;
    printf("in %s all=%d\n",__func__,all);
    return all;
}

 

运行结果如下:

 

返回指针的函数

  • 返回本地变量的地址是危险的
  • 返回全局变量或静态本地变量的地址是安全的
  • 返回在函数内malloc的内存是安全的,但是容易造成问题
  • 最好的做法是返回传入的指针

Tips

  • 不要使用全局变量来在函数间传递参数和结果
  • 尽量避免使用全局变量
  • 使用全局变量和静态本地变量的函数是线程不安全的

可变数组实现

怎么样实现一个大小可变的数组?(只考虑输入正常的情况,暂不考虑越界等问题)

  • 数组可以增长
  • 能够方便的得到数组的大小
  • 能够访问数组中的单元

需要实现的函数:

  • Array array_create(int init_size);//创建一个初始大小为init_size的int类型数组
  • void array_free(Array *a);//释放数组
  • int array_size(const Array *a);//获得数组此时的大小
  • int array_get(const Array *a , int index);//访问数组的第index个单元
  • void array_set(Array *a , int index , int value);//设置数组的第index个单元
  • void array_inflate(Array *a,int more_size);//给数组增加more_size个单元

实现代码如下:

#include<stdio.h>
#include<stdlib.h>
#include<string.h>

 typedef struct{
      int *array;
      int size;
 }Array;

Array array_create(int init_size);//创建一个初始大小为init_size的int类型数组
void array_free(Array *a);//释放数组
int array_size(const Array *a);//获得数组此时的大小
int array_get(const Array *a , int index);//访问数组的第index个单元
void array_set(Array *a , int index , int value);//设置数组的第index个单元
void array_inflate(Array *a,int more_size);//给数组增加more_size个单元

Array array_create(int init_size)//创建一个初始大小为init_size的int类型数组
{
    Array a;
    a.size = init_size;
    a.array = (int*)malloc(a.size*sizeof(int));
    return a;
}

void array_free(Array *a)//释放数组
{
     free(a->array);
     a->array = NULL;
     a->size = 0;
}

int array_size(const Array *a)//获得数组此时的大小
{
     return a->size;
}

int array_get(Array *a,int index)//访问数组的第index个单元
{
     return a->array[index];

}

void array_set(Array *a,int index ,int value)//设置数组的第index个单元
{
     if(index >= a->size){
        array_inflate(a,(index/20+1)*20 - a->size);
     }
      a->array[index] = value;
}

void array_inflate(Array *a,int more_size)//给数组增加more_size个单元
{
    int *p = (int*)malloc((a->size+more_size)*sizeof(int));
     for(int i = 0; i<a->size ;i++){
        p[i] = a->array[i];
     }
    free(a->array);
    a->size =a->size+more_size;
    a->array = p;
}

 int main(){
      Array a = array_create(1);
      array_set(&a,0,1);
      printf("array_get(&a,0)=%d\n",array_get(&a,0));
      printf("array_size(&a)=%d\n",array_size(&a));
      array_set(&a,1,10);
      printf("array_size(&a)=%d\n",array_size(&a));
      printf("array_get(&a,0)=%d\n",array_get(&a,0));
      printf("array_get(&a,1)=%d\n",array_get(&a,1));
 }