2019年9月

虚拟空间解决了什么问题?

程序在编译时,每个变量所在的内存地址就已经确认下来。而在程序运行时,如果物理内存中的这两个地址被其他程序占用了怎么办?所以出现了虚拟地址的概念,使得程序在运行时,都使用相同的'虚拟地址',这些虚拟地址在操作系统的控制下映射到实际的物理地址。
这样做的好处有:

  • 使不同程序的地址空间相互隔离
  • 提高内存使用效率

打开文件的方式

打开方式说明
r以只读方式打开文件,只允许读取,不允许写入。该文件必须存在。
r+以读/写方式打开文件,允许读取和写入。该文件必须存在。
rb+以读/写方式打开一个二进制文件,允许读/写数据。
rt+以读/写方式打开一个文本文件,允许读和写。
w以只写方式打开文件,若文件存在则长度清为0,即该文件内容消失,若不存在则创建该文件。
w+以读/写方式打开文件,若文件存在则文件长度清为零,即该文件内容会消失。若文件不存在则建立该文件。
a以追加的方式打开只写文件。若文件不存在,则会建立该文件,如果文件存在,写入的数据会被加到文件尾,即文件原先的内容会被保留(EOF符保留)。
a+以追加方式打开可读/写的文件。若文件不存在,则会建立该文件,如果文件存在,则写入的数据会被加到文件尾后,即文件原先的内容会被保留(原来的EOF符 不保留)。
wb以只写方式打开或新建一个二进制文件,只允许写数据。
wb+以读/写方式打开或建立一个二进制文件,允许读和写。
wt+以读/写方式打开或建立一个文本文件,允许读写。
at+以读/写方式打开一个文本文件,允许读或在文本末追加数据。
ab+以读/写方式打开一个二进制文件,允许读或在文件末追加数据。

记忆窍门:

  • 文件打开方式由r、w、a、t、b、+ 六个字符拼成,各字符的含义是:

r(read):读
w(write):写
a(append):追加
t(text):文本文件,可省略不写
b(banary):二进制文件
+:读和写

  • 如果没有“b”字符,文件以文本方式打开。
  • 凡用“r”打开一个文件时,该文件必须已经存在。
  • 在打开一个文件时,如果出错,fopen将返回一个空指针值NULL。在程序中可以用这一信息来判别是否完成打开文件的工作,并作相应的处理。因此常用以下程序段打开文件:
if( (fp=fopen("D:\\demo.txt","rb") == NULL ){
    printf("Error on open D:\\demo.txt file!");
    getch();
    exit(1);
}
  • 把一个文本文件读入内存时,要将ASCII码转换成二进制码,而把文件以文本方式写入磁盘时,也要把二进制码转换成ASCII码,因此文本文件的读写要花费较多的转换时间。对二进制文件的读写不存在这种转换。
  • 标准输入文件 stdin(键盘)、标准输出文件 stdout(显示器)、标准错误文件 stderr(显示器)是由系统打开的,可直接使用。

六种位运算符

运算符&|^~<<>>
说明按位与按位或按位异或取反左移右移

按位与 &

一个比特(Bit)位只有 0 和 1 两个取值,只有参与&运算的两个位都为 1 时,结果才为 1,否则为 0。例如1&1为 1,0&0为 0,1&0也为 0,这和逻辑运算符&&非常类似。

按位或 |

参与|运算的两个二进制位有一个为 1 时,结果就为 1,两个都为 0 时结果才为 0。例如1|1为1,0|0为0,1|0为1,这和逻辑运算中的||非常类似。

按位异或 ^

参与^运算两个二进制位不同时,结果为 1,相同时结果为 0。例如0^1为1,0^0为0,1^1为0。

取反

取反运算符~为单目运算符,右结合性,作用是对参与运算的二进制位取反。例如~1为0,~0为1,这和逻辑运算中的!非常类似。

左移 <<

左移运算符<<用来把操作数的各个二进制位全部左移若干位,高位丢弃,低位补0。

右移运算 >>

右移运算符>>用来把操作数的各个二进制位全部右移若干位,低位丢弃,高位补 0 或 1。如果数据的最高位是 0,那么就补 0;如果最高位是 1,那么就补 1。

理解指针的关键

C语言标准规定,对于一个符号的定义,编译器总是从它的名字开始读取,然后按照优先级顺序依次解析。对,从名字开始,不是从开头也不是从末尾。

知道了这个关键,再知道一些运算符的优先级,它们的优先级从高到低依次是::

  • 定义中被括号( )括起来的那部分。
  • 后缀操作符:括号( )表示这是一个函数,方括号[ ]表示这是一个数组。
  • 前缀操作符:星号*表示“指向xxx的指针”。

举例子来说明:

#include <stdio.h>

int main(int argc, const char * argv[]){
    int *p1[6];
    /*
     从 p1 开始理解,它的左边是 *,右边是 [ ],[ ] 的优先级高于 *,所以编译器先解析p1[6],p1 首先是一个拥有 6 个元素的数组,然后再解析int *,它用来说明数组元素的类型。从整体上讲,p1 是一个拥有 6 个 int * 元素的数组,也即指针数组。
     **/
    int (*p3)[6];
    /*
     从 p3 开始理解,( ) 的优先级最高,编译器先解析(*p3),p3 首先是一个指针,剩下的int [6]是 p3 指向的数据的类型,它是一个拥有 6 个元素的一维数组。从整体上讲,p3 是一个指向拥有 6 个 int 元素数组的指针,也即二维数组指针。
     这里说明一下:为了能够通过指针来遍历数组元素,在定义数组指针时需要进行降维处理,例如三维数组指针实际指向的数据类型是二维数组,二维数组指针实际指向的数据类型是一维数组,一维数组指针实际指向的是一个基本类型;在表达式中,数组名也会进行同样的转换(下降一维)。
     **/
    int (*p4)(int, int);
    /*
     从 p4 开始理解,( ) 的优先级最高,编译器先解析(*p4),p4 首先是一个指针,它后边的 ( ) 说明 p4 指向的是一个函数,括号中的int, int是参数列表,开头的int用来说明函数的返回值类型。整体来看,p4 是一个指向原型为int func(int, int);的函数的指针。
     **/
    char *(* c[10])(int **p);
    /*
     这个定义有两个名字,分别是 c 和 p,乍看起来 p 是指针变量的名字,不过很遗憾这是错误的。如果 p 是指针变量名,c[10]这种写法就又定义了一个新的名字,这让人匪夷所思。
     以 c 作为变量的名字,先来看括号内部(* c[10])
     [ ] 的优先级高于 *,编译器先解析c[10],c 首先是一个数组,它前面的*表明每个数组元素都是一个指针,只是还不知道指向什么类型的数据。整体上来看,(* c[10])说明 c 是一个指针数组,只是指针指向的数据类型尚未确定。

     跳出括号,根据优先级规则(() 的优先级高于 *)应该先看右边(int **p)
     ( )说明是一个函数,int **p是函数参数。
     再看左边char * 是函数的返回值类型。
     从整体上看,我们可以将定义分成两部分:
     (* c[10])表明 c 是一个指针数组,char *(int **p);表明指针指向的数据类型,合起来就是:c 是一个拥有 10 个元素的指针数组,每个指针指向一个原型为char *func(int **p);的函数。
     **/
    int (*(*(*pfunc)(int *))[5])(int *);
    /*
     从 pfunc 开始理解,先看括号内部(*pfunc),pfunc 是一个指针。
     跳出括号,看它的两边,*(int *),根据优先级规则应该先看右边的(int *),它表明这是一个函数,int *是参数列表。再看左边的*,它表明函数的返回值是一个指针,只是指针指向的数据类型尚未确定。
     将上面的两部分合成一个整体,(*(*pfunc)(int *)),它表明 pfunc 是一个指向函数的指针,现在函数的参数列表确定了,也知道返回值是一个指针了(只是不知道它指向什么类型的数据)。
     再向外跳一层括号,[5],[ ] 的优先级高于 *,先看右边,[5] 表示这是一个数组,再看左边,* 表示数组的每个元素都是指针。也就是说,* [5] 是一个指针数组,函数返回的指针就指向这样一个数组。
     那么,指针数组中的指针又指向什么类型的数据呢?再向外跳一层括号,int  (int *);右边,它是一个函数,再看左边,它是函数的返回值类型。也就是说,指针数组中的指针指向原型为int func(int *);的函数。
     将上面的三部分合起来就是:pfunc 是一个函数指针(蓝色部分),该函数的返回值是一个指针,它指向一个指针数组(红色部分),指针数组中的指针指向原型为int func(int *);的函数(橘黄色部分)。
     
     **/
    return 0;
}

常见指针变量的定义

定 义含 义
int *p;p 可以指向 int 类型的数据,也可以指向类似 int arr[n] 的数组。
int **p;p 为二级指针,指向 int * 类型的数据。
int *p[n];p 为指针数组。[ ] 的优先级高于 ,所以应该理解为 int (p[n]);
int (*p)[n];p 为二维数组指针。
int *p();p 是一个函数,它的返回值类型为 int *。
int (*p)();p 是一个函数指针,指向原型为 int func() 的函数。

#include <stdio.h>
int main(int argc, const char * argv[]){
    char *string0 = "COSC1283/1284";
    char *string1 = "Programming";
    char *string2 = "Techniques";
    char *string3 = "is";
    char *string4 = "great fun";
   
    char *lines[5];//定义了一个指针数组,它的每个元素的类型都是char *
    /*
     在表达式中使用 lines 时,它会转换为一个类型为char **的指针,这样*lines就表示一个指向字符的指针,而**lines表示一个具体的字符,这一点很重要!
     **/
    lines[0] = string0;
    lines[1] = string1;
    lines[2] = string2;
    lines[3] = string3;
    lines[4] = string4;
    /*
     指针是可以进行运算的,lines 表示数组的首地址(第0个元素的地址),lines+0、lines+1、lines+2 ... 分别表示第0、1、2 ...个元素的地址,*(lines+0)或lines[0]、*(lines+1)或lines[1]、*(lines+2)或lines[2] ... 分别是字符串 string0, string1, string2 ... 的首地址。即:
     *lines == *(lines+0) == lines[0] == string0
     *(lines+1) == lines[1] == string1
     *(lines+2) == lines[2] == string2
     注意:lines 是二级指针,*(lines+i) 是一级指针,**(lines+i) 才是具体的字符。
     **/
    char *str1 = lines[1];//lines[1]:它是一个指针,指向字符串string1,即 string1 的首地址。
    char *str2 = *(lines + 3);//*(lines + 3):lines + 3 为数组中第 3 个元素的地址,*(lines + 3) 为第 3 个元素的值,它是一个指针,指向字符串 string3。
    char c1 = *(*(lines + 4) + 6);//*(*(lines + 4) + 6):*(lines + 4) + 6 == lines[4] + 6 == string4 + 6,表示字符串 string4 中第 6 个字符的地址,即 f 的地址,所以 *(*(lines + 4) + 6) 就表示字符 f。
    char c2 = (*lines + 5)[5];//(*lines + 5)[5]:*lines + 5 为字符串 string0 中第 5 个字符的地址,即 2 的地址,(*lines + 5)[5]等价于*(*lines + 5 + 5),表示第10个字符,即 2。
    char c3 = *lines[0] + 2;//*lines[0] + 2:lines[0] 为字符串 string0 中第 0 个字符的地址,即 C 的地址;*lines[0] 也就表示第 0 个字符,即字符 C。字符与整数运算,首先转换为该字符对应的 ASCII 码,然后再运算,所以 *lines[0] + 2 = 67 + 2 = 69,69 对应的字符为 E。
    printf("str1 = %s\n", str1);
    printf("str2 = %s\n", str2);
    printf("  c1 = %c\n", c1);
    printf("  c2 = %c\n", c2);
    printf("  c3 = %c\n", c3);
    return 0;
}