第5章--操作符和表达式

1、编写一个程序，从标准输入读取字符，并把它们写到标准输出中。除了大写字母字符要转换为小写字母之外，所有字符的输出形式应该和他的输入形式完全相同。

#include <stdio.h>

int main(void)
{
	int ch;

	printf("please input a string:");

	while ((ch = getchar()) != EOF)
	{
		if ((ch >= 'A') && (ch <= 'Z'))
		{
			ch -= ('A' - 'a');
		}

		putchar(ch);
	}

	return 0;
}

2、编写一个程序，从标准输入读取字符，并把它们写到标准输出中，所有非字母字符都完全按照它的输入形式输出，字母字符在输出之前进行加密。加密的方法很简单：每个字母被修改为在字母表上距其13个位置（前或后）的字母，例如，A被修改为N，B被修改为O，Z被修改为M，以此类推，注意大小写字母都应该被转换。

#include <stdio.h>

int main(void)
{
	int ch;

	while ((ch = getchar()) != EOF)
	{
		if (((ch >= 'a') && (ch <= 'm')) || ((ch >= 'A') && (ch <= 'M')))
		{
			ch += 13;
		}
		else if (((ch >= 'n') && (ch <= 'z')) || ((ch >= 'N') && (ch <= 'Z')))
		{
			ch -= 13;
		}

		putchar(ch);
	}

	return 0;
}

3、 请编写函数:
unsigned int reverse_bits(unsigned int value);
这个函数的返回值是把value的二进制位模式从左到右变换一下之后的值。例如，在32位机器上，25这个值包含下列各位：
00000000,00000000,00000000,00011001
函数的返回值应该是2550136832,它的二进制位模式是：
10011000,00000000,00000000,00000000
编写函数时注意不要让它依赖于你的机器上整型值的长度。

#include <stdio.h>

unsigned int reverse_bits(unsigned int value);

int main(int argc, char *argv[])
{
	unsigned int ch;

	ch = atoi(argv[1]);
	printf("%d\n", ch);	
	printf("%u\n", reverse_bits(ch));

	return 0;
}

unsigned int reverse_bits(unsigned int value)
{
	unsigned int i;
	unsigned int tmp = 0;

	for (i = 1; i != 0; i <<= 1)
	{
		tmp <<= 1;

		if (value & 0x1)
		{
			tmp |= 0x1;
		}

		value >>= 1;
	}

	return tmp;
}

4、编写一组函数，实现位数组，函数的原型如下：
void set_bit(char bit_array[], unsigned bit_number);
void clear_bit(char bit_array[], unsigned bit_number);
void assign_bit(char bit_array[], unsigned bit_number, int value);
int test_bit(char bit_arrar[], unsigned bit_number);
每个函数的第一个参数是字符数组，用于实际储存所有的位，第二个参数用于标识需要访问的位。
函数的调用者必须确保这个值不要太大，以至于超出数组边界。
第一个函数把指定的位设置为1,第二个函数把指定的位清零，如果value的值为1，第三个函数就把指定的位清零，否则置1，至于最后一个函数，如果参数中指定的位不为零就返回真，否则返回假。

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

void set_bit(char bit_array[], unsigned int bit_number);
void clear_bit(char bit_array[], unsigned int bit_number);
void assign_bit(char bit_array[], unsigned int bit_number, int value);
int test_bit(char bit_array[], unsigned int bit_number);

int main(int argc, char *argv[])
{
	//int i = 2767;    //101011001111b
	char binbuf[] = "abcd1234";
	int bit1 = atoi(argv[1]);
	int bit2 = atoi(argv[2]);
	int bit3 = atoi(argv[3]);
	int bit4 = atoi(argv[4]);
	
	printf("original data: %s\n", binbuf);

	set_bit(binbuf, bit1);
	printf("set bit %d: %s\n", bit1, binbuf);
	
	clear_bit(binbuf, bit2);
	printf("clear bit %d: %s\n", bit2, binbuf);
	
	assign_bit(binbuf, bit3, 0);
	printf("assign bit %d: %s\n", bit3, binbuf);
	
	printf("test bit %d: %d\n", bit4, test_bit(binbuf, bit4));

	return 0;		
}

void set_bit(char bit_array[], unsigned int bit_number)
{
	if (bit_number <= sizeof(bit_array))
	{
		bit_array[bit_number / 8] |= (1 << (bit_number % 8));
	}
}

void clear_bit(char bit_array[], unsigned int bit_number)
{
	if (bit_number <= sizeof(bit_array))
	{
		bit_array[bit_number / 8] &= ~(1 << (bit_number % 8));
	}
}

void assign_bit(char bit_array[], unsigned int bit_number, int value)
{
	if (value)
	{
		set_bit(bit_array, bit_number);
	}
	else
	{
		clear_bit(bit_array, bit_number);
	}
}

int test_bit(char bit_array[], unsigned int bit_number)
{
	if ((bit_array[bit_number / 8]) & (1 << (bit_number % 8)))
	{
		return 1;
	}
	else
	{
		return 0;
	}
}

5、 编写一个函数，把一个给定的值存储到一个整数中指定的几个位。它的原型如下：
int store_bit_field(int original_value, int value_to_store, unsigned starting_bit, unsigned ending_bit);
假定整数中的位是从右向左进行编号。因此，起始位的位置不会小于结束位的位置，为了更清楚的说明，函数应该返回下列值。

原始值	需要储存的位	起始位	结束位	返回值
0x0	0x1	4	4	0x10
0xffff	0x123	15	4	0x123f
0xffff	0x123	13	9	0xc7ff

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

int store_bit_field(int original_value, int value_to_store, int starting_bit, int ending_bit);

int main(int argc, char *argv[])
{
	int result;

	printf("original value: 0x%x\n", atoi(argv[1]));
	printf("value to store: 0x%x\n", atoi(argv[2]));
	result = store_bit_field(atoi(argv[1]), atoi(argv[2]), atoi(argv[3]), atoi(argv[4]));
	printf("result: 0x%x\n", result);

	return 0;
}

int store_bit_field(int original_value, int value_to_store, int starting_bit, int ending_bit)
{
	int i;
	unsigned int mask = (unsigned int)0;

	for (i = 0; i < (starting_bit - ending_bit + 1); i++)
	{
		mask  |= 0x1;
		mask <<= 1;
	}
	mask <<= (ending_bit - 1);

	//printf("mask: 0x%x\n", mask);

	original_value  &= ~mask;
	value_to_store <<= ending_bit;
	value_to_store  &= mask;
	original_value  |= value_to_store;

	return original_value;
}