C++?封裝的含義和簡單實現方式講解

這篇文章主要介紹了C++ 封裝的含義和簡單實現方式講解，具有一定借鑒價值，需要的朋友可以參考下。下面就和我一起來看看吧。

目錄

• 封裝實現

• 封裝屬性

• class 封裝

其實封裝并不是編程中的一個思想，對于很多領域來說都是這樣。對于電子器件來說，我們不關心其內部的結構，只在乎該器件能夠實現什么樣的功能。這樣對于顧客來說，不用花時間研究內部的實現過程，而對于商家來說，也可以更好的保護它們的商業秘密。

而對于 C++ 來說也是這樣，借由數據類型也可以實現封裝。這樣做的好處就是對外屏蔽了功能實現，對內開放了數據權限。

C++ 中的類和對象是經由 C 中的 struct 發展而來的，就好像 struct 是由數組發展而來的一樣。因此我們可以先通過 struct 實現封裝。

封裝實現

#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 構建了類似復數的結果，并使用運算符重載實現了復數的加、減、乘運算。這樣如果我們要進行復數的運算的話，可以直接使用 +-* 而不用具體關心內部的實現過程，因為我們在意的只是結果的正確性。

封裝屬性

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

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

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

protected 和 private 的區別在繼承形式上。

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

結果為：

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

上邊的程序使用 class 的概念封裝了 complex 的形式，該形式下能夠從外部調用對象的方法，但是卻不能夠從外部訪問對象的數據，達到了封裝的要求。

以上就是C++ 封裝的含義和簡單實現方式講解的詳細內容了，看完之后是否有所收獲呢？如果想了解更多相關內容，歡迎來億速云行業資訊！