其實封裝并不是編程中的一個思想，對于很多領(lǐng)域來說都是這樣。對于電子器件來說，我們不關(guān)心其內(nèi)部的結(jié)構(gòu)，只在乎該器件能夠?qū)崿F(xiàn)什么樣的功能。這樣對于顧客來說，不用花時間研究內(nèi)部的實現(xiàn)過程，而對于商家來說，也可以更好的保護(hù)它們的商業(yè)秘密。

而對于 C++ 來說也是這樣，借由數(shù)據(jù)類型也可以實現(xiàn)封裝。這樣做的好處就是對外屏蔽了功能實現(xiàn)，對內(nèi)開放了數(shù)據(jù)權(quán)限。

C++ 中的類和對象是經(jīng)由 C 中的 struct 發(fā)展而來的，就好像 struct 是由數(shù)組發(fā)展而來的一樣。因此我們可以先通過 struct 實現(xiàn)封裝。

封裝實現(xiàn)

#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;
}

結(jié)果為：

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

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

封裝屬性

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

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

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

屬性	內(nèi)部	外部
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;
}

結(jié)果為：