2005年05月23日

爱上位运算
———————————————————————————–
       2005
41                E-mail: zjneter@163.com
———————————————————————————-


缘起:C语言区别于其它语言的重要特点是支持位运算,使其能够完成汇编语言所能完成的大部分功能。但是学校开设的C语言课程中老师往往将位运算这一章一代而过,好像这一张根本不重要。但是在实际的编程中借助于位运算往往可以设计出简洁的算法,使程序简化,并且获得较高的效率。而且在某些对硬件进行控制的编程中,位运算是必不可少的。因此笔者参考了相关书籍,总结了一些规律和助记口诀,希望对读者有所帮助。

优先级(高—〉低)
 ! ~ 
算术运算符 关系运算符 & ^ | && || 赋值

移位运算  <<   >>
要点 1 它们都是双目运算符,两个运算分量都是整形,结果也是整形。
     2
左移:右边空出的位上补0,左边的位将从字头挤掉,其值相当于乘2
     3
右移:右边的位被挤掉。对于左边移出的空位,如果是正数则空位补0,若为负数,可能补0或补1,这取决于所用的计算机系统。
      
移入0的叫逻辑右移,移入1的叫算术右移,Turbo C采用逻辑右移。

位运算符的应用  (源操作数s 掩码mask)
(1)
按位与—— &
  1
清零特定位 (mask中特定位置0,其它位为1s=s&mask)

  2 取某数中指定位 (mask中特定位置1,其它位为0s=s&mask)

(2) 按位或—— |
   
常用来将源操作数某些位置1,其它位不变。 (mask中特定位置1,其它位为0 s=s|mask)

(3) 位异或—— ^
  1
使特定位的值取反 (mask中特定位置1,其它位为0 s=s^mask)

  2 不引入第三变量,交换两个变量的值  ( a=a1,b=b1)
   
                         操作后状态
    a=a1^b1         a=a^b              a=a1^b1,b=b1
    b=a1^b1^b1      b=a^b              a=a1^b1,b=a1
    a=b1^a1^a1      a=a^b              a=b1,b=a1

位运算应用口诀
 
清零取反要用与,某位置一可用或
 
若要取反和交换,轻轻松松用异或

应用举例
    (1)
判断int型变量a是奇数还是偶数
            |- 0
偶数
 a&1=|
            |- 1
奇数
    (2)
int型变量a的第k (k=0,1,2……sizeof(int))
 a>>k&1
    (3)
int型变量a的第k位清0
 a=a&~(1<<k)
    (4)
int型变量a的第k位置1
 a=a|(1<<k)
    (5) int
型变量循环左移k
 a=a<<k|a>>16-k   (
sizeof(int)=16)
    (6) int
型变量a循环右移k
 a=a>>k|a<<16-k   (
sizeof(int)=16)

例题
 1
实现一个函数itob(),使用移位运算将从键盘上输入的整数转换为它的二进制表示形。
 
解: char * itob(int n,char *ps)
             {
                int i;
                static int size=8*sizeof(int);
                for(i=size-1;i>=0;i–,n>>=1)
                   ps[i]=(1&n)+’0′;
                ps[size]=’\0′;
                return ps;
             }
 2
编写一个函数 invert_end(),反转一个值中最后n位,并将结果返回。
 
解: int  invert_end(int num,int bits)
             {
                int mask=0;
                int bitval=1;
                while(bits– >0)
                {
                   mask|=bitval;
                   bitval<<=1;
                }
                return num^mask;
             }
实战练习
 1
编写一个将二进制字符串转化为数值的函数
  
若有 char *bin="01001001";
         
那么可将bin作为参数传给该函数,使函数返回值为25
 2
编写一个函数,该函数接受一个int参数,并返回该参数中打开的位的数量。
 3
编写一个函数,该函数接受两个参数:一个值和一个位置。如果制定的位上的值是1,函数返回1,否则返回0
总结
  (1)
在了解了各种位运算的操作原理后,最好熟记各运算符的优先级。在阅读别人写的代码是你可以去查书,但自己写程序时还是
     
熟能生巧。
  (2)
如你所见,在不引入第三变量的情况下使用异或运算就可以将两个变量的交换,本文给除了操作过程,你应当仔细分析一下。
     
感觉就像变魔术一般神奇 :)
  (3)
判断一个整数a的奇偶性通常的做法是看 a%2的结果是0还是1,这没什么不对,但是要知道%运算要比相应的位运算慢的多啦,
     
对十个数进行奇偶判断就无所谓啦,哪种方法都ok,但是若要对T数量级的数进行操作,你就不得不考虑一下效率问题了!

  本文主要参考了 C Primer Plus (第四版)》,本文的例题也来自这本书

 转(CSDN)

2005年05月18日

         数组


关于数组的初始化
例:int p[4]={1,2,3,4};
1
未经初始化的数组
  auto
类型的(自动存储类)的数组在初始化之前数组元素是不定的,编译器使用的在存储单元中已有的数值。
 
静态存储式时期的数组自动将所有元素初始化为零
2
部分初始化
  int p[4]={1,2};
 
p[0]=1,p[1]=2,p[3]=p[4]=0;
也就是说如果只初始化了数组中的部分元素,则剩余的元素自动初始化为0,因此如果要将一个数组全部初始化为零可以这样做p[MAX]={0}
3
指定项目初始化 ( C99 )
 
按照传统的方法要对数组的最后一个元素初始化,需要对每个元素都初始化之后才可以对最后一个元素进行初始化。
例如: int a[5]={0,0,0,0,16};
C99标准中可以用其新特性,指定初始化项目来简单的完成上述工作
例如:int a[5]={[5]=16};
在初始化列表中使用带方括号的元素下标可以指定某个特定元素
例: d[8]={1,2,[4]=9,10,11,[1]=15};
d[0]=1,d[1]=15,d[2]=0,d[3]=0,d[4]=9,d[5]=10,d[6]=11
注:指定项目初始化的两个重要特性
 
若在一个指定初始化项目后跟有不止一个值,则这些值将用来对后续的数组元素初始化。因此在d[4]=9之后,d[5].d[6]分别初始化为1011
 
如果多次对一个元素初始化,则最后一次有效.例中d[1]先被初始化为2,在[1]=15之后,d[1]又初始化为15

        指针和数组

c语言中数组和指针总有千丝万缕的联系。表现在以下几个方面
数组名同时也是该数组首元素的地址
 
对于数组f[MAX] f==&f[0]
  &
运算符取得数组元素f[0]的内存地址,因此f&f[0]都是常量且相等
可以使用指针处理数组
 
p[MAX]是一个数组,其首地址为0×00000000那么p+1的值是0×00000001吗?
回答是不一定。因为对一个指针加上1结果是对该指针增加一个存储单元。对于数组地址会增加到下一个元素的首地址,而不一定是一个字节。那么pp+1之间到底相差多少呢?这要有p所指对象的类型来决定。如果数组的类型是type那么pp+1相差 sizeof(type)个字节。
总结: 1 指针的数值就是它所指向的对象的地址,地址的内部表示由硬件决定。
       2
对指针加1等价于对指针的值加上它指向对象的字节大小。
c
语言标准描述数组时,借助了指针的概念,例如a[n]的意思是*(a+n),即先寻址到内存中的a,然后移动n个单位,再取出该内存处的值。
因此 p+2==&p[2], *(p+2)==p[2]
 
在这里要区分 *(p+2)*p+2的不同。由于*运算符的优先级比+要高, *(p+2)得到的是数组p中第三个元素的值。 *P+2得到的是数组p中第一个元素的值与2相加后的结果。

指针数组和指向数组的指针
  int *p[3]
int (*p)[3]有什么区别呢?
1 []
的优先级高于* 因此int *p[3]等价于int *(p[3])括号内显然是一个数组,括号外的部分表明了数组p的类型,因此p是一个含有3个元素的数组,数组的每一个元素是一个指针,而且是指向int型变量的指针。
2 int (*p)[3]
使得指针p指向了一个包含有3个元素的数组,该数组中元素类型为int 可以用下面的方法记忆
     int *p ;
     int a;
     p= &a;
     *p=a;
    
因此(*p)a代替,从字面上看int(*p)[3]替换为int a[3] ,故可以理解p指向了a[3]
指针和多维数组
  int  zippo[4][2];   /*
整数数组的数组*/
 
数组名 zippo是数组首元素的地址 zippo的首元素本身又是包含两个int型变量的数组。
  zippo
得值和&zippo[0]相同,而 zippo[0]的值同其首元素的地址&zippo[0][0]
相同。zippo[0]是一个整数大小的地址,而zippo是两个整数大小对象的地址。
 
对一个指针加1,会对原来的数值加上一个对应类型大小的数值。在这方面zippozippo[0]是不一样的。zippo所指的对象是两个int,zippo[0]所指的对象是一个int
 
对一个指针取值得到的是该指针所指对象的数值
  *(zippo[0])
代表存储在zippo[0][0]中的数值,即一个int
  *zippo
代表其首元素zippo[0]的值,但zippo[0]本身就是一个int数的地址即 &zippo[0][0],所以 *zippo 就是 &zippo[0][0], **zippo <=> *&zippo[0][0] <=> zippo[0][0]

           变长数组

声明变长数组
 C99
标准引入变成数组,它允许使用变量定义数组维数
变长数组有一些限制,变长数组必须是自动存储类的,这意味着他们必须在函数内部或作为函数声明且声明时不可以进行初始化。
 
示例:  int m=2,n=3;
          int a[m][n];
         
这里a是一个二维数组。
 
“变长”的意思是指在程序运行时动态的创建不同维数的数组,而每一次创建以后该数组就是固定大小的,知道其生存期结束。

变长数组作为函数参数
 
由于变长数组维数在运行时确定,故将其作为函数参数可以提高程序的灵活性和适应性。
 
声明一个带变长数组参数的函数
  int sum (int rows, int cols, int ar[rows][cols]);
注: ar的声明中使用了rowscols,所以在参数列表中对rowscols的声明要早于ar
C99
标准规定可以省略函数原型中的名称,但如果省略名称,则需要用星号代替省略的维数。 例如 int sum (int rows, int cols, int ar[*][*]);

 转自:CSDN

太久没更新了. :(