1.C++ 基础学习复数(不带指针的类)

思路

1.防卫式声明
2.先写出类名
3.考虑需要哪些数据,数据放在私有方法中
4.数据是什么类型
5.考虑构造函数,初值列,没有返回类型,要不要默认值,
6.

头文件

1.声明 .h
2.主程序 .cpp
#include <系统自带>
#include"自己写的内容"
3.标准库 standard library

头文件的写法

#complex.h

#include <iostream>
#ifndef __COMPLEX__
#define __COMPLEX__
using namespace std;
/*
1.需要有前置声明
2.需要有类声明
3.需要有类定义
*/

/*
template<typename T> //模板,不用把类型写死,到时候再指定
class complex
{
public:
	complex(T r = 0, i = 0)
		:re(r), im(i)
	{}
	complex& operator += (const complex&);
	T real() const { return re; }
	T imag() const { return im; }
private:
	T re, im;
};
*/


class complex
{
	//access  level 访问级别
public:   //公开方法

	/*
	构造函数
	是类对象用来初始化数据成员的方法
	1.函数名称和类的名称相同
	2.可以拥有参数,参数可以拥有默认值
	3.没有返回类型
	4.构造函数可以有多个,但是不能冲突
	*/
	//构造函数一
	complex(double r=0, double i=0)
		:re(r), im(i)    //initialization 初始化 初始值
	{};    //这里写方法


	complex& operator += (const complex&);
	double real() const { return re; };  //用方法展示实部和虚部
	double imag() const { return im; };
	//常量成员函数const  

	double func(const complex& parm)
	{
		return parm.re + parm.im;
	};   //这个函数可以处理其他复数 ,直接拿到他们re,im 因为相同class的object互为友元

private:  //私有方法 我们不希望外界去改数据,看到我们的数据,应该把数据封装起来
	double re, im;
	friend complex& __doapl(complex*, const complex&);
	//友元中的函数可以自由取得私有方法中的数据和函数
	//相同class的各个objects互为友元
};

inline complex&   //传送者无需知道接收者是以reference形式接收
__doapl(complex* ths, const complex& r)
{
	ths->re += r.re;
	ths->im += r.im;
	return *ths;
}
//内联函数
/*
成员函数运算符重载
重载符会看左面这个内容对运算符时是否有重载
左边这个数就是this里头的内容

*/
inline complex&
complex::operator += (const complex& r)
{
	return __doapl(this, r);
}


/*
参数传递 pass by value vs. pass by reference 
参数和返回值传递尽量都传引用 &
*/

inline double imag(const complex& r)
{
	return r.imag();
}
inline double real(const complex& r)
{
	return r.real();
}

inline complex 
operator + (const complex& x, const complex& y)
{
	return complex (real(x) +real(y), 
		imag(x) + imag(y));   //这里内部创建内容来储存这个值,可以用创建的类暂时接收,typename()临时对象
}
inline complex
operator + (const complex& x, const double y)
{
	return complex(x.real() + y, x.imag());
}
inline complex 
operator + (const double x, const complex y)
{
	return complex(x + y.real(), y.imag());  
}

/*
输出流重载
只能是全局重载
右边是复数,左边cout 是属于ostream类
*/
ostream& operator << (ostream& os,const complex& x)
{
	return os << "(" << real(x) << "," << imag(x) <<"i" << ")";
}


#endif

compex.cpp

#include "complex.h"
#include <iostream>
using namespace std;

int main()
{
	complex c1(5, 6);
	complex c2(2, 4);
	cout << c1.real() << endl;
	cout << c1.imag() << endl;
	complex c3;
	c3 = c1 + c2;
	cout << c1.real() << endl;
	cout << c2.real() << endl;
	cout << c3 << endl;
	

	system("pause");
};

const常量成员函数

不会改变数据内容的马上加上const

操作符重载

写类需要注意的地方

1.数据放在私有函数里
2.传递参数尽量用引用
3.要不要加const
4.尽量使用构造函数