5 *进制转换为*进制（c语言实现）

前言

进制转换一共有12种，需要手写的进制转换只有6种，即转为10进制和10进制转为进制，其他6种可以用前面6种转换而来。

所以，我们应该熟练掌握前6种进制转换。

代码实现

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


int conversion2to10(int BIN[], int BINlen);
char *conversion2to16(int BIN[], int BINlen, int &HEXlen);
int conversion2to8(int BIN[], int BINlen);

int conversion8to10(int N);
int *conversion8to2(int N, int &BINlen);
char *conversion8to16(int N, int &HEXlen);

int conversion10to8(int N);
char *conversion10to16(int N, int &HEXlen);
int *conversion10to2(int N, int &BINlen);


int conversion16to10(char HEX[], int HEXlen);
int *conversion16to2(char HEX[], int HEXlen, int &BINlen);
int conversion16to8(char HEX[], int HEXlen);



int main() {

	char HEX[2] = { '7','B' };
	int DEC = 123;
	int OCT = 173;
	int BIN[8] = { 0, 1, 1, 1, 1 ,0 ,1 ,1 };
	int BINlen = sizeof(BIN) / sizeof(BIN[0]), HEXlen = sizeof(HEX) / sizeof(HEX[0]);
	printf("%d", HEXlen);
	//十进制转*进制的测试
	int *BIN2 = conversion10to2(DEC,BINlen);
	int OCT2 = conversion10to8(DEC);
	char *HEX2 = conversion10to16(DEC,HEXlen);
	printf("十进制123的二进制表示为：");
	for (int i = 0; i < BINlen; i++) {
		printf("%d  ", BIN2[i]);
	}
	printf("\n");
	printf("十进制123的八进制表示  = %d\n", OCT2);
	printf("十进制123的十六进制表示为：");
	for (int i = 0; i < HEXlen; i++) {
		printf("%c", HEX2[i]);
	}

	//二进制转为*进制的测试
	BINlen = sizeof(BIN) / sizeof(BIN[0]);
	HEXlen = strlen(HEX);

	printf("\n\n二进制转为*进制的测试");
	OCT2 = conversion2to8(BIN, BINlen);
	int DEC2 = conversion2to10(BIN, BINlen);
	HEX2 = conversion2to16(BIN, BINlen, HEXlen);


	printf("\n二进制01111011转化为八进制为：%d\n", OCT2);
	printf("二进制01111011转化为十进制为：%d\n", DEC2);
	printf("二进制01111011转化为十六进制为");
	for (int i = 0; i < HEXlen; i++) {
		printf("%c", HEX2[i]);
	}




	//八进制转为*进制的测试

	printf("\n\n八进制转为*进制的测试\n");
	BIN2 = conversion8to2(OCT, BINlen);
	printf("八进制173转化为二进制为：");
	for (int i = 0; i < BINlen; i++) {
		printf("%d  ", BIN2[i]);
	}
	DEC2 = conversion8to10(OCT);
	printf("\n八进制173转化为十进制为：%d	",DEC2);
	HEX2 = conversion8to16(OCT, HEXlen);
	printf("\n八进制173转化为十六进制为：");
	for (int i = 0; i < HEXlen; i++) {
		printf("%c", HEX2[i]);
	}




	//十六进制转换为*进制的测试
	printf("\n\n十六进制转为*进制的测试\n");
	printf("十六进制7B转化为二进制为：");
	BIN2 = conversion16to2(HEX ,HEXlen,BINlen);
	for (int i = 0; i < BINlen; i++) {
		printf("%d  ", BIN2[i]);
	}
	DEC2 = conversion16to10(HEX,HEXlen);
	printf("\n十六进制7B转化为十进制为：%d	", DEC2);

	OCT2 = conversion16to8(HEX, HEXlen);
	printf("\n十六进制7B转化为八进制为：%d",OCT2);
	

	getchar();
}




void swap(int &a, int &b) {
	int temp = a;
	a = b;
	b = temp;
}
void swap(char &a, char &b) {
	char temp = a;
	a = b;
	b = temp;
}
//将数组反转
void reverseArray(int *arr, int n) {
	if (n % 2 == 0) {
		int i = 0, j = n - 1;
		while (i != j + 1) {
			swap(arr[i++], arr[j--]);
		}
	}
	else {
		int i = 0, j = n - 1;
		while (i != j ) {
			swap(arr[i++], arr[j--]);
		}
	}
}
//将数组反转
void reverseArray(char *arr, int n) {
	if (n % 2 == 0) {
		int i = 0, j = n - 1;
		while (i != j + 1) {
			swap(arr[i++], arr[j--]);
		}
	}
	else {
		int i = 0, j = n - 1;
		while (i != j) {
			swap(arr[i++], arr[j--]);
		}
	}
}

//2进制转换为十进制
int conversion2to10(int BIN[], int BINlen) {
	int DEC = 0;
	int k = 1;
	for (int i = BINlen -1; i >= 0 ; i--) {
		DEC = DEC + BIN[i] * k;
		k = k * 2;
	}

	return DEC;
}
//8进制转换为十进制
int conversion8to10(int N) {
	int OCT = N;
	int temp = 0, DEC = 0;
	for (int i = 1; OCT > 0; i = i * 8) {
		temp = OCT % 10;
		OCT = OCT / 10;
		DEC = DEC + i * temp;
	}
	return DEC;

}
//16进制转换为十进制
int conversion16to10(char HEX[], int HEXlen) {
	int temp, k = 1, DEC = 0;
	for (int i = HEXlen -1; i >= 0; i--) {
		switch (HEX[i]) {
		case '0':temp = 0; break;
		case '1':temp = 1; break;
		case '2':temp = 2; break;
		case '3':temp = 3; break;
		case '4':temp = 4; break;
		case '5':temp = 5; break;
		case '6':temp = 6; break;
		case '7':temp = 7; break;
		case '8':temp = 8; break;
		case '9':temp = 9; break;
		case 'A':temp = 10; break;
		case 'B':temp = 11; break;
		case 'C':temp = 12; break;
		case 'D':temp = 13; break;
		case 'E':temp = 14; break;
		case 'F':temp = 15; break;
		default:break;
		}

		DEC = DEC + k * temp;
		k = k * 16;
	}
	return DEC;
}

//10进制转换为8进制
int conversion10to8(int N) {
	int DEC = N;
	int OCT = 0, temp = 0;
	for (int i = 1; DEC > 0; i = i * 10) {
		temp = DEC % 8;
		DEC = DEC / 8;
		OCT = OCT + temp * i;
	}

	return OCT;
}
//10进制转换为16进制
char *conversion10to16(int N, int &HEXlen) {
	int DEC = N, i;
	char *HEX = (char*)malloc(sizeof(char) * 10), temp;
	for (i = 0; DEC > 0; i++) {
		switch (DEC % 16)
		{
		case 0:temp = '0'; break;
		case 1: temp = '1'; break;
		case 2: temp = '2'; break;
		case 3: temp = '3'; break;
		case 4: temp = '4'; break;
		case 5: temp = '5'; break;
		case 6: temp = '6'; break;
		case 7: temp = '7'; break;
		case 8: temp = '8'; break;
		case 9: temp = '9'; break;
		case 10: temp = 'A'; break;
		case 11: temp = 'B'; break;
		case 12: temp = 'C'; break;
		case 13: temp = 'D'; break;
		case 14: temp = 'E'; break;
		case 15: temp = 'F'; break;
		default:
			break;
		}
		DEC = DEC / 16;
		HEX[i] = temp;

		int len = sizeof(HEX) / sizeof(HEX[0]);
		if ((i + 1) > len) {
			HEX = (char*)realloc(HEX, 2 * len * sizeof(char));
		}
	}

	HEXlen = i;
	reverseArray(HEX, HEXlen);
	return HEX;
}
//10进制转换为2进制
int *conversion10to2(int N, int &BINlen) {
	int DEC = N;
	int i;//遍历指针
	int *BIN = (int*)calloc(sizeof(int),8);
	for (i = 0; DEC > 0; i++) {
		BIN[i] = DEC % 2;
		DEC = DEC / 2;
		//当2进制数组不足时，用来扩容
		int len = sizeof(BIN) / sizeof(BIN[0]);
		if ((i + 1) > len) {
			BIN = (int*)realloc(BIN, 2 * len*sizeof(int));
		}
	}
	BINlen = i;
	reverseArray(BIN, BINlen);
	return BIN;
}

//2进制转换为16进制
char *conversion2to16(int BIN[], int BINlen, int &HEXlen) {
	//char *HEX;
	//int DEC = conversion2to10(BIN, n);
	//HEX = conversion10to16(DEC, HEXlen);
	//return HEX;
	return conversion10to16(conversion2to10(BIN, BINlen), HEXlen);
}
//2进制转换为8进制
int conversion2to8(int BIN[], int BINlen) {
	//int DEC = conversion2to10(BIN, n);
	//int OCT = conversion10to8(DEC);
	//return OCT;
	return conversion10to8(conversion2to10(BIN, BINlen));
}

//8进制转换为2进制
int *conversion8to2(int N, int &BINlen) {
	//int DEC = conversion8to10(N);
	//int *BIN = conversion10to2(DEC, BINlen);
	//return BIN;
	return conversion10to2(conversion8to10(N), BINlen);
}
//8进制转换为16进制
char *conversion8to16(int N, int &HEXlen) {
	//int DEC = conversion8to10(N);
	//char *HEX = conversion10to16(DEC, HEXlen);
	//return HEX;
	return conversion10to16(conversion8to10(N), HEXlen);
}

//16进制转换为2进制
int *conversion16to2(char HEX[], int HEXlen,int &BINlen) {
	//int DEC = conversion16to10(HEX, HEXlen);
	//int *BIN = conversion10to2(DEC, BINlen);
	//return BIN;
	return conversion10to2(conversion16to10(HEX, HEXlen), BINlen);
}
//16进制转换为8进制
int conversion16to8(char HEX[], int HEXlen) {

	//int DEC = conversion16to10(HEX, n);
	//int OCT = conversion10to8(DEC);
	//return OCT;
	return conversion10to8(conversion16to10(HEX, HEXlen));
}