当前位置：首页 > news >正文

[NKU]C++理论课 cours 3 数据抽象(封装-＞隐藏实现的手段,隐藏-＞封装的重要目标)

news 2025/11/4 15:56:45

page 1 数据抽象隐藏实现

Chapter 4: Data Abstraction
Improvements of C++
Size of an object
Inclusion guard
Nested Structure
Chapter 5: Hiding the implementation
Access control: public, private, friends
Declaring a nested structure as friend
Object layout
The keyword class
Application of the access control
Hiding the implementation

第4章：数据抽象

C++ 的改进
对象的大小 sizeof 运算符可用于获取对象的大小。
包含防护（头文件保护）. 为了避免头文件的重复包含，C++ 使用包含防护机制（如 #ifndef、#define、#endif）。
嵌套结构在 C++ 中，可以在一个结构体或类中定义另一个结构体或类，这种结构称为嵌套结构。嵌套结构可以访问外部结构的成员。

第5章：隐藏实现

访问控制：public、private、friend
将嵌套结构声明为友元可以将嵌套结构声明为友元，使其能够访问外部类的私有成员。
对象布局
class 关键字 class 是 C++ 中用于定义类的关键字。与 struct 不同，默认情况下，class 的成员是私有的，而 struct 的成员是公有的。
访问控制的应用通过合理使用访问控制，可以隐藏类的实现细节，只暴露必要的接口。这有助于提高代码的封装性和可维护性。
隐藏实现隐藏实现是数据抽象的核心思想之一。通过将类的实现细节隐藏在私有成员中，只通过公共接口与外部交互，可以减少依赖关系，提高代码的灵活性和安全性。

封装是一种更广泛的概念，指的是将数据和行为组合在一起，并通过访问控制隐藏数据。
隐藏实现 是封装的一个重要目标，更侧重于隐藏类的内部实现细节，只暴露必要的接口。

在实际编程中，封装是实现隐藏实现的手段，而隐藏实现是封装的一个重要目标。
通过封装，可以实现隐藏实现，从而提高代码的安全性、可维护性和复用性。

page 2

main objectives
Object = characteristic + behavior
C++ advantages against C

How to organize header files
what should be put into a header file
how to avoid multiple declaration
how to use the header file

主要目标

对象=特征+行为

c++相对于C的优势

如何组织头文件

头文件里应该放些什么

如何避免多次申报

如何使用头文件

Main Objectives（主要目标）

数据抽象的主要目标：

隐藏复杂性：将复杂的实现细节隐藏起来，只暴露简单的接口。
提供简洁的接口：通过封装数据和行为，提供易于使用的接口。
增强代码复用性：通过封装和抽象，创建通用的类库，便于在不同项目中复用。
提高代码安全性：隐藏内部实现细节，防止外部代码直接访问或修改内部数据，避免数据被滥用。
便于维护和扩展：由于内部实现对外隐藏，修改内部实现不会影响到使用该类的代码，只要接口保持不变。

Object = Characteristic + Behavior（对象 = 特征 + 行为）

对象的定义：

对象（Object） 是面向对象编程中的基本单位，它封装了数据和操作这些数据的方法。
特征（Characteristic）：对象的状态，通常用成员变量（属性）表示。
行为（Behavior）：对象的行为，通常用成员函数（方法）表示。

page 3 动态数组

dynamic array 动态数组
storage 存储
size 大小
next 下一个
quantity 数量
functionality: add, fetch, inflate 功能：添加，获取，膨胀

1. 库的设计原则

封装性：将动态数组的实现细节隐藏起来，只暴露必要的接口（如add、fetch）。
接口设计：提供简洁的接口，让用户可以方便地使用动态数组，而不需要了解内部实现。
模块化：将动态数组的功能划分为不同的模块（如初始化、添加元素add、获取元素fetch、扩展容量inflate等）。

2. 动态数组的实现思路

动态内存管理：使用malloc、realloc和free等函数动态分配和管理内存。
扩展性：当数组容量不足时，通过inflate函数扩展存储容量。
用户友好性：提供简单的接口（如add、fetch），让用户可以方便地操作动态数组。

`malloc`

全称：Memory allocation（内存分配）
功能：分配一块指定大小的内存，并返回指向这块内存的指针。
原型：

c复制
```
void* malloc(size_t size);
```
说明：
- size 是需要分配的内存大小（以字节为单位）。
- 返回值是一个 void* 类型的指针，指向分配的内存块的起始位置。
- 如果分配失败，返回 NULL。
- 分配的内存内容是未初始化的，可能包含任意值。

2. `realloc`

全称：Resize allocation（重新分配内存）
功能：调整已分配内存块的大小。如果需要更大的内存块，可能会移动内存块的位置。

原型：

c复制

void* realloc(void* ptr, size_t new_size);

page4-9 动态数组

CLib.h

//CLib.h
typedef struct CStashTag {
  int size;      // Size of each space
  int quantity;  // Number of storage spaces
  int next;      // Next empty space
  // Dynamically allocated array of bytes:
  unsigned char* storage;
} CStash;  // a place to hide something.  
// } CStash;：在C语言中，CStash 是结构体的标签，为结构体定义了一个新的类型名。

void 	initialize (CStash* s, int size                    );
void 	cleanup (CStash* s                                 );
int 	add	     (CStash* s, const void* element);
void* fetch     (CStash* s, int index                  );
int 	count     (CStash* s                                 );
void 	inflate    (CStash* s, int increase             );

为什么 `CStash` 使用了 `typedef`？

这主要是因为：

历史原因：
- typedef struct 是C语言中的传统用法，C语言中必须使用 typedef 来简化结构体的声明。
- C++继承了C语言的语法，但C++提供了更灵活的语法，C++允许直接使用结构体名。
风格和习惯：
- 在C语言中，typedef struct 是常见的写法。
- 在C++中，通常不使用 typedef，而是直接使用结构体名。这种方式更简洁，也更符合C++的语法风格。

这里的语法结构可以分解为以下几个部分：

typedef 关键字：用于创建类型别名。
struct CStashTag：定义了一个结构体类型，其标签为 CStashTag。
{ ... }：结构体成员的定义。
CStash：通过 typedef，CStash 成为了 struct CStashTag 的别名。

因此，在定义了这个结构体之后，你可以直接使用 CStash 来声明该类型的变量，而不需要再使用 struct CStashTag。例如：

CLib.CPP

//CLib.CPP
#include "CLib.h"
#include <iostream>
#include <cassert> 
using namespace std;

// Quantity of elements to add  when increasing storage
const int increment = 100;

void initialize(CStash* s, int sz) {
    s->size = sz;        // 设置每个存储单元的大小
    s->quantity = 0;     // 初始化存储容量为 0（表示没有分配内存）
    s->storage = 0;      // 初始化存储指针为 NULL（表示没有分配内存）
    s->next = 0;         // 初始化下一个可用位置为 0
}  // // 初始化intStash   initialize(&intStash, sizeof(int));

int add(CStash* s, const void* element) {
    if(s->next >= s->quantity) //Enough space left?
         inflate(s, increment);

    // Copy element into storage,
    // starting at next empty space:
    int startBytes = s->next * s->size;
    unsigned char* e = (unsigned char*)element;
    for(int i = 0; i < s->size; i++)
        s->storage[startBytes + i] = e[i];

    s->next++;
    return(s->next - 1); // Index number
}   // to be continued

void* fetch(CStash* s, int index) {
    // Check index boundaries:
    assert(0 <= index);
    if(index >= s->next)
        return 0; // To indicate the end
    // Produce pointer to desired element:
    return &(s->storage[index * s->size]);
}

int count(CStash* s) {
    return s->next;  // Elements in CStash
} // to be continued

void inflate(CStash* s, int increase) {
    assert(increase > 0);
    int newQuantity = s->quantity + increase;
    int newBytes = newQuantity * s->size;
    int oldBytes = s->quantity * s->size;
    unsigned char* b = new unsigned char[newBytes];
    for(int i = 0; i < oldBytes; i++)
        b[i] = s->storage[ i ]; // Copy old to new
    delete [ ](s->storage); // Old storage

    s->storage = b; // Point to new memory
    s->quantity = newQuantity;
} // to be continued

void cleanup(CStash* s) {
    if(s->storage != 0) {
        cout << "freeing storage" << endl;
        delete [ ]s->storage;
    }
}

如果你有一个结构体变量（而不是指针），你可以使用点操作符 (.) 来访问其成员。例如，如果 stash 是一个 CStash 类型的变量，那么你可以通过 stash.quantity 来访问 quantity 成员。

如果你有一个指向结构体的指针，你应该使用箭头操作符 (->) 来访问其成员。在你的例子中，s 是一个指向 CStash 的指针，所以 s->quantity 是正确的访问方式。
举例如下
(.)操作符访问结构体成员

#include <stdio.h>

typedef struct {
    int quantity;
} CStash;

int main() {
    CStash stash; // 创建一个结构体变量
    stash.quantity = 5; // 使用点操作符访问并修改成员
    printf("stash.quantity = %d\n", stash.quantity); // 输出成员的值
    return 0;
}

(->)操作符访问结构体成员

#include <stdio.h>

typedef struct {
    int quantity;
} CStash;

int main() {
    CStash stashes[2]; // 创建一个结构体数组
    stashes[0].quantity = 10; // 直接访问并修改数组第一个元素的成员
    stashes[1].quantity = 20; // 直接访问并修改数组第二个元素的成员

    // 创建一个指向结构体数组第一个元素的指针
    CStash *s = &stashes[0];
    
    // 使用箭头操作符访问并打印指针指向的结构体的成员
    printf("s->quantity = %d\n", s->quantity); // 输出第一个元素的 quantity 值
    
    // 移动指针到数组的第二个元素，并打印其成员
    s = &stashes[1];
    printf("s->quantity = %d\n", s->quantity); // 输出第二个元素的 quantity 值
    
    return 0;
}

page 10

Heap
new Type [ number_of_elements ]
return a pointer to the Type.
delete [ ] myArray
int *p = new int [100];
delete [ ] p;
memory leak, fragmented heap

堆
new Type [number_of_elements]
返回一个指向类型的指针。
删除[] myArray
Int *p = new Int [100]；
删除[]p；
内存泄漏，碎片堆

1. 堆（Heap）

堆是程序运行时用于动态内存分配的内存区域。
与栈（Stack）不同，堆中的内存分配和释放是手动管理的，通常通过C++中的new和delete操作符来完成。

2. 动态数组的分配与释放

`new Type[number_of_elements]`

功能：在堆上分配一块连续的内存，用于存储一个动态数组。
返回值：返回一个指向数组首元素的指针。 int *p = new int [100];

示例：

int* p = new int[100];  // 分配一个包含100个int的动态数组

`delete[] myArray`

功能：释放通过new[]分配的动态数组。delete[] p; // 释放动态数组
注意：必须使用delete[]来释放new[]分配的内存，而不是delete。
否则，可能会导致未定义行为。
示例：

1 举例 new delete
int* p = new int; //cout << "Value: " << *p << endl; // 输出未定义值，可能每次运行程序时都不一样。例如：Value: -12345678 或者：Value: 0 int* p = new int() //cout << "Value: " << *p << endl; // 输出 0
int* p = new int(42); // new操作符的返回值类型与分配的内存类型一致
delete p;

#include <iostream>
using namespace std;

int main() {
    // 使用 new 分配单个 int
    int* p = new int(42);  // 初始化为 42

    // 使用对象
    cout << "Value: " << *p << endl;

    // 使用 delete 释放单个对象
    delete p;

    return 0;
}

2 举例 new delete[]
int* arr = new int[5]; //数组中的值是未定义的，可能包含任意值。
arr[0]: -12345678 arr[1]: 42 arr[2]: 0 arr[3]: 314159 arr[4]: -1
int* arr = new int[5](); // 00000
int* arr = new int[5]{1,2,3,4,5};
delete[] arr;

#include <iostream>
using namespace std;

int main() {
    // 使用 new[] 分配一个包含 5 个 int 的数组
    int* arr = new int[5]{1, 2, 3, 4, 5};  // 初始化数组

    // 使用数组
    for (int i = 0; i < 5; i++) {
        cout << "arr[" << i << "]: " << arr[i] << endl;
    }

    // 使用 delete[] 释放数组
    delete[] arr;

    return 0;
}

内存泄漏（Memory Leak）

内存泄漏是指程序分配了动态内存，但在使用完毕后没有正确释放，导致内存无法被其他程序或系统回收。
内存泄漏会导致程序占用的内存不断增加，最终可能导致程序崩溃或系统资源耗尽。

int* p = new int[100];
// 忘记释放内存
// delete[] p;  // 如果忘记这一步，就会导致内存泄漏

堆碎片化（Fragmented Heap）

堆碎片化是指堆内存被频繁分配和释放后，导致堆空间变得碎片化。
碎片化的堆内存可能导致以下问题：

内存分配失败：即使堆中仍有足够的总内存，但由于碎片化，可能无法找到足够大的连续空间来满足新的分配请求。
性能下降：频繁的内存分配和释放会增加管理堆的开销。

void example() {
    for (int i = 0; i < 1000; i++) {
        int* p = new int[100];
        delete[] p;  // 正确释放内存
    }
}  //在这个例子中，虽然每次分配的内存都被正确释放，但频繁的分配和释放可能导致堆碎片化。

正确使用new[] delete[]避免 内存泄漏和堆碎片化

#include <iostream>
using namespace std;

int main() {
    // 动态分配一个包含100个int的数组
    int* p = new int[100];

    // 使用数组
    for (int i = 0; i < 100; i++) {
        p[i] = i * i;  // 初始化数组
    }

    // 输出数组内容
    for (int i = 0; i < 100; i++) {
        cout << "p[" << i << "]: " << p[i] << endl;
    }

    // 释放动态数组
    delete[] p;

    return 0;
}

page 11-13

CLabTest.cpp

#include "CLib.h" //CLib.h：假设这是一个自定义的头文件，定义了 CStash 结构体以及相关的函数（initialize、add、fetch、cleanup 等）。
#include <fstream> //文件
#include <iostream> //控制台
#include <string>//字符
#include <cassert> //assert
using namespace std;

int main( ) {
  // Define variables at the beginning
  // of the block, as in C:
  CStash intStash, stringStash;  //定义对象用于存储 int string
  int i;    //循环计算
  char* cp;  // 字符指针，提取字符串
  ifstream in;  //打开文件读取，输入流对象
  string line;  // 字符串变量，读取文件美航
  const int bufsize = 80;  定义常量 整形 字符串最大长度80
  // to be continued

 // 初始化intStash
  initialize(&intStash, sizeof(int));

  for(i = 0; i < 100; i++)
      add(&intStash, &i);
  for(i = 0; i < count(&intStash); i++)
      cout << "fetch(&intStash, " << i << ") = "
           << *(int*)fetch(&intStash, i)
           << endl;
   // to be continued

  // Holds 80-character strings:
  initialize(&stringStash, sizeof(char)*bufsize);
  in.open("CLibTest.cpp");
  assert(in);
  while(getline(in, line))
       add(&stringStash, line.c_str());
  i = 0;
  while(  (cp = (char*)fetch(&stringStash,i++) )!=0)
      cout << "fetch(&stringStash, " << i << ") = "
           << cp << endl;
  cleanup(&intStash);
  cleanup(&stringStash);
}

完整代码

//CLib.h
typedef struct CStashTag {
  int size;      // Size of each space
  int quantity;  // Number of storage spaces
  int next;      // Next empty space
  // Dynamically allocated array of bytes:
  unsigned char* storage;
} CStash;  // a place to hide something.  
// } CStash;：在C语言中，CStash 是结构体的标签，为结构体定义了一个新的类型名。

void 	initialize (CStash* s, int size                    );
void 	cleanup (CStash* s                                 );
int 	add	     (CStash* s, const void* element);
void* fetch     (CStash* s, int index                  );
int 	count     (CStash* s                                 );
void 	inflate    (CStash* s, int increase             );


//CLib.CPP
#include "CLib.h"
#include <iostream>
#include <cassert> 
using namespace std;

// Quantity of elements to add  when increasing storage
const int increment = 100;

//初始化
void initialize(CStash* s, int sz) { // CStash* s表示需要一个指向 CStash 类型结构体的指针
    s->size = sz;        // 设置每个存储单元的大小
    s->quantity = 0;     // 初始化存储容量为 0（表示没有分配内存）
    s->storage = 0;      // 初始化存储指针为 NULL（表示没有分配内存）
    s->next = 0;         // 初始化下一个可用位置为 0
}  // // 初始化intStash   initialize(&intStash, sizeof(int));

//相加
int add(CStash* s, const void* element) {
    if(s->next >= s->quantity) // Enough space left?
         inflate(s, increment);

    // Copy element into storage, 将element拷贝到storage
    // starting at next empty space: 在下一个empty空间开始
    int startBytes = s->next * s->size;
    unsigned char* e = (unsigned char*)element;
    for(int i = 0; i < s->size; i++)
        s->storage[startBytes + i] = e[i];

    s->next++;
    return(s->next - 1); // Index number
}   // add(&intStash, &i);

void* fetch(CStash* s, int index) {
    // Check index boundaries:
    assert(0 <= index);
    if(index >= s->next)
        return 0; // To indicate the end
    // Produce pointer to desired element:
    return &(s->storage[index * s->size]);
}

int count(CStash* s) {
    return s->next;  // Elements in CStash
} // to be continued

void inflate(CStash* s, int increase) {
    assert(increase > 0);
    int newQuantity = s->quantity + increase;
    int newBytes = newQuantity * s->size;
    int oldBytes = s->quantity * s->size;
    unsigned char* b = new unsigned char[newBytes];
    for(int i = 0; i < oldBytes; i++)
        b[i] = s->storage[ i ]; // Copy old to new
    delete [ ](s->storage); // Old storage

    s->storage = b; // Point to new memory
    s->quantity = newQuantity;
} // inflate(s, increment);

void cleanup(CStash* s) {
    if(s->storage != 0) {
        cout << "freeing storage" << endl;
        delete [ ]s->storage;
    }
}   


#include "CLib.h" //CLib.h：假设这是一个自定义的头文件，定义了 CStash 结构体以及相关的函数（initialize、add、fetch、cleanup 等）。
#include <fstream> //文件
#include <iostream> //控制台
#include <string>//字符
#include <cassert> //assert
using namespace std;

int main( ) {
  // Define variables at the beginning
  // of the block, as in C:
  CStash intStash, stringStash;  //定义对象用于存储 int string
  int i;    //循环计算
  char* cp;  // 字符指针char point，提取字符串
  ifstream in;  //打开文件读取，输入流对象
  string line;  // 字符串变量，读取文件美航
  const int bufsize = 80;  定义常量 整形 字符串最大长度80
  // to be continued

 // 初始化intStash
  initialize(&intStash, sizeof(int));  // &intStash 获取intStash变量的地址

  for(i = 0; i < 100; i++)
      add(&intStash, &i);

  for(i = 0; i < count(&intStash); i++)
      cout << "fetch(&intStash, " << i << ") = "
           << *(int*)fetch(&intStash, i)
           << endl;
   // to be continued

  // Holds 80-character strings:
  initialize(&stringStash, sizeof(char)*bufsize);
  in.open("CLibTest.cpp");
  assert(in);
  while(getline(in, line))
       add(&stringStash, line.c_str());
  i = 0;
  while(  (cp = (char*)fetch(&stringStash,i++) )!=0)
      cout << "fetch(&stringStash, " << i << ") = "
           << cp << endl;
  cleanup(&intStash);
  cleanup(&stringStash);
}

查看全文

http://www.dtcms.com/a/28612.html