可恶的C语言——位运算与可变数组

可恶的C语言——位运算与可变数组

位运算

一、按位运算

1.按位运算的运算符

（1）按位与&

• 如果（x)i1并且（y)i1,那么（x&y)i==1
• 否则的话（x & y）i=0
• 按位与常用与两种应用：
  • 让某一位或某些位为0：x & 0xFE
  • 取一个数中的一段：x & 0xFF

（2)按位取或|

• 如果（x)i1或（y)i1,那么（x|y）i=1
• 否则的话（x|y)i==0
• 按位或常用于两种应用：
  • 使得意味或几个位为1：x|0x01
  • 把两个数拼起来：0x00FF|0xFF00

(3)按位取反

• （~x)i=1-(x)i
• 把1位变为0，0位变为1
• 想得到全部位为1的数：~0
• 7的二进制是0111，x|7使得低3位为1，而
• x&~7，就使得低3位为0

（4）按位异或^

• 如果（x）i==（y)i,那么（x^y)i=0
• 否则的话（x^y)i==1
• 如果两个位相等，那么结果为0；不相等，结果为1
• 如果x和y相等，那么x^y的结果为0
• 对一个变量用同一个值异或两次，等于什么也没做
  • x^yy—>x

(4)左移

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

（5)右移

• i>>j
• i中所有的位向右移j位
• 所有小于int的类型，移位以int的方式来做，结果是int
• 对于unsigned的类型，左边填入0
• 对于signed的类型，左边填入原来的最高位（保持符号不变）
  • x>>=1等价于x/=2
  • x>>=n等价于x/=2的n次方

2.输出一个数的二进制

#include <stdio.h>

int main(int argc,char const *argv[])
{
    int number;
    scanf("%d",&number);
    unsigned mask=1u<<31;//u表示为一个unsigned的数，往左移31个bit
    for( ;mask ;mask>>=1)
    {
        printf("%d",number & mask?1:0);
    }
    printf("\n");
    
    return 0;
}

3.位段

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

struct
{
    unsigned int leading :3;//数字表示占几个bit
    unsigned int FLAG1 :1;
    unsigned int FLAG2： 1；
    int trailing : 11;
};

例如：

#include <stdio.h>

void ptrBin(unsigned int number);

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

int main(int argc,char const *argv[])
{
    struct U0 uu;
    uu.leading=2;
    uu.FLAG2=1;
    uu.trailing=0;
    printf("sizeof(uu)=%li\n",sizeof(uu));
    ptrBin(*(int*)&uu);
    
    return 0;
}

二、可变数组

1、可变数组

• Array array_creat(int init_size);创建一个数组
• void array_free(Array *a);释放数组
• int array_size(const Array *a);说明数组中有多少个空间可以用
• int* array_at(Array *a,int index);访问数组中的某个单元
• void array_inflate(Array *a,int more_size);让数组长大

#include "array.h"

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

Array array_creat(int init_size)
{
    Array a;
    a.size=init_size;
    a.array=(int*)malloc(sizeof(int)*a.size);
    return a;
}

void array_free(Array *a)
{
    free(a->array);
    a->array=NULL;
    a->size=0;
}

int array_size(const Array *a)
{
    return a->sizel
}

//封装
int array_size(const Array *a)
{
    return a->size;
}

int* array_at(Array *a,int more_size);
{
    return &(a->array[index]);
}

int array_get(const Array *a,int index)
{
    return a->array[index];
}

void array_set(Array *a,int index,int value)
{
    a->array[index]=value;
}

void array_inflate(Array *a,int more_size)
{
    inr *p=(int*)malloc(sizeof(int)(a->size+more_size));
    int i;
    for(i=o;i<a->size;i++)
    {
        p[i]=a->array[i];
    }
    free(a->array);
    a->array=p;
    a->size+=more_size;
}
int main(int argc,char const *argv[])
{
    Array a=array_creat(100);
    printf("%d\n",array_size(&a));
    *array_at(&a,0)=10;
    printf("%d\n",*array_at(&a,0));
    int number;
    int cnt=0;
    while(1)
    {
        scanf("%d",&number);
        *array_at(&a,cnt++)=number;
    }
    array_free(&a);
    
    return 0;
}