【原创】C++_第一周_C++ complex类的实现（我的第一个c++程序）

最新推荐文章于 2024-01-16 17:04:52 发布
最新推荐文章于 2024-01-16 17:04:52 发布
阅读量631 收藏 4
点赞数 2
文章标签： c 类实现 complex类 模板 操作符重载
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_31201973/article/details/71023537
版权
本文介绍了作者的第一个C++程序，实现了一个complex类，包括类模板、操作符重载、赋值函数、相等比较等功能，并使用了友元函数和this指针。代码简洁并附有注释。
摘要由CSDN通过智能技术生成

如果喜欢可以关注我

本文是我真正意义上第一个c++程序，在此期间查阅了大量的资料，实现了一个complex类，实现了类模板，水平有限，如有错误请私信我。

本程序实现的功能：

1. +  -  *  /                              重载函数

2. +=  -=  *=  /=                      重载函数

3. 赋值重载函数

4.判断是否相等，是否不等的重载函数

5.取正，取负的重载函数

6.get_real ,get_imag  成员函数（成员函数互为友元）

7.友元函数，this指针的使用。

8.complex类的显示

因为程序比较简单，我都做了注释，就不详细展开，如有问题请私信我。

 

/*	本程序的注释代表仅代表个人理解，不一定完全正确，全是我亲自敲上去的，如有错误请联系我。  	*/


#ifndef __COMPLEX_B_H__
#define __COMPLEX_B_H__




template<typename T>		//定义模板 typename is T

class complex			/*	复数类	*/
{
public:
	complex(T r = 0, T i =0) : re(r), im(i)
	{
		;
	}
	complex& operator += (const complex&);	//成员函数
	complex& operator -= (const complex&);
	complex& operator *= (const complex&);
	complex& operator /= (const complex&);
	complex& operator = (const complex&);	//赋值运算符重载函数
	T real() const { return re; }
	T imag() const { return im; }

private:
	T re, im;

	friend complex& __doadd(complex *, const complex&);
	friend complex& __dosub(complex *, const complex&);
	friend complex& __domul(complex *, const complex&);
	friend complex& __dodiv(complex *, const complex&);
	friend complex& __doequ(complex*, const complex&);	//赋值实际运算函数

};



/************	全局函数声明区	***************/

double real(const complex<double>& x);	//取对象的实部（全局函数），不用在类外专门定义传参数
double imag(const complex<double>& x);	//取对象的虚部（全局函数），不用在类外专门定义传参数
inline complex<double>& __doequ(complex<double>* ths, const complex<double>& r);	//赋值实际运算函数

/**************************************************************************************************************************************************************/


/************			+= -= *= /=			***************************************************************************************************************************/
/*	复数 += 的实际运算函数	*/
inline complex<double>& 
__doadd(complex<double>* ths, const complex<double>& r)	
{
	ths->re += r.re;
	ths->im += r.im;
	return *ths;
}

/*	函数名 ooerator+=	运算符重载	*/
inline complex<double>&
complex<double>::operator +=(const complex<double>& r)
{
	return __doadd(this, r);
}

/*	复数 -= 的实际运算函数	*/
inline complex<double>&
__dosub(complex<double>* ths, const complex<double>& r)	
{
	ths->re -= r.re;
	ths->im -= r.im;
	return *ths;
}

/*	函数名 ooerator-=	*/
inline complex<double>&
complex<double>::operator -=(const complex<double>& r)
{
	return __dosub(this, r);
}

/*	复数 *= 的实际运算函数	*/
inline complex<double>&
__domul(complex<double>* ths, const complex<double>& r)
{
	ths->re *= r.re;
	ths->im *= r.im;
	return *ths;
}

/*	函数名 ooerator*=	*/
inline complex<double>&
complex<double>::operator *=(const complex<double>& r)
{
	return __domul(this, r);
}

/*	复数 /= 的实际运算函数	*/
inline complex<double>&
__dodiv(complex<double>* ths, const complex<double>& r)
{
	ths->re /= r.re;
	ths->im /= r.im;
	return *ths;
}

/*	函数名 ooerator/=	*/
inline complex<double>&
complex<double>::operator/=(const complex<double>& r)
{
	return __dodiv(this, r);
}

/*	复数	赋值（=）	实际运算函数	*/
inline complex<double>&
__doequ(complex<double>* ths, const complex<double>& r)
{
	ths->re = r.re;
	ths->im = r.im;
	return *ths;
}

/*	函数名 ooerator=	复数赋值（=）	*/
inline complex<double>&
complex<double>::operator=(const complex<double>& r)
{
	return __doequ(this, r);
}


/**************************************************************************************************************************************************************/

/*	函数名 ooerator+（复数，复数）	*/
inline complex<double>
operator+(const complex<double>& x, const complex<double>& y)
{
	return complex<double> (real(x) + real(y), imag(x) + imag(y));
}

/*	函数名 ooerator+（复数，double）	*/
inline complex<double>
operator+(const complex<double> x, double y)
{
	return complex<double>(real(x) + y, imag(x));
}

/*	函数名 ooerator+（double，复数）	*/
inline complex<double>
operator+(double x, const complex<double> y)
{
	return complex<double>(x + real(y), imag(y));
}



/*	函数名 ooerator-（复数，复数）	*/
inline complex<double>
operator-(const complex<double> x, const complex<double> y)
{
	return complex<double>(real(x) - real(y), imag(x) - imag(y));
}

/*	函数名 ooerator-（复数，double）	*/
inline complex<double>
operator-(const complex<double> x, double y)
{
	return complex<double>(real(x) - y, imag(x));
}

/*	函数名 ooerator-（double，复数）	*/
inline complex<double>
operator-(double x, const complex<double> y)
{
	return complex<double>(x - real(y), imag(y));
}



/*	函数名 ooerator*（复数，复数）	*/
inline complex<double>
operator*(const complex<double> x, const complex<double> y)
{
	return complex<double>(real(x) * real(y), imag(x) * imag(y));
}

/*	函数名 ooerator*（复数，double）	*/
inline complex<double>
operator*(const complex<double> x, double y)
{
	return complex<double>(real(x) * y, imag(x));
}

/*	函数名 ooerator*（double，复数）	*/
inline complex<double>
operator*(double x, const complex<double> y)
{
	return complex<double>(x * real(y), imag(y));
}


/*	函数名 ooerator/（复数，复数）	*/
inline complex<double>
operator/(const complex<double> x, const complex<double> y)
{
	return complex<double>(real(x) / real(y), imag(x) / imag(y));
}

/*	函数名 ooerator/（复数，double）	*/
inline complex<double>
operator/(const complex<double> x, double y)
{
	return complex<double>(real(x) / y, imag(x));
}

/*	函数名 ooerator/（double，复数）	*/
inline complex<double>
operator/(double x, const complex<double> y)
{
	return complex<double>(x / real(y), imag(y));
}



/*		函数名 ooerator==（复数，复数）	判断两个复数是否相等     重载		*/
inline bool
operator==(const complex<double>& x, const complex<double>& y)
{
	return  real(x) == real(y) && imag(x) == imag(y);
}

/*		函数名 ooerator==（复数，double）	判断两个复数是否相等     重载		*/
inline bool
operator==(const complex<double>& x, double y)
{
	return  real(x) == y && imag(x) == 0;
}

/*		函数名 ooerator==（double，复数）	判断两个复数是否相等     重载		*/
inline bool
operator==(double x, const complex<double>& y)
{
	return  x == real(y) && imag(y) == 0;
}



/*		函数名 ooerator!=（复数，复数）	判断两个复数是否不相等     重载		*/
inline bool 
operator != (const complex<double>& x, const complex<double>& y)
{
	return real(x) != real(y) || imag(x) != imag(y);
}

/*		函数名 ooerator!=（复数，double）	判断两个复数是否不相等     重载		*/
inline bool 
operator != (const complex<double>& x, double y)
{
	return real(x) != y || imag(x) != 0;
}

/*		函数名 ooerator!=（double，复数）	判断两个复数是否相等     重载		*/
inline bool operator != (double x, const complex<double>& y)
{
	return x != real(y) || imag(y) != 0;
}




/*	函数名 ooerator+（复数）	+正数	*/
inline complex<double>
operator+ (const complex<double>& x)
{
	return x;
}

/*	函数名 ooerator-（复数）	-复数	*/
inline complex<double>
operator- (const complex<double>& x)
{
	return complex<double>(-real(x), -imag(x));
}




inline double real(const complex<double>& x)	//取对象的实部（全局函数），不用在类外专门定义传参数
{
	return x.real();
}

inline double imag(const complex<double>& x)	//取对象的虚部（全局函数），不用在类外专门定义传参数
{
	return x.imag();
}


#endif

 

/*	本程序的注释代表仅代表个人理解，不一定完全正确，全是我亲自敲上去的，如有错误请联系我。  	*/


#include<iostream>
#include"complex_B.h"
#include<windows.h>

using namespace std;

/*	对 cout<< complex 类型的重载    ostream 是 cout的类	*/
ostream& operator<<(ostream& os, const complex<double>& x)
{

	return os << '(' << real(x) << ',' << imag(x) << ')';
	//return os << '(' << x.real() << ',' << x.imag() << ')';	//直接调用成员函数 real() 和 imag()  不必在
}

int main(void)
{
	complex<double> c1(2, 1);
	complex<double> c2(4, 0);
	complex<double> c3(-1, 1);
	complex<double> c4;		//c4未初始化（构造函数会赋初值0）

	cout << "c1=" << c1 << endl;
	cout << "c2=" << c2 << endl;
	cout << "c3=" << c3 << endl;
	cout << "c4=" << c4 << endl << endl;

	cout << "c1+c2" << c1 + c2 << endl;
	cout << "c1+4" << c1 + 4 << endl;
	cout << "2+c2" << 2 + c2 << endl << endl;

	cout << "c1-c2" << c1 - c2 << endl;
	cout << "c1-4" << c1 - 4 << endl;
	cout << "2-c2" << 2 - c2 << endl << endl;

	cout << "c1*c2" << c1 * c2 << endl;
	cout << "c1*4" << c1 * 4 << endl;
	cout << "2*c2" << 2 * c2 << endl << endl;

	cout << "c1/c2" << c1 / c2 << endl;
	cout << "c1/4" << c1 / 4 << endl;
	cout << "2/c2" << 2 / c2 << endl << endl;

	cout << "+c3" << +c3 << endl;	//测试运算符  +
	cout << "-c3" << -c3 << endl << endl;	//测试运算符  -

	c3 = complex<double>(1, -1);	// 运算符 =   （赋值）
	cout << "c3=(1,-1)" << endl;
	cout << "c3=" << c3 << endl;	// 测试运算符 = （赋值）		复数变量=临时复数
	c3 = c4;
	cout << "c3=c4" << endl;
	cout << "c3=" << c3 << endl << endl;	// 测试运算符 = （赋值）		复数变量1=复数变量2
	
	//cout << "(c1 += c2)="  << (c1 += c2) << endl;
/*	
	c1 += c2
	相当于c1.operator+=(c2)
	也就是c1调用的+=，所以this指向c1
*/
	//cout << "(c1 -= c2)="   << (c1 -= c2) << endl;
	//cout << "(c1 *= c2)=" << (c1 *= c2) << endl;
	cout << "(c1 /= c2)=" << (c1 /= c2) << endl << endl;

	cout << "c1==c2  =" << (c1 == c2) << endl;	// 测试运算符 ==  （两个复数是否相等判断）  复数变量1==复数变量2
	cout << "c1==2  =" << (c1 == 2) << endl;	// 测试运算符 ==  （两个复数是否相等判断）	复数变量==实数
	cout << "2==c2  =" << (4 == c2) << endl;	// 测试运算符 ==  （两个复数是否相等判断）	复数变量==实数

	system("pause");

	return 0;
}


 

 

 

 

 

_coder_
关注
C++学习（complex类）
qq_37988883的博客
11-14 3301
注意事项 1、防卫式的申明，避免重复定义类 2、重载一般发生在构造函数中，构造函数可以提供默认实参，要注意成员初始化列表的使用。构造函数在对象创建的同时被调用。 3、有些函数可以在类中直接进行定义，也可以在类外进行定义，在类中进行定义的函数都为内联函数，在类外定义式在前面加上inline则也可以推荐为内联函数，但具体是不是内联还是得看编译系统。内联函数一般选择较为简单的函数（不能包含循环，swit...
c++复数类（Complex class）
04-16
设计的复数类，含以下方法： 1、含两个复数的加、减、乘、除运算 2、与实数的加、减、乘、除运算 3、使用静态函数将两个复数的加、减、乘、除 4、使用友元函数进行复数与实数的加、减、乘、除运算
C++学习 Complex类
最新发布
qq_47530834的博客
01-16 1268
C++面向对象高级编程
C++ complex类
mine_soul的博客
10-23 2206
complex是C++中的模板类，用来表示复数，及复数的一系列运算。 可以定义多种类型的复数，其虚部和实部可以是整数也可以是实数。
c++复数Complex类的实现过程
一个搬运知识的笨小孩
11-17 1231
第一步：写出防卫式的声明 #ifndef _COMPLEX_ // _COMPLEX_是名称，自行定义 #define _COMPLEX_ ... #endif 第二步:写出class #ifndef _COMPLEX_ #define _COMPLEX_ class complex { ... }; //谨记勿丢分号 #endif 第三步:考虑复数需要的数据 #ifndef _COMPLEX_ #define _COMPLEX_ class complex { //数据要放在private下
C++ Complex类(without pointer member(s))
面向外界的过程
05-06 547
#ifndef __Complex__ #define __Complex__ #include<iostream> using namespace std; //using std::cout; //using std::ostream; /*前向声明*/ //class ostream; class Complex; Complex& _doapl(Complex* ths, const Complex& r); /*类声明*/ class Complex { publi
FFT_code.rar_C++实现FFT 迭代_C++实现fft函数_c++ fft函数_fft
09-23
本项目提供的"FFT_code.rar"包含了一个用C++实现的FFT迭代算法，它包括了比特翻转函数和FFT核心实现函数。以下是对这些内容的详细阐述：** ### 1. 快速傅里叶变换(FFT) 快速傅里叶变换是一种优化的离散傅里叶变换...
C++面向对象高级编程代码资源.rar_Complex_class Complex_复数的C++代码
09-20
在本资源包中，我们关注的是如何利用C++来实现复数类（Complex class），这是一段面向对象的高级编程实践。 复数类是数学概念在编程中的抽象，它表示由实部和虚部组成的数。在C++中创建复数类通常包括以下几个部分...
fft.rar_C Builder_FFT程序_c++ builder FFT_fft
09-14
标题中的"fft.rar_C++ Builder_FFT程序_c++ builder FFT_fft"表明这是一个关于C++ Builder环境下的快速傅里叶变换(FFT)程序的压缩包。FFT是数字信号处理领域的一个重要算法，用于将一个复数序列（通常是时间或空间域...
FFT.rar_C# fft 图像_C++ FFT_FFT程序_fft C#_fft c
09-14
开发者可以利用System.Numerics.Complex类进行复数运算，并使用第三方库如MathNet.Numerics或者.NET自带的Microsoft_numerics库来实现FFT功能。这些库提供了接口，使得开发者能方便地对一维、二维甚至多维数据进行...
FFT.rar_C++ FFT_FFT C程序_fft
09-21
标题中的"FFT.rar_C++ FFT_FFT C程序_fft"表明这是一个关于快速傅里叶变换（FFT）的C++编程资源，可能包含一个或多个C语言编写的FFT算法实现。FFT是一种在数字信号处理中非常重要的算法，用于计算离散傅里叶变换...
c++ complex
01-05
类中的complex ,有参数构造函数，复数的加减运算，
c++编程中complex
06-25
c++编程中关于complex类 代码运行过 请放心使用
C++ Complex复数类
冷月
07-01 564
#define _CRT_SECURE_NO_WARNINGS 1 #include using namespace std; class Complex { public: Complex(double real = 0, double image = 0) :_real(real) ,_image(image) {} Complex(const Complex& d)
C++complex复数类
August的博客
03-31 9548
  复数是形如a+bi的数，复数由实部和虚部构成，在C++的模板库中由complex类，可以直接调用，包含在complex头文件中。
【C++基础】complex类的实现
mrqiuwen的博客
06-12 995
C++complex类的实现
C++ Complex类实现
Xuan_Ray的博客
04-03 659
Complex类是典型的不含指针的类。 下面贴出代码： #ifndef __COMPLEX_H_ #define __COMPLEX_H_ // a += b += c; 结合律 right -> left // cout << a << b; 结合律 left -> right #include <iostream> //编译器会生成默认的拷贝构造，拷贝赋值，和析构函数 class Complex { public: Complex
C++：复Complex类的实现过程
weixin_43589450的博客
07-02 291
1、不带指针的 #pragma once #ifndef __COMPLEX__ #define __COMPLEX__ class complex { double re, im;//他们是私有的，一般不能直接取得，要取在private中建立的是非成员函数，例如友元函数 friend complex& __doapl(complex&, const complex&); public: complex(double r =0, double i = 0):re(r),im(i
C++面向对象之类complex详解
qq_40319799的博客
02-25 7769
类complex可作为入门C++面向对象的经典类。complex的原型是数学上的复数。我们都知道复数有实部和虚部。所以类complex有两个数据成员re, im。复数有加，减，乘，除，取反，求共轭等操作，类complex也有相对应的成员函数来实现这些操作。下面是类complex的定义和测试代码，已在vs测试过。 类complex的定义 //complex.h #ifndef _MYCOMP...
C++大学教程第十一章：复数与指数运算详解及课后习题
本资源是C++大学教程第五版第十一章的课后作业，主要涉及复数运算和指数运算的相关概念与实现。首先，我们看到一个名为`Complex`的类定义，这个类用于处理复数，并提供了友元函数来支持输入输出流操作，如`和`>>`...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值