C++运算符重载典型习题---复数类 String类 分数类

最新推荐文章于 2023-03-03 22:21:45 发布
最新推荐文章于 2023-03-03 22:21:45 发布
阅读量355 收藏
点赞数
分类专栏： c++程序设计基础 文章标签： 运算符重载
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43142013/article/details/96203349
版权

一、复数类(Complex class)

complex.cpp：

/*****************************************************
copyright (C), 2019-2020, Lighting Studio. Co.,     Ltd. 
File name：
Author：xozofunny    Version:0.1    Date: 
Description：
Funcion List: 
*****************************************************/

#include <iostream>
using namespace std;

class Complex{
private:
    float m_real;
    float m_imag;

public:
    
    Complex():m_real(0), m_imag(0){}
    Complex(float a, float b)
    {
        m_real = a;
        m_imag = b;
    }
    ~Complex(){}
    
    //以成员函数重载+
    Complex operator+(Complex &obj);
    Complex operator-(Complex &obj);
    Complex operator*(Complex &obj);
    Complex operator/(Complex &obj);
    
    //重载输入输出流只能用友元函数
    friend ostream& operator<<(ostream& out, Complex& obj);
    friend istream& operator>>(istream& in, Complex& obj);
	
    void show();

};

Complex Complex :: operator+(Complex &obj)//复数相加
{
    Complex tmp;
    tmp.m_real = m_real + obj.m_real;
    tmp.m_imag = m_imag + obj.m_imag;

    return tmp;
}

Complex Complex :: operator-(Complex &obj)//复数相减
{
    Complex tmp;
    tmp.m_real = m_real - obj.m_real;
    tmp.m_imag = m_imag - obj.m_imag;
    
    return tmp;
}

Complex Complex :: operator*(Complex &obj)//复数相乘
{
    Complex tmp;
    tmp.m_real = (m_real * obj.m_real) - (m_imag * obj.m_imag);
    tmp.m_imag = (m_imag * obj.m_real) + (m_real * obj.m_imag);
    
    return tmp;
}

Complex Complex:: operator/(Complex &obj)//复数相除
{
    Complex tmp;
    tmp.m_real = (((m_real * obj.m_real) + (m_imag * obj.m_imag)) / ((obj.m_real * obj.m_real) + (obj.m_imag * obj.m_imag)));
    tmp.m_imag = (((m_imag * obj.m_real) - (m_real * obj.m_imag)) / ((obj.m_real * obj.m_real) + (obj.m_imag * obj.m_imag)));

    return tmp;
}

void Complex :: show()//默认的public成员函数
{
    cout<<"result is "<<m_real<<"+"<<"j"<<m_imag<<endl;
}

//重载的输出流， 可以直接用来输出一个对象
ostream& operator<<(ostream& out, Complex& obj)//重载<<运算符
{
	if(obj != NULL)
		out<<obj.m_real<<" "<<"+"<<" "<<obj.m_imag<<"i";
	return out;
}

istream& operator>>(istream& in, Complex& obj)//重载>>运算符
{
    in>>obj.m_real>>obj.m_imag;
    return in;
}

int main()
{
    Complex obj1(2,3);
//两者占用不同的内存空间
    Complex obj2(4,5);

    Complex obj3 = obj1 + obj2;
    obj3.show();

    obj3 = obj2 - obj1;
    obj3.show();
	
    obj3 = obj2 * obj1;
    //obj3.show();
    cout<<obj3<<endl;

    obj3 = obj1 / obj2;
    //obj3.show();
    cout<<obj3<<endl;
	
    return 0;
}

 

测试结果：

二、string类

my_string.h

#ifndef __MYSTRING_H__
#define __MYSTRING_H__
 
#include <iostream>
using namespace std;
 
class MyString
{
    friend ostream & operator<<(ostream& out, const MyString& str);
    friend istream & operator>>(istream& in, MyString& str);
public:
	MyString();
    MyString(int len);
    MyString(const char *p);
    MyString(const MyString & str);
    ~MyString();
 
public:
    MyString& operator=(const char *p);
    MyString& operator=(MyString &str);
 
    char& operator[](const int index);
 
    bool operator==(const char *p) const;
    bool operator==(const MyString& str) const;
    bool operator!=(const char *p) const;
    bool operator!=(const MyString& str) const;
 
    bool operator<(const char *p) const;
    bool operator<(const MyString& str) const;
    bool operator>(const char *p) const;
    bool operator>(const MyString& str) const;
 
public:
    char *c_str()
    {
        return m_p;
    }
    const char *c_str2()
    {
        return m_p;
    }
 
    int length()
    {
        return m_len;
    }
 
private:
    int m_len;//字符串长度
    char *m_p;//所指字符串
};
 
 
#endif

my_string.cpp

#include "my_string.h"

MyString::MyString()//构造1,意旨只创建一个基对象,采用了默认参数
{
    cout<<"Default constructor was called"<<endl;
    m_len = 0;
    m_p = NULL;//它没有任何堆空间可言
}

MyString::MyString(int len)//告诉它默认分配一个固定的大小
{
    cout<<"Costum1 constructor was called"<<endl;
    m_len = len;
    m_p = new char[m_len];
}
MyString::MyString(const char *p)//给它初始化一个字符串
{
    cout<<"Costum2 constructor was called"<<endl;
    m_len = strlen(p);
    m_p = new char[m_len + 1];
    memcpy(m_p, p, m_len);
}
MyString::MyString(const MyString & str)//拷贝构造
{
    cout<<"Deepcopy constructor was called"<<endl;
    m_len = str.m_len;
    m_p = new char[m_len];
    memcpy(m_p, str.m_p, m_len*sizeof(char));
}

MyString::~MyString()//析构
{
    cout<<"Destructor was called"<<endl;
    delete[] m_p;
    m_len = 0;
    m_p = NULL;
}

//以全局变量创建的
//仅当当用一个对象输出时有效
ostream& operator<<(ostream& out, const MyString& str)
{
    if(str.m_p != NULL)
	out << str.m_p << ". and the length is:" << str.m_len;
    return out;
}

//仅当用一个对象输入时有效
//比如：MyString str;
//     cin>>str;//阻塞态
istream& operator>>(istream& in, MyString& str)
{
    char buf[255] = {0};//给它规定一个行缓冲,当且仅当用户输入回车时刷新
    in>>buf;
	
    if(buf != NULL)
    {
	str.m_len = strlen(buf);
	str.m_p = new char[str.m_len+1];
	memset(str.m_p, 0, sizeof(str.m_p));
	memcpy(str.m_p, buf, str.m_len);
    }
	
    return in;
}

//以成员函数重载
MyString& MyString:: operator=(const char *p)//将一个对象初始化为字符串常量
{
    if(m_p != NULL)
    {
	delete[] m_p;
	m_p = NULL;
	m_len = 0;
    }
    m_len = strlen(p);
    m_p = new char[m_len + 1];
    memcpy(m_p, p, m_len);

    return *this;
}

//使用一个已有的对象赋值给另一个新的对象, 初始化则调用拷贝构造
//例:MyString str2(str1);
MyString& MyString:: operator=(MyString &str)
{
    if(m_p != NULL)
    {
	delete[] m_p;
	m_p = NULL;
	m_len = 0;
    }
    m_len = str.length();//先计算相应的长度
    m_p = new char[m_len + 1];
    memcpy(m_p, str.c_str2(), m_len);

    return *this;
}

//以对象的形式下标访问相应的指定字符串
char& MyString:: operator[](const int index)
{
    if(index < 0 || index >= m_len)
    {
	cout<<"数组越界错误"<<endl;
	exit(-1);
    }
    return m_p[index];
}

/*****************************************
const表示不可对对象内存中的数据作任何改变
功能:判断两个字符串是否相等
******************************************/
bool MyString::operator==(const char *p) const
{
    if((size_t)m_len == (size_t)strlen(p))
    {
	if((strcmp(m_p, p) == 0))
	    return 1;
	else
	    return 0;
    }
    else
	return 0;
}

bool MyString::operator==(const MyString& str) const
{
    if(m_len == str.m_len)
    {
	if((strcmp(m_p, str.m_p) == 0))
	    return 1;
	else
	    return 0;
    }
    else
	return 0;
}

//长度不等，字符串的内容肯定不等
bool MyString::operator!=(const char *p) const
{
    if(((size_t)m_len != (size_t)strlen(p)))
	return 1;
    else
	return 0;
}

bool MyString::operator!=(const MyString& str) const
{
    if(((size_t)m_len != (size_t)str.m_len))
	return 1;
    else
	return 0;
}

//满足即说明这两个字符串没什么好比的,因为长度都不一样
bool MyString::operator<(const char *p) const
{
    if(((size_t)m_len != (size_t)strlen(p)))
	return 0;
    else
    {
	if((strcmp(m_p, p) < 0))
	    return 1;
	else
	    return 0;
    }
}

bool  MyString::operator<(const MyString& str) const
{
    if(((size_t)m_len != (size_t)str.m_len))
	return 0;
    else
    {
	if((strcmp(m_p, str.m_p) < 0))
	    return 1;
	else
	    return 0;
    }
}


bool MyString::operator>(const char *p) const
{
    if(((size_t)m_len != (size_t)strlen(p)))
        return 0;
    else
    {
	if((strcmp(m_p, p) > 0))
	    return 1;
	else
	    return 0;
    }
}

bool MyString::operator>(const MyString& str) const
{
    if(((size_t)m_len != (size_t)str.m_len))
	return 0;
    else
    {
	if((strcmp(m_p, str.m_p) > 0))
	    return 1;
	else
	    return 0;
    }
}

test.cpp

#include "my_string.h"

int main()
{
    MyString str1 = "we well we well rock you";
    cout<<str1<<endl;
    MyString str2;
    str2 = str1;
    cout<<str2<<endl;
    cout<<endl;
	
    if(str2 == str1)
	cout<<"Matching Good!"<<endl;
    else
	cout<<"Dismatching!"<<endl;
    cout<<endl;
	
    cin>>str1;
    cin>>str2;
    MyString str3 = str2;//copyconstructor
    cout<<"str1 = "<<str1<<endl;
    cout<<"str2 = "<<str2<<endl;
    cout<<"str3 = "<<str3<<endl;

    cout<<"str2 = str1??"<<endl;
    if(str2 == str1)
	cout<<"Matching Good!"<<endl;
    else
	cout<<"Dismatching!"<<endl;
    cout<<"str2 > str1??"<<endl;
    if(str2 > str1)
	cout<<"Matching Good!"<<endl;
    else
	cout<<"Dismatching!"<<endl;
    cout<<"str2 < str1??"<<endl;
    if(str2 < str1)
	cout<<"Matching Good!"<<endl;
    else
	cout<<"Dismatching!"<<endl;
	
    return 0;
}

测试结果：

阻塞了：

现在开始输入hello world（注意中间有空格）

cin输入的流会将空格作为划分标志，我输入了一行，程序中下一行cin调用却不堵塞了，是因为我的缓冲区是行缓冲，下次读取时直接从缓冲区中读取一个字符串了。。 完现了 scanf("%s", str); 的功能。

C++实现分数类---实现分数的加减乘除，与比较赋值运算；

成员函数重载分数比较与运算, 全局函数借助成员函数重载完成整数与分数的比较与运算。

分子分母能够实现约分， 求倒数。

Grade.h

#ifndef _GRADE_H_
#define _GRADE_H_

#include <iostream>

using namespace std;

class Grade{
protected:
    int numerator;
    int denominator;
    int GCD(int a, int b = 1);//最大公约数

public:
    Grade();
    Grade(int a, int b);//构造
    ~Grade();//析构
//以成员函数的方式重载分数之间的运算
    Grade operator+(Grade& obj);
    Grade operator-(Grade& obj);
    Grade operator*(Grade& obj);
    Grade operator/(Grade& obj);
	
    Grade& operator=(const Grade& obj);//以成员函数形式重载赋值符号
    Grade& operator-();//重载单目运算符"-"

//重载分数之间的比较
    bool operator==(Grade& obj);
    bool operator!=(Grade& obj);
    bool operator>(Grade& obj);
    bool operator<(Grade& obj);
    bool operator>=(Grade& obj); 
    bool operator<=(Grade& obj);

	
//以全局函数重载输入输出流
    friend ostream& operator<<(ostream& obj, Grade& obj);
    friend istream& operator>>(istream& obj, Grade& obj);
//相关成员函数
    void Reduction();//约分
    void Redata();//倒数

//以全局函数的形式计算比较整数和分数
    friend Grade operator+(int a, Grade& obj);
    friend Grade operator-(int a, Grade& obj);
    friend Grade operator*(int a, Grade& obj);
    friend Grade operator/(int a, Grade& obj);

    friend bool operator==(int a, Grade& obj);
    friend bool operator!=(int a, Grade& obj);
    friend bool operator>(int a, Grade& obj);
    friend bool operator>=(int a, Grade& obj);
    friend bool operator<(int a, Grade& obj);
    friend bool operator<=(int a, Grade& obj);
	
};             

#endif

Grade.cpp

#include "Grade.h"

inline int ABS(int m)
{
    return (m >= 0 ? m : -m);
}

Grade::Grade()
{
    numerator = 0;
    denominator = 1;//不允许分母为0
    cout<<"Default constructor was called"<<endl;
}

Grade::Grade(int a, int b = 1)//构造
{
    if((a >= 0 && b > 0) || (a <= 0 && b< 0))
    {
	numerator = ABS(a);
	denominator = ABS(b);
    }
    else{
	numerator = -ABS(a);
	denominator = ABS(b);
    }
    cout<<"Costum constructor was called"<<endl;
}

//最大公约数不会大于两者之间最小的一个数
int Grade::GCD(int a, int b)
{
    if(a >= b)
    {
	for(int i = b; i > 0; i--)
	{
	    if(b%i == 0 && a%i == 0)
	    {
		return i;
		break;
	    }		
	}
    }
    else
    {
	for(int i = a; i > 0; i--)
	{
	    if(a%i==0 && b%i==0)
	    {
                return i;
		break;
	    }
	}
    }
}

Grade Grade::operator+(Grade& obj)
{
    Grade tmp;
    tmp.numerator = (this->numerator * obj.denominator)+(this->denominator * obj.numerator);
    tmp.denominator = this->denominator * obj.denominator;

    tmp.Reduction();//约分处理
    return tmp;
}

Grade Grade::operator-(Grade& obj)
{
    Grade tmp;
    tmp.numerator = (this->numerator * obj.denominator)-(this->denominator * obj.numerator);
    tmp.denominator = this->denominator * obj.denominator;

    tmp.Reduction();
    return tmp;
}
Grade Grade::operator*(Grade& obj)
{
    Grade tmp;
    tmp.numerator = this->numerator * obj.numerator;
    tmp.denominator = this->denominator * obj.denominator;

    tmp.Reduction();
    return tmp;
}
Grade Grade::operator/(Grade& obj)
{
    Grade tmp;
    tmp.numerator = this->numerator * obj.denominator;
    tmp.denominator = this->denominator * obj.numerator;

    tmp.Reduction();
    return tmp;
}

Grade& Grade::operator=(const Grade& obj)//以成员函数形式重载赋值符号
{
    this->numerator = obj.numerator;
    this->denominator = obj.denominator;

    return *this;
}

Grade& Grade::operator-()//重载单目运算符"-"
{
    numerator = -numerator;

    return *this;
}

bool Grade::operator==(Grade& obj)
{
    if((numerator*obj.denominator) == (denominator*obj.numerator))
	return 1;
    else
	return 0;
}

bool Grade::operator!=(Grade& obj)
{
    if((numerator*obj.denominator) != (denominator*obj.numerator))
	return 1;
    else
	return 0;
}

bool Grade::operator>(Grade& obj)
{
    if((numerator*obj.denominator) > (denominator*obj.numerator))
	return 1;
    else
	return 0;
}

bool Grade::operator>=(Grade& obj)
{
    if((numerator*obj.denominator) >= (denominator*obj.numerator))
	return 1;
    else
	return 0;
}


bool Grade::operator<=(Grade& obj)
{
    if((numerator*obj.denominator) <= (denominator*obj.numerator))
	return 1;
    else
	return 0;
}

bool Grade::operator<(Grade& obj)
{
    if((numerator*obj.denominator) < (denominator*obj.numerator))
	return 1;
    else
	return 0;
}


void Grade::Redata()//求倒数
{
    if(numerator > 0)
    {
	int tmp = numerator;
	numerator = denominator;
	denominator = tmp;
    }

    if(numerator < 0)
    {
	int tmp = numerator;
	numerator = -denominator;
	denominator = ABS(tmp);
    }
}

void Grade::Reduction()//约分,用来输出
{
    int gcd = GCD(ABS(numerator), ABS(denominator));
    if(gcd > 1)
    {
	denominator /= gcd;
	numerator /= gcd;
    }
//分子分母同时大于0，或者分子分母同时小于0
    if((numerator >= 0 && denominator > 0) || (numerator <= 0 && denominator < 0))
    {
        numerator = ABS(numerator);
	denominator = ABS(denominator);
    }
    else{
	numerator = -ABS(numerator);
	denominator = ABS(denominator);
    }
}

ostream& operator<<(ostream& out, Grade& obj)
{
    if(obj.numerator == 0)
	out<<"The Finally Fraction is："<<obj.numerator;
    else if(obj.denominator != 1)
	out<<"The Finally Fraction is："<<obj.numerator<<"/"<<obj.denominator;
    else
	out<<"The Finally Fraction is："<<obj.numerator;

    return out;
}

istream& operator>>(istream& in, Grade& obj)
{
    cout<<"input numerator"<<endl<<">>>:";
    cin>>obj.numerator;
    cout<<"input denominator"<<endl<<">>>:";
    cin>>obj.denominator;
    while(obj.denominator == 0)
    {
	cin>>obj.denominator;
    }

    if(obj.denominator < 0)
    {
	obj.numerator = -ABS(obj.numerator);
	obj.denominator = ABS(obj.denominator);
    }
    return in;
}

/**************************************************
全局的友元函数将会调用对象中重载过的运算符直接
将整形变量转换构造成相应的分母分子形式,分母的值
始终为1,两对象之间会调用上方的比较重载函数
*************************************************/
Grade operator+(int a, Grade& obj)
{
    return Grade(a)/*因为构造函数是默认参数*/ + obj; 
}

Grade operator-(int a, Grade& obj)
{
    return Grade(a) - obj;
}

Grade operator*(int a, Grade& obj)
{
    return Grade(a) * obj;
}

Grade operator/(int a, Grade& obj)
{
    return Grade(a) / obj;
}

bool operator==(int a, Grade& obj)
{
    return Grade(a) == obj;
}

bool operator!=(int a, Grade& obj)
{
    return Grade(a) != obj;
}

bool operator>(int a, Grade& obj)
{
    return Grade(a) > obj;
}

bool operator>=(int a, Grade& obj)
{
    return Grade(a) >= obj;
}

bool operator<(int a, Grade& obj)
{
    return Grade(a) < obj;
}

bool operator<=(int a, Grade& obj)
{
    return Grade(a) <= obj;
}


Grade::~Grade()//析构
{
    cout<<"Destructor was called"<<endl;
}

main.cpp

#include "Grade.h"

int main()
{
    Grade obj1(3,4);
    Grade obj2;
    int tmp = 7;

    cout<<"obj1 = "<<obj1<<endl;
    cin>>obj2;
    cout<<"obj2 = "<<obj2<<endl;

    Grade obj3 = obj1 + obj2;
    cout<<obj3<<endl;
    obj3 = obj1 - obj2;
    cout<<obj3<<endl;
    obj3 = obj1 * obj2;
    cout<<obj3<<endl;
    obj3 = obj1 / obj2;
    cout<<obj3<<endl;
    
    obj3 = tmp + obj1;
    cout<<obj3<<endl;
    obj3 = tmp - obj1;
    cout<<obj3<<endl;
    obj3 = tmp * obj1;
    cout<<obj3<<endl;
    obj3 = tmp / obj1;
    cout<<obj3<<endl;

    if(obj1 == obj2)
	cout<<"Matching!"<<endl;
    else
	cout<<"Sorry Dismatching!"<<endl;
    if(obj1 > obj2)
	cout<<"Matching!"<<endl;
    else
	cout<<"Sorry Dismatching!"<<endl;
    if(obj1 != obj2)
	cout<<"Matching!"<<endl;
    else
	cout<<"Sorry Dismatching!"<<endl;
	
	
    return 0;
}

Makefile

.PHONY : clean
cc = g++
CFLAGS =  -g -Wall
Target = main
BIN = Grade.o  main.o
$(Target) : $(BIN)
    $(cc) -o  $@  $^
%.o : %.cpp
    $(cc) $(CFLAGS) -c $< -o $@
clean:
    rm -f $(BIN)
    rm -i main

结果：

 

 

 

 

 

 

 

、

 

-浓烟下的诗歌电台
关注
专栏目录
C++实现String类实例代码
08-30
在C++编程中，实现String类是一个常见的练习题，旨在考查程序员对类的构造、析构以及赋值等行为的理解程度。通过对String类的实现，开发者可以加深对C++中类机制、动态内存管理、拷贝控制等概念的理解。 首先，C++...
string类中运算符重载的实现
u014253011的博客
05-29 3323
#include&lt;iostream&gt; using namespace std; class MyString { public: MyString(); MyString(const int number); MyString(const char *ptr); MyString(const MyString &amp;str); ~MySt...
C++ String类的实现
weixin_30809173的博客
11-21 94
#include <iostream> using namespace std; class mystring { public: mystring(); ~mystring(){} mystring(const char *str); mystring(mystring &str); mys...
C++中符号（运算符）重载
qq_43643506的博客
01-28 1096
全局函数与成员函数： 1、把全局函数转化成成员函数，通过this指针隐藏左操作数 Test add(Test &amp;t1, Test &amp;t2)=》Test add(Test &amp;t2) 2、把成员函数转换成全局函数，多了一个参数 void printAB()=》void printAB(Test *pthis) 3、函数返回元素和返回引用 Test&amp; add(Test &...
C++ MyString类的实现
han_lx_的博客
04-07 2893
功能要求： 功能1.0 初步实现MyString类（数据属性包括char*list，intlength（字符串长度）） 1.1. 实现构造函数（通过字符串初始化list） 1.2. 析构函数 1.3. 字符串拼接 1.4. 字符串比较大小（实现strcmp功能） 1.5. 子串查找 1.6. 提取某个位置字符 1.7. 输出。 功能2.0 2.1. 流输入>>和流输出<<运算符的重载 2.2. 重载 = 运算符 2.3. 重载 += 运算符 2...
用C++实现String类的四种构造和运算符重载
ai_keke的博客
07-29 252
（教学版本，main函数可以自己写） MyString.h   #ifndef __MYSTRING_H__ #define __MYSTRING_H__   #include &lt;iostream&gt; using namespace std;   class MyString {     friend ostream &amp; operator&lt;&lt;(o...
C++Primer（第4版）-课后习题答案.pdf
11-01
《C++ Primer（第4版）》是一本深入学习C++编程语言的经典教材，其课后习题答案提供了丰富的实践练习和问题解析，帮助读者巩固并深化对C++语法、概念的理解。以下将针对各章节的主要知识点进行详细阐述： 1. 第一章...
C和C++笔试题----不错的笔试参考资料
12-30
- 字符数组即字符串，需要了解C风格字符串（以空字符'\0'结束）和C++风格的string类。 8. **结构体与联合体**： - 结构体用于组合不同类型的数据，理解结构体的定义、初始化和成员访问。 - 联合体（union）则在...
运算符重载 PPT学习教案.pptx
10-11
最后，PPT中提到了一些练习题，如`String`类的`+=`运算符重载，以及`++`和`--`的重载。这些练习旨在帮助学习者深入理解运算符重载的实际应用和设计技巧。 总之，运算符重载是C++中提高代码可读性和灵活性的重要工具...
c++程序设计实验、辅导与习题解答-实验五.docx
11-08
8. **成员函数的字符串连接**：在类的成员函数中，可以使用C++标准库提供的`std::string`类的各种方法来连接字符串，如`append`或`+`运算符。 9. **递归函数**：递归函数是调用自身的函数，常用于解决分治策略的...
复数类的代码
10-07
VC++中的复数类，可以实现复数的+—*/倒数等运算。
C++程序设计 运算符重载实验（一）
04-03
C++程序设计实验——运算符重载，涉及单目、双目运算符的重载
模拟string类
bluebubble的专栏
05-04 498
做为学习重载的最佳练习，自己写了这个string类，请大家指正！//string.h#ifndef MyString_H#define MyString_H#include iostream>using namespace std;class MyString...{private:  char *data;  int length;public:  MyString();  ~MyStr
C++运算符重载题目练习
最新发布
qq_56243544的博客
03-03 466
c++重载练习题
[C++] 运算符重载练习题
qq_45418426的博客
06-08 2384
【20分】2. 四进制加法（运算符重载） 题目描述 定义一个四进制的类，重定义“+”号实现四进制数的累加。 提示 输入 第一行输入所需要的四进制数的个数 第二行开始，依次输入四进制数 输出 所有输入四进制数累加的和 示例输入 3 13 2 21 示例输出 102 示例代码 #include <iostream> #include <iomanip> #include <string> #include <cmath> using namespace std;
C++(10)——实现复数类和String类
青布衫白少年的博客
08-12 336
复数类 class CComplex { public: CComplex(int r = 0, int z = 0) :a(r),b(z) { } ~CComplex() { } CComplex operator+(const CComplex &com) { return CComplex(this->a + com.a,this->b + com.b); } void show() { cout << "实部：" <&lt
C++语言利用函数重载和运算符重载完成复数运算
Junhao's Blog
05-19 3607
文章目录1.重载是什么？(1).在C++中的函数重载(2).在C++中的运算符重载2.复数的相关知识（部分）(1).复数的定义和概念(2).复数的几何意义(3).复数代数形式的加减法运算(4).复数的乘除法运算3.C++中的友元函数4.思路和设计(1).程序组成和思路(2).部分函数对应源代码的作用(3).整体源代码5.参考资料 1.重载是什么？ 教材上和网上讲的很多都晦涩难懂。用我自己的话来讲： C++对函数和运算符可以有多个定义，类似于一词多义。分别称为函数重载和运算符重载。
【c++】运算符重载练习
AG的博客
10-14 407
利用运算符重载实现自己的MyString类 MyString.h #pragma once #include using namespace std; class MyString { public: //构造和析构 MyString(); MyString(const char* p); MyString(const MyString& obj); ~MyString();
C++ 面向对象 - 运算符重载与友元函数
m0_61820263的博客
06-10 198
C++ 面向对象 - 运算符重载与友元函数
C++编程实践：继承与运算符重载实例
这两个C++练习题涵盖了类的继承、基本的数学计算、用户输入处理以及动态内存管理，都是C++编程中的核心概念。通过解决这些问题，你可以加强基础编程技能，为更复杂的面向对象设计和内存管理做好准备。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值