使用ptr-to-ptr数组

Use of ptr-to-ptr array?

本文关键字：数组 ptr-to-ptr 使用      更新时间：2023-10-16

这种东西的用途和解释是什么?: 

int capacity;
int** number;
this->number = new int*[this->capacity];

我正在为考试学习，在考试中，他们要求使用指针对指针对象，并从中创建一个动态数组。有两类;钱包, WalletKeeper 。在解决方案中，他们在WalletKeeper的头文件中这样做:

private:
    Wallet** wallets;
    int capacity;
    int size;
    /*other stuff below this*/

在构造函数中:

WalletKeeper::WalletKeeper(int capacity)
{
    this->capacity = capacity;
    this->size = 0;
    this->wallets = new Wallet*[this->capacity];
    this->initiate();
}

我理解一个基本的动态数组，像这样:

Wallet * wallets = new Wallet[capacity];

这意味着你创建一个指针，指向钱包数组在内存中的位置，这样你就可以改变这些内存槽的内容。但是为什么要创建指向指针数组的指针呢?有什么用?

钱包没有自己的数组，否则我会理解它，因为我读到:初始化动态指针到多维数组的正确方法?

教授们都放假了。

指针数组有多种用途。

  1. 重新排序。假设您想重新排序数组中的对象。处理指针比移动整个对象快得多。
  2. 动态分配。您可以单独删除或分配每个对象。
  3. 重新分配和性能。假设您想增加数组的大小。重新分配实际对象可能会导致不同类型的问题(无效)。然而，重新分配指针数组或多或少是没有问题的，而且也快得多。

基本思想是它允许您创建"数组的数组"。与矩阵相比，它有一个狭窄的优势，因为它允许您拥有不同大小的子数组，但缺点是所有对象的内存不再在整个数组中连续。

Wallet ** w_ptr_ptr = new Wallet*[capacity];
for(int i = 0; i < capacity; i++) {
    w_ptr_ptr[i] = new Wallet[i+1];
}
for(int i = 0; i < capacity; i++) {
    for(int j = 0; j < i+1; j++) {
        w_ptr_ptr[i][j] = Wallet(/*...*/);
    }
}

请注意，在该代码中，w_ptr_ptr[0]的数组大小与w_ptr_ptr[1]的数组大小不同。

正如我在评论中提到的，你的教授不应该这样教学。因为这段代码需要手动清理内存，并且没有任何能力进行自动边界检查，所以您应该使用的代码是:

std::vector<std::vector<Wallet>> wallets;
for(int i = 0; i < capacity; i++) {
    wallets.emplace_back(i+1); //Will automatically create a i+1-sized array.
}
for(int i = 0; i < wallets.size(); i++) { //Note I'm able to query the size here!
    for(int j = 0; j < wallets[i].size(); j++) { //Again I can query the size!
        wallets[i][j] = Wallet(/*...*/);
    }
}

指向指针对象的指针通常用于矩阵实现。确实像指针对象实现动态数组，正如你在你的问题中所建议的:

Wallet* wallets = new Wallet[capacity];

使钱包数组的第一个位置指向numcapacity Wallet对象。

[Wallet-obj] [Wallet-obj] [Wallet-obj] ... [Wallet-obj]
     0           1             2           capacity - 1

指针的指针，如:

Wallet** wallets = new Wallet*[capacity];

创建一个数组钱包指针:

[Wallet-pointer] [Wallet-pointer] [Wallet-pointer] ... [Wallet-pointer]
        0              1                 2                capacity-1

vector中的每个指针都应该指向一个动态数组。

我将尝试"绘制";代表:

 [0][wallet-pointer]  ----> [0][wallet obj] [1][wallet obj] ... [capacity-1][wallet obj]
 [1][wallet-pointer]  ----> [0][wallet obj] [1][wallet obj] ... [capacity-1][wallet obj]
 ...
 [capacity-1][wallet-pointer]  ----> [0][wallet obj] [1][wallet obj] ... [capacity-1][wallet obj]

所以为了访问一个对象，你应该使用这样的语句:

wallets[0][2];

这意味着访问指针数组中的第1个指针，使用1 "行"

你可以想象，你有一个矩阵因为你有一个n容量的动态数组，就像n容量的行。

<标题>注意

当你实例化一个指针数组时，你必须初始化每个指针。这是一个完整的代码:

Wallet** wallets = new Wallet*[capacity];
// Now for each pointer you have to allocate a dynamic array of n-elements.
for (size_t i = 0; i < capacity; ++i) {
  wallets[i] = new Wallet[capacity];
}

对于释放阶段也是如此:

// First of all, deallocate each object in each dynamic array:
for (size_t i = 0; i < capacity; ++i) {
  delete[] wallets[i];  // wallets[i] is a dynamic array to deallocate
}
// Finally deallocate the dynamic array of poiter
delete[] wallets;
相关文章：