IP地址转换问题（2）不保证正确，暂时做的笔记

// #include <IOSTREAM>
// #include <STDIO.H>
// #include <WINSOCK.H>
// using namespace std;
// 
// typedef unsigned short int uint16;
// typedef unsigned long int uint32;
// 
// // 短整型大小端互换
// #define BigLittleSwap16(A)  ((((uint16)(A) & 0xff00) >> 8) | \
// (((uint16)(A) & 0x00ff) << 8))
// // 长整型大小端互换
// 
// #define BigLittleSwap32(A)  ((((uint32)(A) & 0xff000000) >> 24) | \
// 	(((uint32)(A) & 0x00ff0000) >> 8) | \
// 	(((uint32)(A) & 0x0000ff00) << 8) | \
// (((uint32)(A) & 0x000000ff) << 24))
// 
// // 本机大端返回1，小端返回0
// int checkCPUendian()
// {
// 	union{
// 		unsigned long int i;
// 		unsigned char s[4];
// 	}c;
// 	
// 	c.i = 0x12345678;
// 	return (0x12 == c.s[0]);
// }
// 
// // 模拟htonl函数，本机字节序转网络字节序
// unsigned long int t_htonl(unsigned long int h)
// {
// 	// 若本机为大端，与网络字节序同，直接返回
// 	// 若本机为小端，转换成大端再返回
// 	return checkCPUendian() ? h : BigLittleSwap32(h);
// }
// 
// // 模拟ntohl函数，网络字节序转本机字节序
// unsigned long int t_ntohl(unsigned long int n)
// {
// 	// 若本机为大端，与网络字节序同，直接返回
// 	// 若本机为小端，网络数据转换成小端再返回
// 	return checkCPUendian() ? n : BigLittleSwap32(n);
// }
// 
// // 模拟htons函数，本机字节序转网络字节序
// unsigned short int t_htons(unsigned short int h)
// {
// 	// 若本机为大端，与网络字节序同，直接返回
// 	// 若本机为小端，转换成大端再返回
// 	return checkCPUendian() ? h : BigLittleSwap16(h);
// }
// 
// // 模拟ntohs函数，网络字节序转本机字节序
// unsigned short int t_ntohs(unsigned short int n)
// {
// 	// 若本机为大端，与网络字节序同，直接返回
// 	// 若本机为小端，网络数据转换成小端再返回
// 	return checkCPUendian() ? n : BigLittleSwap16(n);
// }
// 
// //8个二进制(2个十六进制)数转换成十进制数,不含a-f。即00-99的转换   
// int transfer_0(int x)  
// {  
//     int y;//结果   
//     int temp;//临时值   
// 	
//     y=x%10;//个位数   
//     temp=(x%100-y)/10;//十位数   
//     y+=temp*16;  
//     return y;  
// }  
// 
// //32个二进制(4个十六进制)数转换成十进制数,不含a-f。即0000-9999的转换   
// void transfer_1(unsigned int x)  
// {  
//     //从右向左   
//     int temp1=x%100;  
//     int y1=transfer_0(temp1);  
// 	
//     int temp2=(x%10000-temp1)/100;  
//     int y2=transfer_0(temp2);  
// 	
//     int temp3=(x%1000000-temp1-temp2*100)/10000;  
//     int y3=transfer_0(temp3);  
// 	
//     int temp4=(x%100000000-temp1-temp2*100-temp3*10000)/1000000;  
//     int y4=transfer_0(temp4);  
// 	
//     printf("结果是：%d.%d.%d.%d\n",y4,y3,y2,y1);  
// }
// 
// //将16进制数数转化成10进制数，一位的0-F。   
// int transfer_0(char x)  
// {  
//     int y=0;//返回值   
//     if (x>='0' && x<='9')//0-9的数字   
//     {  
//         y=x-'0';  
//         return y;  
//     }  
//     if (x>='a' && x<='f')//a-f的字母   
//     {  
//         y=x-'a'+10;  
//         return y;  
//     }  
//     if (x>='A' && x<='F')//A-F的字母   
//     {  
//         y=x-'A'+10;  
//         return y;  
//     }  
//     printf("参数错误！");  
//     exit(1);  
// }
// 
// 
// //将16进制数数转化成10进制数，八位的00000000-FFFFFFFF。   
// void transfer_3(char x[],int n)//长度为8   
// {  
//     //从左往右   
//     int y0=transfer_0(x[0]);  
//     int y1=transfer_0(x[1]);  
//     int y2=transfer_0(x[2]);  
//     int y3=transfer_0(x[3]);  
//     int y4=transfer_0(x[4]);  
//     int y5=transfer_0(x[5]);  
//     int y6=transfer_0(x[6]);  
//     int y7=transfer_0(x[7]);  
// 	
//     printf("结果是：%d.%d.%d.%d\n",y0*16+y1,y2*16+y3,y4*16+y5,y6*16+y7);      
// }
// 
// 
// //将16进制数数转化成10进制数，八位的00000000-FFFFFFFF。   
// void transfer_4(char x[])  
// {  
//     //从左往右   
//     int y1=transfer_0(x[0])*16+transfer_0(x[1]);  
//     int y2=transfer_0(x[2])*16+transfer_0(x[3]);  
//     int y3=transfer_0(x[4])*16+transfer_0(x[5]);  
//     int y4=transfer_0(x[6])*16+transfer_0(x[7]);  
// 	
//     printf("结果是：%d.%d.%d.%d\n",y1,y2,y3,y4);      
// }  
// 
// //#include <linux/kernel.h>
// 
// 
// // #define NIPQUAD(addr) \
// // ((unsigned char *)&addr)[0], 
// // ((unsigned char *)&addr)[1], 
// // ((unsigned char *)&addr)[2], 
// // ((unsigned char *)&addr)[3]
// 
// 
// // #include <linux/kernel.h>
// // printk("%d.%d.%d.%d\n", NIPQUAD(iph->saddr));
// // 
// // #define NIPQUAD(addr) \
// // ((unsigned char *)&addr)[0], 
// // ((unsigned char *)&addr)[1], 
// // ((unsigned char *)&addr)[2], 
// //         ((unsigned char *)&addr)[3]
// 
// //转化为十六进制
// #define TRANS(x) (x & 0xFFFF)
// // 十六进制转整数:scanf("%x",i);
// // 整数转二进制字符串：
// // for(int n=0;n<32;n++)
// // {
// // 	char bit=(i>>n)&1;//取i的第n位
// // 	printf("%d",bit);
// // }
// //转化为二进制
// 
// void trans16to2(int i)
// {
// 	for(int n=0;n<32;n++)
// 	{
// 		char bit=(i>>n)&1;//取i的第n位
// 		printf("%d",bit);
// 	}
// 	printf("\n");
// }
// 
// void trans10to2(int num)
// {
//     if(num ==0)
//     {       
// 		return;
//     }
//     else
//     {
// 		trans10to2(num/2);  
// 		printf("%d",num%2);
//     }
// }
// 
// void test()
// {
// // 	char str1[20];
// // 	char str2[20];
// // 	char str3[20];
// // 	char str4[20];
// 
// 	unsigned long a1=0;
// 	unsigned long a2=0;
// 	unsigned long a3=0;
// 	unsigned long a4=0;
// 
// 	unsigned long ipX32=0;
// 	//struct in_addr st_addr;
// 
// 	sscanf("10.112.112.73","%d.%d.%d.%d",&a1,&a2,&a3,&a4);
// 	
// 	printf("%d%d%d%d\n",a1,a2,a3,a4);
// 	printf("%02x,%02x,%02x,%02x\n",a1,a2,a3,a4);
// 
// // 	a1 &= 0xff;
// // 	printf("%08x\n",a1);
// // 	a2 &=0xff;
// // 	printf("%08x\n",a2);
// // 	a3 &=0xff;
// // 	printf("%08x\n",a3);
// // 	a4 &=0xff;
// // 	printf("%08x\n",a4);
// 
// 	ipX32 = (TRANS(a1)<<24) | (TRANS(a2)<<16) | (TRANS(a3)<<8) | TRANS(a4);
// 
// 	printf("%08x\n",ipX32);
// 
// 	trans10to2(a1);
// 	trans10to2(a2);
// 	trans10to2(a3);
// 	trans10to2(a4);
// 
// 	printf("\n");
// 
// 	trans16to2(a1);
// 	trans16to2(a2);
// 	trans16to2(a3);
// 	trans16to2(a4);
// 	
// }
// 
// 
// 
// int main()
// {
// 	test();
// 	return 0;
// }

#include<iostream>
using namespace std;


//十进制转为二进制

char*__bit(int n,char*array,int size)
{
		for(int i=size-1;i>=0;i--,n>>=1)

			array[i]='0'+(1&n);

			array[size]='\0';

			return array;

}

//二进制转为十进制(应用了查表法,本程序中的表是mask数组)

int __bit(char *array,int strlen,int *mask,int last_iterator)
{

		int temp=0;

		for(int i=strlen-1;i>=0;i--)

			temp+=(1&(array[i]-'0'))*mask[last_iterator--];

			return temp;
}

void main()
{
		//一个二进制数中:从右到左,第一位的权值是2的0次方=1,第二位是2的1次方=2,第三位是2的2次方=4,第四位是2的3次方=8,...
		int mask[]={2048,1024,512,256,128,64,32,16,8,4,2,1};//这个数组有多少个元素就能求多少位的二进制为十进制,你可以将它向前扩展
		int last_iterator=sizeof(mask)/4-1;//不管数组mask有多少个元素,这个语句可以计算出mask的最后一个元素的下标值
		cout<<__bit("001",strlen("001"),mask,last_iterator)<<endl;
		cout<<__bit("010",strlen("010"),mask,last_iterator)<<endl;
		cout<<__bit("011",strlen("011"),mask,last_iterator)<<endl;
		cout<<__bit("100",strlen("100"),mask,last_iterator)<<endl;
		cout<<__bit("101",strlen("101"),mask,last_iterator)<<endl;
		cout<<__bit("110",strlen("110"),mask,last_iterator)<<endl;

		printf("%s\n",10);

}