C++ 实现复数类

一个复数类

#include<iostream>
using namespace std;

class Complex
{
private:
    double real;
    double imag;
public:
    Complex(double x, double y);//构造函数，
    ~Complex()//析构函数，如果没有写构造函数和析构函数，编译器会自动帮忙生成
    {};

    Complex Add(const Complex x) const;
    Complex Sub(const Complex x) const;
    Complex Mut(const Complex x) const;
    Complex Div(const Complex x) const;
    void Show();
};

Complex::Complex(double x = 1.0, double y = 2.0)//构造函数的实现
{
    real = x;
    imag = y;
}

Complex Complex::Add(const Complex x) const
{
    Complex z;
    z.real = real + x.real;
    z.imag = imag + x.imag;
    return z;
}

Complex Complex::Sub(const Complex x) const
{
    Complex z;
    z.real = real - x.real;
    z.imag = imag - x.imag;
    return z;
}

Complex Complex::Mut(const Complex x) const
{
    Complex z;
    z.real = real * x.real;
    z.imag = imag * x.imag;
    return z;
}

Complex Complex::Div(const Complex x) const
{
    Complex z;
    z.real = real / x.real;
    z.imag = imag / x.imag;
    return z;
}

void Complex::Show(void)
{
    cout << "real = " << real;
    cout << "imag = " << imag << endl;
}

测试程序

#include "Template_Complex.h"
#include "iostream"
using namespace std;

int main()
{
    Complex x(1.2f,2.4f), y(1.2f,2.4f), z;
    z = x.Add(y);
    z.Show();
    z = x.Sub(y);
    z.Show();
    z = x.Mut(y);
    z.Show();
    z = x.Div(y);
    z.Show();

}

构造函数的名字要和类的名字相同，每个类必须有构造函数，同时还要有对应的析构函数。
const使用:

1. 用于指针的两种情况:const是一个左结合的类型修饰符.
   int const A; //A可变,A不可变
   int const A; //A不可变,A可变
   2.限定函数的传递值参数:
   void function(const int Var); //传递过来的参数在函数内不可以改变.
   3.限定函数返回值型.
   const int function(); //此时const无意义
   const myclassname function(); //函数返回自定义类型myclassname.
   4限定函数类型.
   void function()const; //常成员函数, 常成员函数是不能改变成员变量值的函数。
   例如

int Point::GetY()
{
return yVal;
}

这个函数被调用时，不改变Point对象，而下面的函数改变Point对象：

void Point:: SetPt (int x, int y)
{
xVal=x;
yVal=y;
}

为了使成员函数的意义更加清楚，我们可在不改变对象的成员函数的函数原型中加上const说明：

class Point
{
public:
int GetX() const;
int GetY() const;
void SetPt (int, int);
void OffsetPt (int, int);
private:
int xVal, yVal;
};

const成员函数应该在函数原型说明和函数定义中都增加const限定：

int Point::GetY() const
{
return yVal;
}
class Set {
public:
Set (void){ card = 0; }
bool Member(const int) const;
void AddElem(const int);
//...
};
bool Set::Member (const int elem) const
{
//...
}

非常量成员函数不能被常量成员对象调用，因为它可能企图修改常量的数据成员：
const Set s;
s.AddElem(10); // 非法: AddElem不是常量成员函数
s.Member(10); // 正确
*******但构造函数和析构函数对这个规则例外，它们从不定义为常量成员，但可被常量对象调用（被自动调用）。它们也能给常量的数据成员赋值，除非数据成员本身是常量。
为什么需要const成员函数？
我们定义的类的成员函数中，常常有一些成员函数不改变类的数据成员，也就是说，这些函数是"只读"函数，而有一些函数要修改类数据成员的值。如果把不改变数据成员的函数都加上const关键字进行标识，显然，可提高程序的可读性。其实，它还能提高程序的可靠性，已定义成const的成员函数，一旦企图修改数据成员的值，则编译器按错误处理。