CPU加减乘除布斯算法

#ifndef __MODEL__H__
#define __MODEL__H__

#ifdef _MSC_VER
	#if _MSC_VER > 1000
		#pragma once
	#endif
#endif

#include <bitset>//for bitset
#include <cstddef>//for size_t
#include <algorithm>//for min
#include <stdexcept>

const std::size_t BIT8	= 8u;
const std::size_t BIT16 = 16u;
const std::size_t BIT32 = 32u;
const std::size_t BIT64 = 64u;

class cpu_model{
	typedef std::bitset<BIT8>   resister8;
	typedef std::bitset<BIT16>  register16;
	typedef std::bitset<BIT32>  register32;
	typedef std::bitset<BIT64>	register64;
public:
	cpu_model();
	cpu_model(const cpu_model&) = delete;
	cpu_model& operator =(const cpu_model&) = delete;
	~cpu_model() = default;
public:
	void clear();
	const register32& plus(const register32&, const register32&);
	const register32& sub(const register32&, const register32&);
	const register64& mult(const register32&, const register32&);
	const register32& div(const register32&, const register32&);
private:
	const register32 negative(const register32&);
private:
	bool m_flag;
	register32 m_lhs;
	register32 m_rhs;
	register32 m_ax;
	register32 m_bx;
	register32 m_tmp;
	register64 m_mult;
};



#endif

#include "model.h"

cpu_model::cpu_model()
	:m_flag(false){
}

void cpu_model::clear(){
	m_lhs.reset();
	m_rhs.reset();
	m_ax.reset();
	m_flag = false;
	m_bx.reset();
	m_tmp.reset();
}

const std::bitset<BIT32>& cpu_model::plus(const register32& lhs, const register32& rhs){
	m_lhs = lhs;
	m_rhs = rhs;
	bool flag = false;//为了进位
	std::size_t index = 0u;
	for (std::size_t i = 0u; i != m_rhs.size(); ++i){
		if (m_lhs[i] && m_rhs[i]){//如果相同且为1，那么就需要进位
			if (!flag) m_lhs[i] = ~m_lhs[i];
			flag = true;//标志设为1
		}
		else{
			m_lhs[i] = m_lhs[i] ^ m_rhs[i];
			if (flag) m_lhs[i] = ~m_lhs[i];
			if (m_lhs[i]) flag = false;//当为0的时候，取反为1，此时不在需要对后面的操作也进位
		}
	}
	return m_lhs;
}

const std::bitset<BIT32>& cpu_model::sub(const register32& lhs, const register32& rhs){
	register32 tmp = negative(rhs);//先取反
	return plus(lhs,tmp);//后加1便得到相反数
}

const std::bitset<BIT32> cpu_model::negative(const register32& item){
	register32 res(item);
	res.flip();
	return plus(res, register32(1));
}


const std::bitset<BIT64>& cpu_model::mult(const register32& lhs, const register32& rhs){
	this->clear();
	m_bx = rhs;
	bool back;
	for (std::size_t i = 0; i != rhs.size(); ++i){
		if (m_bx[0] && !m_flag){
			m_ax = sub(m_ax, lhs);
		}
		else if (!m_bx[0] && m_flag){
			m_ax = plus(m_ax, lhs);
		}
		back = m_ax[BIT32 - 1];
		//移位
		m_flag = m_bx[0];
		m_bx >>= 1;
		m_bx[BIT32 - 1] = m_ax[0];
		m_ax >>= 1;
		m_ax[BIT32 - 1] = back;
	}
	m_mult = m_ax.to_ulong();
	register64 tmp = m_bx.to_ulong();
	m_mult <<= BIT32;
	m_mult |= tmp;
	return m_mult;
}

const std::bitset<BIT32>& cpu_model::div(const register32& lhs, const register32& rhs){
	if (!rhs.to_ulong()) throw std::invalid_argument("");
	if (lhs.to_ulong() < rhs.to_ulong()) return (m_ax = 0);
	clear();
	m_bx = lhs;
	m_rhs = negative(rhs);
	for (std::size_t i = 0; i != rhs.size(); ++i){
		m_ax <<= 1;
		m_ax[0] = m_bx[BIT32 - 1];
		m_bx <<= 1;
		m_tmp = plus(m_ax, m_rhs);
		m_bx[0] = ~m_tmp[BIT32 - 1];
		if (m_bx[0]) m_ax = m_tmp;
	}
	return m_bx;
}


#include "model.h"
#include <iostream>


int main(int argc, char* argv[])
{
	cpu_model test;
	std::cout << test.div(std::bitset<32>(7), std::bitset<32>(1));
//	std::cout << test.sub(std::bitset<32>(0), std::bitset<32>(2));
	system("pause");
	return 0;
}