Archive for 2010 年 10 月

内核同步方法-锁机制

21 10 月, 2010

本文将为你介绍内核同步算法中的自旋锁和信号量。在这之前,先了解一些概念。

执行线程:thread of execution,指任何正在执行的代码实例,可能是一个正在内核线程,一个中断处理程序等。有时候会将执行线程简称为线程。

临界区:critical region,即访问和操作共享数据的代码段。

多个执行线程并发访问同一资源通常是不安全的,通常使用自旋锁和信号量来实现对临界区互斥的访问。

自旋锁

自旋锁(spin lock)是一个对临界资源进行互斥访问的典型手段。自旋锁至多只能被一个执行线程持有。当一个执行线程想要获得一个已被使用的自旋锁时,该线程就会一直进行忙等待直至该锁被释放,就如同“自旋”所表达的意思那样:在原地打转。

我们也可以这么理解自旋锁:它如同一把门锁,而临界区就如同门后面的房间。当一个线程A进入房间后,它会关闭房门,使得其他线程不得进入。此时如果其他某个进程B需要进入房间,那么只能在门外“打转”。当A进程打开们后,进程B才能进入房间。

自旋锁的使用

1.定义初始化自旋锁

使用下面的语句就可以先定一个自旋锁变量,再对其进行初始化:

spinlock_t lock;
spin_lock_init(&lock);

也可以这样初始化一个自旋锁:

spinlock_t lock=SPIN_LOCK_UNLOCKED;

2.获得自旋锁

void spin_lock(spinlock_t*);
int spin_trylock(spinlock_t*);

使用spin_lock(&lock)这样的语句来获得自旋锁。如果一个线程可以获得自旋锁,它将马上返回;否则,它将自旋至自旋锁的保持者释放锁。

另外可以使用spin_trylock(&lock)来试图获得自旋锁。如果一个线程可以立即获得自旋锁,则返回真;否则,返回假,此时它并不自旋。

3.释放自旋锁

void spin_unlock(spinlock_t*);

使用spin_unlock(&lock)来释放一个已持有的自旋锁。注意这个函数必须和spin_lock或spin_trylock函数配套使用。

关于自旋锁的说明

1.保护数据。我们使用锁的目的是保护临界区的数据而不是临界区的代码。
2.在使用自旋锁时候,必须关闭本地中断,否则可能出现双重请求的死锁。比如,中断处理程序打断正持有自旋锁的内核代码,如果这个中断处理程序又需要这个自旋锁,那么这个中断处理程序就会自旋等待自旋锁被释放;但是这个锁的持有者此刻被中断打断,因此不可能在中断完毕之前释放锁。此时就出现了死锁。
3.自旋锁是忙等锁。正如同前面所说的那样,当其他线程持有自旋锁时,如果另有线程想获得该锁,那么就只能循环的等待。这样忙的功能对CPU来说是极大的浪费。因此只有当由自旋锁保护的临界区执行时间很短时,使用自旋锁才比较合理。
4.自旋锁不能递归使用。这一点也很好理解,如果当前持有锁的线程又需要再持有该锁,那么它必须自旋,等待锁被释放;但是这个锁本身又被它自己持有,因此这个线程永远无法继续向前推进。

信号量

信号量(semaphore)是保护临界区的一种常用方法。它的功能与自旋锁相同,只能在得到信号量的进程才能执行临界区的代码。但是和自旋锁不同的是,一个进程不能获得信号量时,它会进入睡眠状态而不是自旋。

利用上述自旋锁的门和锁的例子,我们可以这样解释信号量。我们将信号量比作钥匙。进程A想要进入房间,就必要持有一把钥匙。当钥匙被使用完之后,如果又有进程B想进房间,那么这个进程在等待其他进程从房间出来给它钥匙的同时会打盹。当房间里的某个进程出来时会摇醒这个睡觉的进程B。

信号量的使用

0.数据结构

  16struct semaphore {
  17        spinlock_t              lock;
  18        unsigned int            count;
  19        struct list_head        wait_list;
  20};

count:初始化信号量时所设置的信号量值。
wait_list:等待队列,该队列中即为等待信号量的进程。
lock:自旋锁变量

1.定义初始化信号量

使用下面的代码可以定义并初始化信号量sem:

struct semaphore sem;
sem_init(&sem,val);

其中val即为信号量的初始值。

如果我们想使用互斥信号量,则使用下面的函数:

init_MUTEX(&sem);

这个函数会将sem的值初始为1,即等同于sem_init(&sem,1);

如果想将互斥信号量的初值设为0,则可以直接使用下面的函数:

init_MUTEX_LOCKED(&sem);

除上面的方法,可以使用下面的两个宏定义并初始化信号量:

DECLARE_MUTEX(name);

DECLARE_MUTEX_LOCKED(name);

其中name为变量名。

2.获得信号量

down(&sem);

进程使用该函数时,如果信号量值此时为0,则该进车会进入睡眠状态,因此该函数不能用于中断上下文中。

down_interruptibale(&sem);

该函数与down函数功能类似,只不过使用down而睡眠的进程不能被信号所打断,而使用down_interruptibale的函数则可以被信号打断。

如果想要在中断上下文使用信号量,则可以使用下面的函数:

dwon_try(&sem);

使用该函数时,如果进程可以获得信号量,则返回0;否则返回非0值,不会导致睡眠。

3.释放信号量

up(&sem);

该函数会释放信号量,如果此时等待队列中有进程,则唤醒一个。

信号量的同步

信号量除了使进程互斥的访问临界区外,还可以用于进程间的同步。比如,当B进程执行完代码区C后,A进程才会执行代码段D,两者之间有一定的执行顺序。

内核同步方法-原子操作

20 10 月, 2010

Latest Update:2010/10/23

原子操作

原子操作用于执行轻量级、仅执行一次的操作,比如修改计数器,某些条件下的增加值或设置位等。原子操作指的是指令以原子的方式执行。之所以用原子来修饰这种操作方式是因为它们均不可再分。也就是说,原子操作要么一次性执行完毕,要么就不执行,这些操作的执行过程是不可被打断的。原子操作的具体实现取决于体系架构,以下代码如无特别声明,均来自linux/arch/x86/include/asm/atomic.h中

内核中提供了两组原子操作的接口:原子整形操作和原子位操作。前者是一组对整形数据的操作,后者则是针对单独的位操作。通过上面的叙述我们可以知道,这写操作接口完成的动作都是原子的。

原子整形操作

0.数据结构

在linux/include/linux/types.h中有如下定义:

 190typedef struct {
 191        int counter;
 192} atomic_t;

原子类型内部只有一个整型的成员counter。

1.初始化/设置原子变量的值

  15#define ATOMIC_INIT(i)  { (i) }

  35static inline void atomic_set(atomic_t *v, int i)
  36{
  37        v->counter = i;
  38}

初始化宏的源码很明显的说明了如何初始化一个原子变量。我们在定义一个原子变量时可以这样的使用它:

  atomic_t v=ATOMIC_INIT(0);

atomic_set函数可以原子的设置一个变量的值。

2.获取原子变量的值

  23static inline int atomic_read(const atomic_t *v)
  24{
  25        return (*(volatile int *)&(v)->counter);
  26}

返回原子型变量v中的counter值。关键字volatile保证&(v->counter)的值固定不变,以确保这个函数每次读入的都是原始地址中的值。

3.原子变量的加与减

   47static inline void atomic_add(int i, atomic_t *v)
  48{
  49        asm volatile(LOCK_PREFIX "addl %1,%0"
  50                     : "+m" (v->counter)
  51                     : "ir" (i));
  52}

  61static inline void atomic_sub(int i, atomic_t *v)
  62{
  63        asm volatile(LOCK_PREFIX "subl %1,%0"
  64                     : "+m" (v->counter)
  65                     : "ir" (i));
  66}

加减操作中使用了内联汇编语句。

linux中的汇编语句都采用AT&T指令格式。带有C表达式的内联汇编格式为:__asm__ __volatile__(“InstructionList” :Output :Input :Clobber/Modify);其中asm(或__asm__)用来声明一个内联汇编语句;关键字volatile是可选的,选择此关键字意味着向编译器声明“不要动我所写的指令,我需要原封不动的保留每一条指令”,否则,编译器可能会对指令进行优化。InstructionList即我们所加的汇编语句。指令后面的3个部分(Output, Input,Clobber/Modify)是可选的,分别指输出操作数,输入操作数,修改位。

下面我们针对上述加减操作对上述内联汇编语句做简单的解释。

在加函数中,对变量加操作的原子型表现在使用单条的汇编语句完成。指令中的%1,%0分别代表输入操作数和输出操作数,它们用来标示变量。内联汇编语句中的操作数从0开始进行编号,并且优先为输出操作数编号,然后再依次为输入操作数编号。在指令后的输出部分,“+m”中的+表示输出变量是可读可写的,m表示输出操作数存储于内存单元中,而不是在寄存器中。在输入部分,“ir”中的i表示输入操作数是一个直接操作数,r表示存储与寄存器中。输入部分和输出部分中的括号内的C语言格式的变量分别对应汇编语句中的输入操作数和输出操作数。

汇编语句addl %1,%0就是将i加至v->counter上,这个加的过程是原子的。

了解了加操作,那么减操作也就不难理解了,这里不再赘述。

4.原子变量的自加自减

  93static inline void atomic_inc(atomic_t *v)
  94{
  95        asm volatile(LOCK_PREFIX "incl %0"
  96                     : "+m" (v->counter));
  97}

 105static inline void atomic_dec(atomic_t *v)
 106{
 107        asm volatile(LOCK_PREFIX "decl %0"
 108                     : "+m" (v->counter));
 109}

从内联的汇编语句中可以看到,自加自减均采用单条汇编指令,直接在输出数%0上加1或减1。这里的输出数%0的值即是v->counter变量的值。

5.操作并测试

atomic_sub_and_test函数实现的功能是原子的从v减去i,如果结果等于0,则返回1;否则返回0。

 77static inline int atomic_sub_and_test(int i, atomic_t *v)
  78{
  79        unsigned char c;
  80
  81        asm volatile(LOCK_PREFIX "subl %2,%0; sete %1"
  82                     : "+m" (v->counter), "=qm" (c)
  83                     : "ir" (i) : "memory");
  84        return c;
  85}

通过上述源码可以看到,第一条指令实现减操作;接着根据ZF的值设置c变量的值。sete命令的作用是,如果ZF=1,也就是说减的结果为0,将设置c变量为1;否则c的值为0。执行完毕后返回相应的c值。

 119static inline int atomic_dec_and_test(atomic_t *v)
 120{
 121        unsigned char c;
 122
 123        asm volatile(LOCK_PREFIX "decl %0; sete %1"
 124                     : "+m" (v->counter), "=qm" (c)
 125                     : : "memory");
 126        return c != 0;
 127}

 137static inline int atomic_inc_and_test(atomic_t *v)
 138{
 139        unsigned char c;
 140
 141        asm volatile(LOCK_PREFIX "incl %0; sete %1"
 142                     : "+m" (v->counter), "=qm" (c)
 143                     : : "memory");
 144        return c != 0;
 145}

上数两个函数的作用是自减1或自加1后,再测试v值是否为0,如果是0,则返回1;否则返回0。

也许你会认为上述的加/减并测试并不是原子的。我个人的认为是:第一条加/减操作的确是原子的,当此条语句执行完毕后,会产生相应的ZF值。如果此时在执行sete之前产生了中断,那么肯定会保存当前寄存器等值。因此,即便中间产生了中断,返回的也是中断前加/减后的结果。

6.操作并返回

 173static inline int atomic_add_return(int i, atomic_t *v)
 174{
 175        int __i;
 176#ifdef CONFIG_M386
 177        unsigned long flags;
 178        if (unlikely(boot_cpu_data.x86 <= 3))
 179                goto no_xadd;
 180#endif
 181        /* Modern 486+ processor */
 182        __i = i;
 183        asm volatile(LOCK_PREFIX "xaddl %0, %1"
 184                     : "+r" (i), "+m" (v->counter)
 185                     : : "memory");
 186        return i + __i;
 187
 188#ifdef CONFIG_M386
 189no_xadd: /* Legacy 386 processor */
 190        raw_local_irq_save(flags);
 191        __i = atomic_read(v);
 192        atomic_set(v, i + __i);
 193        raw_local_irq_restore(flags);
 194        return i + __i;
 195#endif
 196}

首先if判断语句判断当前的处理器是否为386或386以下,如果是则直接执行no_xadd处开始的代码;否则紧接着判断语句执行。此处的unlikely表示”经常不“。因为现在的处理器大都高于386,所以编译器一般都按照高于386来处理,以达到优化源代码的目的。搞清楚这段代码的逻辑关系,那么接下来的工作就不困难了。

如果CPU高于386,则它将执行xaddl命令,该命令的作用是先交换源和目的操作数,再相加。这里%0,%1分别代表i和v->counter。首先将i值用__i保存;操作数交换后,%0,%1的值依次为v->counter和i;相加并保存到%1;最后%0,%1的结果就是v->counter,i+v->counter,返回的结果i+__i的结果就是i+v->counter。这里涉及到i和v->counter的值时均指初值。

理解了上述过程,再看其他的操作返回函数:

 205static inline int atomic_sub_return(int i, atomic_t *v)
 206{
 207        return atomic_add_return(-i, v);
 208}

可以看到,atomic_sub_return函数是对atomic_add_return函数的封装。而下面两个函数则又是对上述两个函数的封装。

 210#define atomic_inc_return(v)  (atomic_add_return(1, v))
 211#define atomic_dec_return(v)  (atomic_sub_return(1, v))

上述就是对整形原子操作的分析。

C语言中的指针和数组

19 10 月, 2010

下面的内容节选自由我所执笔的会议记录。对于本文的不足之处,各位可以提出自己的看法。

Q1:指针和数组到底是怎么一回事?

A:指针和数组有本质的不同。指针就是一个内存地址,在32位系统下,一个指针永远占4个字节;数组是一块连续的内存空间,我们从一个已定义的数组中可以获得数组大小以及这块连续内存空间的起始地址。这个起始地址即数组首元素的地址,更具体的说是数组中首个元素的首地址。

在C语言中,只有一维数组。但是,当一个一维数组的元素是仍然是一维数组时,就形成了所谓的一维数组。如何印证这一点?二维数组在内存中的存储方式仍然是按照一维数组那样线性存储的,只不过这个数组的元素按照另一个一维数组线性存储。多维数组照此类推。

Q2:我还能获得关于数组和指针更详细的说明吗?

A:当然可以。

我们通常会这样使用一个指针:

int a[5];
int *p=a;

我们首先定义了一个指向int类型的指针p,在定义p的同时将其初始化为a;通常我们将这种行为称为“p指向一个大小为5的整形数组a”。事实上,我们可以更具体的想一下:p真的指向整个数组吗?当然不是。p只是指向一个int型变量而已。在这个例子中,p指向的是a数组的首元素。换句话说,p存储的是&a[0]。另外,p是变量,我们可以对p进行自加自减(在a数组有效的范围内),让p指向a数组的其他元素。换句话说,p可以存储整个数组中任意一个元素的地址(更具体的是这个元素的首地址)。而数组名a虽然也是个地址,但是它是一个常量,它永远存储的是数组的首地址,不可改变。

对于上述所言的p指针,我们可以通过指针方式*(p+i)和下标方式p[i]访问数组。对于数组名a而言,我们也可以通过*(a+i)和下标方式a[i]来访问数组。对于p指针而言,以指针方式访问数组的过程是这样的:我们通过p指针首先获取这个数组的首地址,然后加上i个偏移量,得到数组中第i个元素的地址,最后通过引用,得到具体的值。而对于p[i]这种下标访问方式,最终还是会被转化成上述指针访问方式。对于数组名a而言,与p方式相同。

另外还要注意,上述所说的i个偏移量,并不是加上i个字节那么简单;而是i个元素的总字节数。因此,给指针p加上一个整数和给指针p的二进制表示形式加上同样的整数,两者的含义是截然不同的。
另外,刚说到a是一个常量的问题,我想到了const关键字。上次在现代软件工程课程上,我听到有的同学说const所修饰的是常量。const修饰的当然是一个变量,只不过这个变量是只读的,即便这个变量的特性和常量相似。

Q3:对于数组a[3][4],我该如何理解更多的信息?

A:我们首先可以获知以下信息:数组a是一个包含有3个元素的数组,每个数组元素是一个大小为4的一维数组。因此,我们通常说这个数组有三行四列(但是你要清楚:内存中并不会出现3*4的那样的表格)。具体来说,二维数组a有以下三个元素:a[0],a[1],a[2];每一个元素又都是一个一维数组。对于一维数组a[0]来说,它又有4个元素:a[0][0],a[0][1],a[0][2],a[0][3];这4个元素是int型的。

以上就是关于这个数组的基本结构,下面从指针的角度来分析这个数组。

对于上述的数组名a,我们称为指向指针的指针(a是一个常量)。对于一维数组我们知道,数组名是数组中首元素的地址。对于上述所言的数组a,a当然也是这个数组首元素的地址。那么,数组a的首元素是什么?对了,就是a[0]。那么a这个指针存储的就是a[0]的地址,即a等价于&a[0]。那么a+i也就很明显了:a[i]的地址。再来想a[i]是什么?它是数组a中第i个元素。在数组a中,第i个元素是什么?它是一个大小为4的一维数组。对应到上述所言的“三行四列”,a+i即是指向第i行的指针。可以看到,i这个偏移量此刻是以行为单位的。

我们上述已说明,a+i指向a[i],a[i]是一个一维数组。a+i是一个指向指针的指针,那么现在取出a+i的值,也就是*(a+i)。从我们所说的“指向指针的指针”来看,*(a+i)也是一个指针,但是这个指针指向什么?它指向数组a[i]的首元素的地址,也就是a[i][0]的地址,即&a[i][0]。那么数组a[i]中第j个元素的地址是什么?那就是*(a+i)+j,即&a[i][j]。当然,也可以这么写:a[i]+j。

另外要说明的是,上述的a+i和*(a+i)的内存地址其实是相同,但是含义是完全不同的。具体原因,你可以从上面的陈述中得到答案。

Q4:难道指针就只有这么多内容吗?

A:当然不是。关于指针更高级的使用,还有指向一维数组的指针;指针数组;函数指针。可能它们的定义方式会让你迷惑,但是,无论如何,它们本质上仍然是指针。先了解最基本的指针,然后再理解这些高级指针就简单了许多。

上述Q1~Q3从某种角度来说,叙述的过于罗嗦,甚至有时候必须得咬文嚼字;并且,必须在实践的基础上理解上述内容。我个人的建议是,指针部分必须建立在“理论——实践——理论”这样反复的过程中,否则——套用现在最fashion的话——“指针神马的一切都是浮云~”。

grep和正则表达式

16 10 月, 2010

这两天抽空看了一下正则表达式,随之也基本会用grep命令了。关于grep和正则表达式的具体使用,总结成文章如下。

什么是grep?

grep (Global search Regular Expression and Print out the line,全面搜索正则表达式并把行打印出来)是一种强大的文本搜索工具,它能使用正则表达式搜索文本,并把匹配的行打印出来。

什么是正则表达式?

正则表达式(Regular Express)就是由一系列特殊字符组成的字符串, 其中每个特殊字符都被称为元字符, 这些元字符并不表示为它们字面上的含义,而会被解释为一些特定的含义。

正则表达式的元字符

1.句点(.)

在正则表达式中,句点(.)可以匹配任何的单个字符。比如:

e.sionte:可以是edsionte,e#sionte,e7sionte等等;

ed…te:可以是edsionte,ed@wdte等

Try:

:%s/  a.d  /@/g

打开任意一个文本文件(本文中的所有命令都是使用这里的文章进行的测试),在vim命令状态下输入上述命令。这条命令的意思是:在所有行(%s代表所有行)中查找符合“  a.d  “的字符串(注意a前面和d后面均有一个空格),并且将符合条件的字符串替换成@;g代表将每一行中符合上述条件的所有字符串都做相应替换,否则只会替换每一行的第一个否和条件的字符串。在上述命令中,属于正则表达式的字符串为两个/之间的部分。

2.^符号

在正则表达式中,^符号表示跟行首进行匹配。比如:

edsionte is a good boy. edsionte likes eating.edsionte likes music.

^edsionte只会跟行首的edsionte进行匹配,而不是和位于行中的其他edsionte进行匹配。

Try:

:%s/^/      /

上述命令在一个文本文件的每行都插入五个空格。对于上述命令,在命令末尾加g和不加g作用是一样的。

3.美元符号($)

与^符号相反,美元符号($)代表跟行尾进行匹配。比如:

edsionte is eating a apple.edsionte will eat that pear.This cup of milk was drunk by edsionte.

edsionte$不会与末尾的edsionte进行匹配,因为这一行最后一个字符是句点(.)。而且它更不会与此行中其他两个edsionte进行匹配。同样的,对于上述命令,在命令末尾加g和不加g作用是一样的。

那么如何匹配行尾的句点?你会想到是这样:.$。不过,这个正则表达式表示的确实匹配行尾的任意的单字符。学过C语言的你,应该知道为什么了吧?我们上面说过正则表达式是由元字符组成,因此句点在正则表达式中不会代表它本身的意思。想要使用句点本身,即得在句点前加\。也就是说,\.$才会真正的匹配行尾的句点。这其实就是转义字符,got it?

Try:

:%s/..$//

删除每行的最后两个字符。

4.[…]结构

在正则表达式中,使用[…]来匹配包含在此结构中的一个字符。比如:

[Tt]he:不管是The还是the都否和匹配要求,这条正则表达式很好的处理了出现在行首的那些单词。但必须注意的是,在字符串“Ttheapple”中,使用上述正则表达式所匹配的是the,而不是Tthe。

[0123456789]:匹配的是任意一个数字,更简单的写法是[0-9]。

[^0-9]:匹配非数字的单字符。请注意这条正则表达式和^[0-9]的差异。

一些特殊的规则是,如果要匹配一个连字符,必须将连字符放在靠近左[的位置。如果方括号内有^必须将^放在所有匹配字符的前方,比如:

[-0-9]:匹配一个数字或者连字符。

[^-0-9]:匹配一个不是连字符或数字的字符。

Try:

:%s/[Hh]arry Potter[0-9]/HARRY POTTER/g

将诸如harry potter3、Harry potter5等这样的字符串都替换成HARRY POTTER。

:%s/HARRY POTTER/*harry potter*/g

将上一步替换后的字符串都换成*harry potter*。可能你会有这样的疑问:*,.,和^等这样的字符不是元字符吗,为什么这里可以直接使用*的本来意思?这是因为元字符只有在搜索串(也就是在正则表达式中)中才会有特殊意义,在替换串中则不会有特殊意义。

5.星号(*)

在正则表达式中,用星号来匹配零到多个紧靠在星号左边的那个字符。比如:

.*:表示零到多个任意字符。因为正则表达式总是寻求最大匹配,因此.*总是匹配一整行。

go*le:可以用来匹配gle,gole,goole,gooooooooooole等。

goo*le:最小的匹配为gole。

t.*t:匹配前后均为t的字符串,而且匹配的是最大长度的字符串。

Try:

:%s/  */ /g

将每一行中的一个到多个空格都全部换成一个空格。

:%s/[a-zA-Z][a-zA-Z]*//g

这个会有什么结果,试试就知道。

6.\{…\}结构

使用\{…\}这样的结构可以匹配精确数目的字符。比如:

t\{1,5\}:匹配1到5个连续的t。

[a-zA-Z]\{4,8\}:匹配4到8个连续的字母。

[0-9]\{8\}:匹配正好8个数字。

[a-z]\{4,\}:匹配至少4个连续的小写字母。

Try:

:%s/[a-z]\{5,\}/@/g

将至少5个连续的小写字母替换成@。

grep的使用

grep命令的基本使用方法是:grep 模式 文件名。文件中符合模式的字符串所在行均会被打印出来。比如:

grep include hello.c:即在hello.c中查找包含字符串include的那些行。

如何将上述我们所熟悉的正规表达式与grep命令结合起来?模式处即为正则表达式,并用单引号包含。比如:

grep ‘[Hh]arry [Pp]otter’ harry.txt:在harry.txt中查找harry potter所在的行,其中H和P是不区分大小写的。

另外,grep命令还有下面一些选项,可以使grep命令使用的更灵活。

-i:模式匹配时忽略大小写的差异;
-l:只输出匹配模式的文件名,而不打印匹配的行;
-q:匹配成功并不将结果在标准输出中显示;
-v:显示不符合模式的行;
-n:在匹配行前显示行号;

const和enum

14 10 月, 2010

const

我们可以将const关键字所修饰的变量看作是只读变量,也就是说这个变量不可被修改,只能读取其值。但它决不是常量。在标准C语言中,下面的语句是错误的:

	const int i=5;
	int a[i]={1,2,3,4,5};

诸如5,“hello”这样的常量以及宏定义过的常量之所以不能被修改是因为在内存中没有为他们分配空间,它们存储在运算单元的寄存器中。而上述所言的const修改过的变量说到底还是一个变量,内存中有存储那个变量的地方。只不过,这个变量有些特殊:只能读取。现在再看上面的代码,由于i为变量,它不能用来初始化数组的大小。

接着看下面的代码:

typedef char * charp;
char string[4] = "abc";
const char *p1 = string;
const charp p2 = string;
p1++;
p2++;

最后一句会报错,为什么?

在第三句中,p1是可变的,而*p是const的;第四句中,p2是const的,因此不能进行++;也许你此时对p和*p哪一个为const很迷惑。但是没有关系,这里有一个小技巧:将上述语句中的数据类型去掉,离const最近的就是只读的。比如const char *p1 = string去掉char后,*p离const最近,那么*p是const的;再如const charp p2 = string去掉数据类型charp后,p2离const最近,那么p2就是不可改变的。

不过,对于类似const (char *)p1 = string;这样的语句,上述办法有点阻碍。不过你可以将(char*)看成一个整体(你也可以认为是用typedef定义了一个新类型),那么就可以继续用上面的方法。

enum

关于中断处理函数的返回值类型,有下面的定义:

//linux/include/linux/interrupt.h
 98typedef irqreturn_t (*irq_handler_t)(int, void *);
//linux/include/linux/irqreturn.h
 10enum irqreturn {
 11        IRQ_NONE,
 12        IRQ_HANDLED,
 13        IRQ_WAKE_THREAD,
 14};
 15
 16typedef enum irqreturn irqreturn_t;

有一些书上使用的是int型,并且使用int也可以通过。这是为什么?

其实,了解了枚举类型的本质,这个问题就一目了然了。枚举类型的定义形式如下:

enum
{ 枚举常量1,枚举常量2,……,枚举常量n};

而枚举常量是用标示符表示的整形常量。并且C语言规定枚举常量的默认值依次为:0,1,……,n-1。对应到上面的定义代码,enum irqreturn中三个常量的值即为0,1,2。

windows 7 ultimate product key

windows 7 ultimate product key

winrar download free

winrar download free

winzip registration code

winzip registration code

winzip free download

winzip free download

winzip activation code

winzip activation code

windows 7 key generator

windows 7 key generator

winzip freeware

winzip freeware

winzip free download full version

winzip free download full version

free winrar download

free winrar download

free winrar

free winrar

windows 7 crack

windows 7 crack

windows xp product key

windows xp product key

windows 7 activation crack

windows7 activation crack

free winzip

free winzip

winrar free download

winrar free download

winrar free

winrar free

download winrar free

download winrar free

windows 7 product key

windows 7 product key