c++數據封裝以及定義結構的詳細講解

先介紹一個字符串比較函數：strcmp（s1，s2），當s1<s2時，返回一個負整數；當s1=s2時，返回值為0；當s1>s2時，返回一個正整數
還有一個字符串復制函數：strcpy（a，b），表示將字符串b的值復制給字符串a當然字符串b的長度不能超過字符串a

定義結構

為了定義結構，您必須使用 struct 語句。struct 語句定義了一個包含多個成員的新的數據類型，struct 語句的格式如下：

struct type_name {
member_type1 member_name1;
member_type2 member_name2;
member_type3 member_name3;
.
.
} object_names;

type_name 是結構體類型的名稱，member_type1 member_name1 是標準的變量定義，比如 int i; 或者 float f; 或者其他有效的變量定義。在結構定義的末尾，最后一個分號之前，您可以指定一個或多個結構變量，這是可選的。下面是聲明一個結構體類型 books，變量為 book：

struct books
{
 char  title[50];
 char  author[50];
 char  subject[100];
 int   book_id;
} book;

訪問結構成員

為了訪問結構的成員，我們使用成員訪問運算符（.）。成員訪問運算符是結構變量名稱和我們要訪問的結構成員之間的一個句號。

下面的實例演示了結構的用法：

#include <iostream>
#include <cstring>

using namespace std;

// 聲明一個結構體類型 books 
struct books
{
 char  title[50];
 char  author[50];
 char  subject[100];
 int   book_id;
};

int main( )
{
 books book1;        // 定義結構體類型 books 的變量 book1
 books book2;        // 定義結構體類型 books 的變量 book2

 // book1 詳述
 strcpy( book1.title, "c++ 教程");
 strcpy( book1.author, "yapf"); 
 strcpy( book1.subject, "編程語言");
 book1.book_id = 12345;

 // book2 詳述
 strcpy( book2.title, "css 教程");
 strcpy( book2.author, "yapf");
 strcpy( book2.subject, "前端技術");
 book2.book_id = 1234556;

 // 輸出 book1 信息
 cout << "第一本書標題 : " << book1.title <<endl;
 cout << "第一本書作者 : " << book1.author <<endl;
 cout << "第一本書類目 : " << book1.subject <<endl;
 cout << "第一本書 id : " << book1.book_id <<endl;

 // 輸出 book2 信息
 cout << "第二本書標題 : " << book2.title <<endl;
 cout << "第二本書作者 : " << book2.author <<endl;
 cout << "第二本書類目 : " << book2.subject <<endl;
 cout << "第二本書 id : " << book2.book_id <<endl;

 return 0;
}

實例中定義了結構體類型 books 及其兩個變量 book1 和 book2。當上面的代碼被編譯和執行時，它會產生下列結果：

第一本書標題:c++教程
第一本書作者:yapf
第一本書類目:編程語言
第一本書id：12345
第一本書標題:css教程
第一本書作者:yapf
第一本書類目:前端技術
第一本書id：123456

結構作為函數參數

您可以把結構作為函數參數，傳參方式與其他類型的變量或指針類似。您可以使用上面實例中的方式來訪問結構變量：

#include <iostream>
#include <cstring>

using namespace std;
void printbook( struct books book );

// 聲明一個結構體類型 books 
struct books
{
 char  title[50];
 char  author[50];
 char  subject[100];
 int   book_id;
};

int main( )
{
 books book1;        // 定義結構體類型 books 的變量 book1
 books book2;        // 定義結構體類型 books 的變量 book2

  // book1 詳述
 strcpy( book1.title, "c++ 教程");
 strcpy( book1.author, "yapf"); 
 strcpy( book1.subject, "編程語言");
 book1.book_id = 12345;

 // book2 詳述
 strcpy( book2.title, "css 教程");
 strcpy( book2.author, "yapf");
 strcpy( book2.subject, "前端技術");
 book2.book_id = 1234556;

 // 輸出 book1 信息
 printbook( book1 );

 // 輸出 book2 信息
 printbook( book2 );

 return 0;
}
void printbook( struct books book )
{
 cout << "書標題 : " << book.title <<endl;
 cout << "書作者 : " << book.author <<endl;
 cout << "書類目 : " << book.subject <<endl;
 cout << "書 id : " << book.book_id <<endl;
}

當上面的代碼被編譯和執行時，它會產生下列結果：

書標題：c++教程
書作者：yapf
書類目：編程語言
書id：12345
書標題：css教程
書作者：yapf
書類目：前端技術
書id：123456

指向結構的指針

您可以定義指向結構的指針，方式與定義指向其他類型變量的指針相似，如下所示：

struct books *struct_pointer;

現在，您可以在上述定義的指針變量中存儲結構變量的地址。為了查找結構變量的地址，請把 & 運算符放在結構名稱的前面，如下所示：

struct_pointer = &book1;

為了使用指向該結構的指針訪問結構的成員，您必須使用 -> 運算符，如下所示：

struct_pointer->title;

讓我們使用結構指針來重寫上面的實例，這將有助于您理解結構指針的概念：

#include <iostream>
#include <cstring>

using namespace std;
void printbook( struct books *book );

struct books
{
 char  title[50];
 char  author[50];
 char  subject[100];
 int   book_id;
};

int main( )
{
 books book1;        // 定義結構體類型 books 的變量 book1
 books book2;        // 定義結構體類型 books 的變量 book2

  // book1 詳述
 strcpy( book1.title, "c++ 教程");
 strcpy( book1.author, "yapf"); 
 strcpy( book1.subject, "編程語言");
 book1.book_id = 12345;

 // book2 詳述
 strcpy( book2.title, "css 教程");
 strcpy( book2.author, "yapf");
 strcpy( book2.subject, "前端技術");
 book2.book_id = 1234556;

 // 通過傳 book1 的地址來輸出 book1 信息
 printbook( &book1 );

 // 通過傳 book2 的地址來輸出 book2 信息
 printbook( &book2 );

 return 0;
}
// 該函數以結構指針作為參數
void printbook( struct books *book )
{
 cout << "書標題  : " << book->title <<endl;
 cout << "書作者 : " << book->author <<endl;
 cout << "書類目 : " << book->subject <<endl;
 cout << "書 id : " << book->book_id <<endl;
}

當上面的代碼被編譯和執行時，它會產生下列結果：

書標題：c++教程
書作者：yapf
書類目：編程語言
書id：12345
書標題：css教程
書作者：yapf
書類目：前端技術
書id：123456

typedef 關鍵字

下面是一種更簡單的定義結構的方式，您可以為創建的類型取一個"別名"。例如：

typedef struct books
{
 char  title[50];
 char  author[50];
 char  subject[100];
 int   book_id;
}books;

現在，您可以直接使用books來定義books類型的變量，而不需要使用 struct 關鍵字。下面是實例：

books book1, book2;

您可以使用typedef關鍵字來定義非結構類型，如下所示：

typedef long int *pint32;

pint32 x, y, z;

x, y 和 z 都是指向長整型 long int 的指針。

c++ 數據封裝

所有的 c++ 程序都有以下兩個基本要素：

• 程序語句（代碼）：這是程序中執行動作的部分，它們被稱為函數。
• 程序數據：數據是程序的信息，會受到程序函數的影響。

封裝是面向對象編程中的把數據和操作數據的函數綁定在一起的一個概念，這樣能避免受到外界的干擾和誤用，從而確保了安全。數據封裝引申出了另一個重要的 oop 概念，即數據隱藏。

數據封裝是一種把數據和操作數據的函數捆綁在一起的機制，數據抽象是一種僅向用戶暴露接口而把具體的實現細節隱藏起來的機制。

c++ 通過創建類來支持封裝和數據隱藏（public、protected、private）。我們已經知道，類包含私有成員（private）、保護成員（protected）和公有成員（public）成員。默認情況下，在類中定義的所有項目都是私有的。例如：

class box
{
 public:
    double getvolume(void)
    {
       return length * breadth * height;
    }
 private:
    double length;      // 長度
    double breadth;     // 寬度
    double height;      // 高度
};

變量 length、breadth 和 height 都是私有的（private）。這意味著它們只能被 box 類中的其他成員訪問，而不能被程序中其他部分訪問。這是實現封裝的一種方式。

為了使類中的成員變成公有的（即，程序中的其他部分也能訪問），必須在這些成員前使用 public 關鍵字進行聲明。所有定義在 public 標識符后邊的變量或函數可以被程序中所有其他的函數訪問。

把一個類定義為另一個類的友元類，會暴露實現細節，從而降低了封裝性。理想的做法是盡可能地對外隱藏每個類的實現細節。

數據封裝的實例

c++ 程序中，任何帶有公有和私有成員的類都可以作為數據封裝和數據抽象的實例。請看下面的實例：

#include <iostream>
using namespace std;

class adder{
 public:
    // 構造函數
    adder(int i = 0)
    {
      total = i;
    }
    // 對外的接口
    void addnum(int number)
    {
        total += number;
    }
    // 對外的接口
    int gettotal()
    {
        return total;
    };
 private:
    // 對外隱藏的數據
    int total;
};
int main( )
{
 adder a;
 
 a.addnum(10);
 a.addnum(20);
 a.addnum(30);

 cout << "total " << a.gettotal() <<endl;
 return 0;
}

當上面的代碼被編譯和執行時，它會產生下列結果：

total 60

上面的類把數字相加，并返回總和。公有成員 addnum 和 gettotal 是對外的接口，用戶需要知道它們以便使用類。私有成員 total 是對外隱藏的，用戶不需要了解它，但它又是類能正常工作所必需的。

設計策略

通常情況下，我們都會設置類成員狀態為私有（private），除非我們真的需要將其暴露，這樣才能保證良好的封裝性。

這通常應用于數據成員，但它同樣適用于所有成員，包括虛函數。

c++ 類 & 對象

c++ 在 c 語言的基礎上增加了面向對象編程，c++ 支持面向對象程序設計。類是 c++ 的核心特性，通常被稱為用戶定義的類型。

類用于指定對象的形式，是一種用戶自定義的數據類型，它是一種封裝了數據和函數的組合。類中的數據稱為成員變量，函數稱為成員函數。類可以被看作是一種模板，可以用來創建具有相同屬性和行為的多個對象。

c++ 類定義

定義一個類需要使用關鍵字 class，然后指定類的名稱，并類的主體是包含在一對花括號中，主體包含類的成員變量和成員函數。

定義一個類，本質上是定義一個數據類型的藍圖，它定義了類的對象包括了什么，以及可以在這個對象上執行哪些操作。

以下實例我們使用關鍵字class定義 box 數據類型，包含了三個成員變量 length、breadth 和 height：

class box
{
 public:
    double length;   // 盒子的長度
    double breadth;  // 盒子的寬度
    double height;   // 盒子的高度
};

關鍵字 public 確定了類成員的訪問屬性。在類對象作用域內，公共成員在類的外部是可訪問的。您也可以指定類的成員為 private 或 protected，這個我們稍后會進行講解。

定義 c++ 對象

類提供了對象的藍圖，所以基本上，對象是根據類來創建的。聲明類的對象，就像聲明基本類型的變量一樣。下面的語句聲明了類 box 的兩個對象：

box box1; // 聲明 box1，類型為 box box box2; // 聲明 box2，類型為 box

對象 box1 和 box2 都有它們各自的數據成員。

訪問數據成員

類的對象的公共數據成員可以使用直接成員訪問運算符 . 來訪問。

為了更好地理解這些概念，讓我們嘗試一下下面的實例：

#include <iostream>

using namespace std;

class box
{
 public:
    double length;   // 長度
    double breadth;  // 寬度
    double height;   // 高度
    // 成員函數聲明
    double get(void);
    void set( double len, double bre, double hei );
};
// 成員函數定義
double box::get(void)
{
  return length * breadth * height;
}

void box::set( double len, double bre, double hei)
{
  length = len;
  breadth = bre;
  height = hei;
}
int main( )
{
 box box1;        // 聲明 box1，類型為 box
 box box2;        // 聲明 box2，類型為 box
 box box3;        // 聲明 box3，類型為 box
 double volume = 0.0;     // 用于存儲體積

 // box 1 詳述
 box1.height = 5.0; 
 box1.length = 6.0; 
 box1.breadth = 7.0;

 // box 2 詳述
 box2.height = 10.0;
 box2.length = 12.0;
 box2.breadth = 13.0;

 // box 1 的體積
 volume = box1.height * box1.length * box1.breadth;
 cout << "box1 的體積：" << volume <<endl;

 // box 2 的體積
 volume = box2.height * box2.length * box2.breadth;
 cout << "box2 的體積：" << volume <<endl;


 // box 3 詳述
 box3.set(16.0, 8.0, 12.0); 
 volume = box3.get(); 
 cout << "box3 的體積：" << volume <<endl;
 return 0;
}

當上面的代碼被編譯和執行時，它會產生下列結果：

box1的體積：210
box2的體積：1560
box3的體積：1536

需要注意的是，私有的成員和受保護的成員不能使用直接成員訪問運算符 (.) 來直接訪問。我們將在后續的教程中學習如何訪問私有成員和受保護的成員。

以上就是c++數據封裝以及定義結構的詳細講解的詳細內容，更多關于c++數據封裝以及定義結構的資料請關注碩編程其它相關文章！