AHU-C++（一）--函数的设计

实验内容与要求：

本次实验中，要求大家用模块化程序设计方法，编程模拟一个4bit加法器。一个4bit加法器由4个1bit全加器A1串联组成，如图1所示，那么两个4比特数：X=X1X2X3X4,Y=Y1Y2Y3Y4,求和过程为

一个1bit全加器可以由两个1bit半加器以及一个或门构成（如图2所示）。假设用A0表示1bit半加器，OR表示或门，A1表示1bit全加器，那么A1的运算过程为：

一个1bit半加器可以由一个异或门XOR与一个与门AND构成（如图3所示），半加器的运算过程为：

下面的代码定义了一个四比特数X，并初始化为0110：

FOUR X={Zero,One,One,Zero};

下面的代码将X修改为1010：

X[0] = Zero;

X[1] = One;

3）编写一个函数，在控制台上输出一个四比特数。输出格式为：X[1]X[2]X[3]X[4]，例如FOUR X={Zero,One,One,Zero};输出为0110。

4）编写三个函数，分别实现与门，或门以及异或门。函数的参数与返回值均为BIT类型。

5）编写一个函数，实现1bit半加器。注意半加器的运算结果是两个BIT类型的数据，即：和与进位。要求通过调用异或门和与门实现。

6）编写一个函数，实现1bit全加器。注意全加器的运算数包括3个BIT类型的数据，分别是两个运算数X,Y以及前一位的进位C。输出包括两个BIT类型的数据，即：和与进位。要求通过调用1bit半加器以及或门实现。

7)编写一个函数，参数包括两个运算数X,Y以及进位Cout，通过调用全加器计算X,Y的求和结果S

与进位Cout，并在控制台上输出一行，显示运算数以及运算结果，输出依次为Cin,X,Y,S,Cout。

8）编写一个测试1bit全加器的函数，在该函数中使用所有可能的X,Y,Cin来测试1bit全加器，并调用7）中的函数输出结果。该函数在控制台上的输出应如下图所示：

9）编写一个函数实现4bit加法器，函数的参数是两个FOUR类型的数据X,Y,以及一个BIT类型的数据表示进位Cin,函数的计算结果为一个FOUR类型的数据S以及产生的进位Cout。

10）编写一个函数，该函数使用一个测试用例来测试4比特加法器，函数的参数是两个FOUR类型的数据，表示运算数X,Y。该函数通过调用4比特加法器，计算X+Y的和S以及进位Cout，并在控制台上输出一行，格式为X,Y, S, Cout。

11)编写一个函数，用于测试4bit加法器，该函数通过调用10）中的函数，使用多个不同的测试用例测试4比特加法器。请使用以下测试用例(假设进位Cin=Zero)：

分析：

        实质上本题抛去一系列复杂的涉及数字逻辑的知识，归根到底，就是与、或、非、异或等等的基础函数运算，配合上递归进行解题，对于返回两个值，一个C进位，一个S和，我采取返回数组的形式，达到一次返回多个值的目的

源代码：

​
#include<iostream>
using namespace std;
typedef enum BIT
{
	Zero, One
}BIT;


BIT And(BIT& x, BIT& y)
{
	if (x && y)
	{
		return One;
	}
	else
	{
		return Zero;
	}
}

BIT Or(BIT& x, BIT& y)
{
	if (x || y)
	{
		return One;
	}
	else
	{
		return Zero;
	}
}

BIT Xor(BIT& x, BIT& y)
{
	if ((x== One&&y== Zero)|| (x == Zero && y == One))
	{
		return One;
	}
	else
	{
		return Zero;
	}
}

BIT* HA(BIT& x, BIT& y)
{
	BIT result[2];
	BIT S = Xor(x, y);
	BIT C = And(x, y);
	result[0] = C;
	result[1] = S;
	return result;
}

BIT* FA(BIT& x, BIT& y, BIT& Cin)
{

	BIT* one =HA(x, y);
	BIT C1 = one[0];
	BIT S1 = one[1];
	BIT* two = HA(S1, Cin);
	BIT C2 = two[0];
	BIT S = two[1];
	BIT C = Or(C1, C2);
	BIT result[2] = { C,S };
	return result;
}

void FAPrint(BIT& x, BIT& y, BIT& Cin)
{
	BIT* one = FA(x,y, Cin);
	BIT  Cout = one[0];
	BIT  S = one[1];
	cout << " " << Cin <<"   " << x << "  " << y << "   " << S << "    " << Cout << endl;
}

void FBPrint(BIT X[4])
{
	cout << X[0] << X[1]  << X[2] << X[3] <<"  ";
}

BIT* FBFA(BIT x[4], BIT y[4], BIT& Cin)
{
	BIT* one = FA(x[3], y[3],Cin);
	BIT C4 = one[0];
	BIT S4 = one[1];
	BIT* two = FA(x[2], y[2], C4);
	BIT C3 = two[0];
	BIT S3 = two[1];
	BIT* three = FA(x[1], y[1], C3);
	BIT C2 = three[0];
	BIT S2 = three[1];
	BIT* four = FA(x[0], y[0], C2);
	BIT Cout = four[0];
	BIT S1 = four[1];
	BIT CS[5] = { Cout, S1,S2,S3,S4 };
	return CS;
}

void FBFAPrint(BIT x[4], BIT y[4], BIT& Cin)
{
	BIT* one = FBFA(x, y, Cin);
	BIT  Cout = one[0];
	BIT  S1 = one[1];
	BIT  S2 = one[2];
	BIT  S3 = one[3];
	BIT  S4 = one[4];
	FBPrint(x);
	FBPrint(y);
	cout <<S1<<S2<<S3<<S4<<"  " <<Cout<< endl;
}

int main()
{
	cout << "sunset" << endl;
	BIT X[4] = { Zero,One,One,Zero };
	X[0] = Zero;
	X[1] = One;
	cout << "Cin  " << "x  " << "y  " << "x+y  " << "Cout  " << endl;
	FAPrint(X[0], X[0], X[0]);
	FAPrint(X[0], X[1], X[0]);
	FAPrint(X[1], X[0], X[0]);
	FAPrint(X[1], X[1], X[0]);
	FAPrint(X[0], X[0], X[1]);
	FAPrint(X[0], X[1], X[1]);
	FAPrint(X[1], X[0], X[1]);
	FAPrint(X[1], X[1], X[1]);
	cout << endl;
	cout  << " x  " << "   y  " << "   S  " << " Cout  " << endl;
	BIT Y[4] = {Zero,Zero,One,One};
	BIT Z[4] = {One,Zero,One,Zero };
	FBFAPrint(Y, Z, X[0]);
	BIT YY[4] = {One,Zero,One,One };
	FBFAPrint(YY, Z, X[0]);
	BIT XX[4] = { Zero,Zero,One,Zero };
	FBFAPrint(YY, XX, X[0]);
	BIT ZZ[4] = { One,One,One,One };
	BIT P[4] = { Zero,One,One,Zero };
	FBFAPrint(ZZ, P, X[0]);
	return 0;
}

​

运行截图：