用C++编写Int函数

用C++编写Int函数来实现基本运算如下:

#include <iostream>
using namespace std;

class Int
{
public:
	Int(int i=0):m_i(i)
	{}
	~Int()
	{}
	Int& operator++()                             //前置++
	{
		m_i++;
		return *this;
	}
	Int operator++(int)                           //后置++
	{
		//Int tmp(m_i);
		//m_i++;
		//return tmp;
		return Int(m_i++);
	}
	Int& operator--()                             //前置--
	{
		m_i--;
		return *this;
	}
	Int  operator--(int)                          //后置--
	{
		return Int(m_i--);
	}
	Int  operator-()                              // -a
	{
		return -m_i;
	}
	Int  operator+()                              //+a
	{
		return +m_i;
	}
	Int  operator+(const Int &I)                  //m_i+I.m_i
	{
		return m_i + I.m_i;
	}
	Int  operator-(const Int &I)                  //m_i-I.m_i
	{
		return m_i - I.m_i;
	}
	Int  operator*(const Int &I)                  //m_i*I.m_i
	{
		return m_i * I.m_i;
	}
	Int  operator/(const Int &I)                  //m_i/I.m_i
	{
		return m_i / I.m_i;
	}
	Int  operator+=(const Int &I)                 //m_i+=I.m_i
	{
		m_i = m_i + I.m_i;
		return *this;
	}
	Int  operator+=(const int &x)                 //m_i+=x
	{
		m_i = m_i + x;
		return *this;
	}
	Int  operator-=(const Int &I)                 //m_i-=I.m_i
	{
		m_i = m_i - I.m_i;
		return *this;
	}
	Int  operator-=(const int &x)                 //m_i-=x
	{
		m_i = m_i - x;
		return *this;
	}
	Int  operator*=(const Int &I)                 //m_i*=I.m_i
	{
		m_i = m_i * I.m_i;
		return *this;
	}
	Int  operator*=(const int &x)                 //m_i*=x
	{
		m_i = m_i * x;
		return *this;
	}
	Int  operator/=(const Int &I)                 //m_i/=I.m_i
	{
		m_i = m_i / I.m_i;
		return *this;
	}
	Int  operator/=(const int &x)                 //m_i/=x
	{
		m_i = m_i / x;
		return *this;
	}
	Int  operator%(const Int &I)                  //m_i%I.m_i
	{
		return m_i % I.m_i;
	}
	Int  operator%(const int &x)                  //m_i%x
	{
		return m_i % x;
	}
	Int  operator^(const Int &I)                  //m_i^I.m_i
	{
		return m_i ^ I.m_i;
	}
	Int  operator^(const int &x)                  //m_i^x
	{
		return m_i ^ x;
	}
	Int  operator|(const Int &I)                  //m_i|I.m_i
	{
		return m_i | I.m_i;
	}
	Int  operator&(const Int &I)                  //m_i&I.m_i
	{
		return m_i & I.m_i;
	}
	Int operator!()                               //!m_i
	{
		return !m_i;
	}
	Int  operator~()                              //~m_i
	{
		return ~m_i;
	}
	bool operator==(const Int &I)                 //m_i == I.m_i
	{
		if(m_i == I.m_i)
		{
			return true;
		}
		else
		{
			return false;
		}
	}
	bool operator!=(const Int &I)                 //m_i != I.m_i
	{
		if(m_i != I.m_i)
		{
			return true;
		}
		else
		{
			return false;
		}
	}
	bool operator>(const Int &I)                  //m_i > I.m_i
	{
		if(m_i > I.m_i)
		{
			return true;
		}
		else
		{
			return false;
		}
	}
	bool operator<(const Int &I)                  //m_i < I.m_i
	{
		if(m_i < I.m_i)
		{
			return true;
		}
		else
		{
			return false;
		}
	}
	bool operator>=(const Int &I)                  //m_i >= I.m_i
	{
		if(m_i >= I.m_i)
		{
			return true;
		}
		else
		{
			return false;
		}
	}
	bool operator<=(const Int &I)                  //m_i <= I.m_i
	{
		if(m_i <= I.m_i)
		{
			return true;
		}
		else
		{
			return false;
		}
	}
	Int operator>>(const Int &I)                   //m_i>>I.m_i
	{
		return m_i>>I.m_i;
	}
	Int operator<<(const Int &I)                   //m_i<<I.m_i
	{
		return m_i<<I.m_i;
	}
	Int operator>>=(const Int &I)                  //m_i>>=I.m_i
	{
		m_i = m_i>>I.m_i;
		return m_i;
	}
	Int operator<<=(const Int &I)                  //m_i<<=I.m_i
	{
		m_i = m_i<<I.m_i;
		return m_i;
	}
	void Show()                                    //显示
	{
		cout<<m_i<<endl;
	}
private:                                           //私有成员
	int m_i;
};

void main()                                        //测试函数
{
	Int i(5);
	Int j(5);
	Int x ;
	x = ++i;
    x.Show();
	x = i++;
	x.Show();
	x = --j;
	x.Show();
	x =j--;
	x.Show();

	Int n;
	n = 6;
	n = +n;
	n.Show();
	n = -n;
	n.Show();

	Int i1(4);
	Int j1(2);
	Int m;
    m = i1+j1;
    m.Show();
    m = i1-j1;
    m.Show();
	m = i1*j1;
	m.Show();
	m = i1/j1;
	m.Show();

	int q = 2;

	Int i2(2);
	Int j2(1);

    i2 += j2;
	i2.Show();
	i2 += q;
	i2.Show();
	i2 -= j2;
	i2.Show();
	i2 -= q;
	i2.Show();
	i2 *= j2;
	i2.Show();
	i2 *= q;
	i2.Show();
	i2 /= j2;
	i2.Show();
	i2 /= q;
	i2.Show();

	Int a;
	a = i1 % j1;
	a.Show();
	a = i1 % q;
	a.Show();
	a = i1 & j1;
	a.Show();
	a = i1 | j1;
	a.Show();
	a = i1 ^ j1;
	a.Show();
	a = i1 ^ q;
	a.Show();
	a = ~i1;
	a.Show();
	a = !i1;
	a.Show();

	if(i1 != j1)
	{
		cout<<"i1不等于j1"<<endl;
	}
	else if(i1 > j1)
	{
		cout<<"i1大于j1"<<endl;
	}
	else if(i1 < j1)
	{
		cout<<"i1小于j1"<<endl;
	}
	else
	{
		cout<<"i1等于j1"<<endl;
	}

	if(i1 >= j1)
	{
		cout<<"i1大于等于j1"<<endl;
	}
	else if(i1 <= j1)
	{
		cout<<"i1小于等于j1"<<endl;
	}

	Int s;
	s = i2<<j2;
	s.Show();
	s = i2>>j2;
	s.Show();
	i2 <<= j2;
	i2.Show();
	i2 >>= j2;
	i2.Show();
}

有不足的地方希望大家可以指出,我会虚心改正,谢谢大家~

时间: 2025-01-04 22:53:04

用C++编写Int函数的相关文章

【C语言】编写一个函数,传入a,b两个int类型的变量,返回两个值的最大公约数。

/*编写一个函数,传入a,b两个int类型的变量,返回两个值的最大公约数. 例如:输入传入(0 , 5)函数返回5,传入(10 , 9)函数返回1,传入(12 , 4)函数返回4 */ #include <stdio.h> int yue(int a,int b) { int temp; int n; if (a>b) { temp=a; a=b; b=temp; } n=a; if(a==0) return b; else while(n!=0) { if( a%n==0 &&

【C语言】编写一个函数,将一个数字字符串转换成该字符串对应的数字(包括正整数、负整数)

/* 编写一个函数,将一个数字字符串转换成该字符串对应的数字(包括正整数.负整数) 例如:"12" 返回12 "-123" 返回-123 函数原型:int my_atof(char *str) */ #include <stdio.h> int my_atof(char *str) { int flag=0; int m=0; if(*str=='-') { flag=1; str++; } while(*str!='\0') { if(*str<

用 void* 编写泛型函数

1.泛型交换 //1.编写int类型的swap void swap(int *vp1, int *vp2) { int a = *vp1; *vp1 = *vp2; *vp2 = *vp1; } //2.引申至泛型swap void swap(void *vp1, void *vp2, int size){ char buffer[size]; memcpy(buffer, vp1, size); memcpy(vp1, vp2, size); memcpy(vp2, buffer, size)

【c语言】编写一个函数reverse_string(char * string)(递归实现) 实现:将参数字符串中的字符反向排列。

/*编写一个函数reverse_string(char * string)(递归实现) 实现:将参数字符串中的字符反向排列. 要求:不能使用C函数库中的字符串操作函数.*/ #include <stdio.h> #include <assert.h> void reverse_string(char const * string) { assert( string != NULL ); if( *string != '\0' ) { string++; reverse_string

编写一个函数char_contains(char str[],char c), 如果字符串str中包含字符c则返回数值1,否则返回数值0

/* 编写一个函数char_contains(char str[],char c), 如果字符串str中包含字符c则返回数值1,否则返回数值0 */ #include <string.h> #include <stdio.h> // 可读性 -> 性能 -> 精简(重构) int char_contains(char str[], char c); int main() { //int result = char_contains("itc8ast"

编写一个函数reverse_string(char * string)(递归实现)

编写一个函数reverse_string(char * string)(递归实现) 实现:将参数字符串中的字符反向排列. 要求:不能使用C函数库中的字符串操作函数. #include<stdio.h> #include<assert.h> #include<stdlib.h> int my_strlen(const char*str) { assert(str); int count = 0; while (*str) { count++; str++; } retur

当自己编写copying函数的时候要负责手动将每一个成员都拷贝

结论1:如果自己编写copying函数则编译器就不会再为你自动生成,如果新追加一个成员变量,但是忘记在copying函数中追加这个变量的拷贝行为,这样编译器不会提示任何错误和警告信息,但是新变量不会被拷贝.因此如果追加新的成员变量,必须记住手动为该成员变量实现copying操作. 代码段1.1:Customer.h文件 #ifndef CUSTOMER_H #define CUSTOMER_H #include <string> #include "Date.h" clas

【c语言】 编写一个函数实现n^k,使用递归实现

//编写一个函数实现n^k,使用递归实现 #include <stdio.h> int cifang( int x, int y )//2^3=2*2*2 { int sum = 0; if( y == 0 ) sum = 1; else sum = x * cifang( x, ( y - 1 ) ); return sum; } int main() { printf("%d\n",cifang( 2,0 )); printf("%d\n",cifa

编写一个函数将参数字符串中的字符反向排列

编写一个函数reverse_string(char * string)(递归实现) 实现:将参数字符串中的字符反向排列. 要求:不能使用C函数库中的字符串操作函数. 注意:将参数字符串中的字符反向排列,不是反向输出. 代码如下: #include<stdio.h> #include<stdlib.h> #include<assert.h> int my_strlen(char *str)//求字符串长度 { int count=0; while(*str++) { co