#include <iostream>
?
using std::cout;
using std::endl;
?
typedef struct complex
{
? ? int x;
? ? int y;
}COMP;
?
void init(COMP &tmp,int x,int y)
{
? ? tmp.x = x;
? ? tmp.y = y;
}
?
COMP * operator +(COMP &tmp1,COMP &tmp2)
{
? ? COMP *p = static_cast<COMP *>(new COMP);
? ? p->x = tmp1.x + tmp2.x;
? ? p->y = tmp1.y + tmp2.y;
? ? return p;
}
?
COMP * operator -(COMP &tmp1,COMP &tmp2)
{
? ? COMP *p = static_cast<COMP *>(new COMP);
? ? p->x = tmp1.x - tmp2.x;
? ? p->y = tmp1.y - tmp2.y;
? ? return p;
}
?
COMP * operator *(COMP &tmp1,COMP &tmp2)
{
? ? COMP *p = static_cast<COMP *>(new COMP);
? ? p->x = tmp1.x*tmp2.x - tmp1.y*tmp2.y;
? ? p->y = tmp1.x*tmp2.y + tmp1.y*tmp2.x;
? ? return p;
}
?
int main()
{
? ? COMP x,y;
? ? init(x,1,2);
? ? init(y,3,4);
? ? cout<<x.x<<" "<<x.y<<endl;
? ? cout<<y.x<<" "<<y.y<<endl;
?
? ? COMP *z;
? ? z = x+y;
? ? cout<<z->x<<" "<<z->y<<endl;
? ? delete z;
?
? ? z = x-y;
? ? cout<<z->x<<" "<<z->y<<endl;
? ? delete z;
?
? ? z = x*y;
? ? cout<<z->x<<" "<<z->y<<endl;
? ? delete z;
?
? ? return 0;
}

結果為：

1 2
3 4
4 6
-2 -2
-5 10

上面的程序使用 struct 構建了類似復數(shù)的結果，并使用運算符重載實現(xiàn)了復數(shù)的加、減、乘運算。這樣如果我們要進行復數(shù)的運算的話，可以直接使用 +-* 而不用具體關心內部的實現(xiàn)過程，因為我們在意的只是結果的正確性。

封裝屬性

封裝的作用就像之前提到的那樣：對外提供接口，對內提供數(shù)據(jù)。

雖然上邊的函數(shù)在全局構建了接口函數(shù)，但是卻也暴露了函數(shù)的實現(xiàn)過程，并且我們還能夠在外部直接訪問 struct 內的數(shù)據(jù)，這并不是我們想要的封裝形式。這是由 struct 的性質決定的，在 C++ 中，提供了 class 的形式實現(xiàn)整個的封裝過程。

struct 和 class 的不同在于，struct 中的數(shù)據(jù)和方法都是 public 的，而 class 中的數(shù)據(jù)和方法卻是可以自定義的：

屬性	內部	外部
public	yes	yes
protected	yes	no
private	yes	no

protected 和 private 的區(qū)別在繼承形式上。

class 封裝

對于上邊的 complex，如果使用 class 來封裝：

#include <iostream>
 
using std::cout;
using std::endl;
 
class complex
{
public:
    complex()
    {
        this->x = 0;
        this->y = 0;
    }
 
    complex(int x, int y):x(x),y(y){}
 
    complex * operator +(complex &tmp)
    {
        complex *p = static_cast<complex *>(new complex);
        p->x = this->x + tmp.x;
        p->y = this->y + tmp.y;
        return p;
    }
 
    complex * operator -(complex &tmp)
    {
        complex *p = static_cast<complex *>(new complex);
        p->x = this->x - tmp.x;
        p->y = this->y - tmp.y;
        return p;
    }
 
    complex * operator *(complex &tmp)
    {
        complex *p = static_cast<complex *>(new complex);
        p->x = this->x*tmp.x - this->y*tmp.y;
        p->y = this->x*tmp.y + this->y*tmp.x;
        return p;
    }
 
    void display()
    {
        cout<<this->x<<" "<<this->y<<endl;
    }
 
private:
    int x;
    int y;
};
 
 
int main()
{
    complex x(1,2),y(3,4);
    x.display();
    y.display();
 
    complex *z;
    z = x+y;
    z->display();
    delete z;
 
    z = x-y;
    z->display();
    delete z;
 
    z = x*y;
    z->display();
    delete z;
 
    return 0;
}

結果為：