C++ C++；动态分配数组

我在做作业，有一点被卡住了。 我正在尝试编写一个list_add（）函数。它的第一个功能是向数组添加值。它的第二个功能是增加阵列的大小。所以它的工作原理很像一个向量。我不知道我是否做对了。我尝试的是创建一个比旧数组大的新动态分配数组，然后将所有值复制到新数组中

这是正确的方法吗

这是主体

int main()
{
    const int N = 7;

    //declaring dynamic array allocation
    int* list = new int[N];

    int used = 0, a_val;
    for(int i=0;i<11;i++)
    {
        list_add(list, used, N, i);
    }

    cout << endl << "Storlek: " << N << endl << endl;
    cout << "Printar listan " << endl;
    for(int i=0;i<used;i++)
    {
        cout << list[i] << ". ";
    }

}

intmain（）
{
常数int N=7；
//声明动态数组分配
int*list=新的int[N]；
使用的int=0，a_val；
对于（int i=0；i我会担心这条线：

*(list+(max_size-space_used-1)) = value;

还有这个：

list_new[i] = i;

我会担心这句话：

*(list+(max_size-space_used-1)) = value;

还有这个：

list_new[i] = i;

您的想法是正确的，但是实现可能需要一些“肘油”

试试这个：

保持2整数

容量-分配到的长度

大小-数组的当前结尾

if capacity <= size:
   make new list( size = capacity x 2 )
   memcopy old list into new list -> if you can't memcopy, copy over the data one-by-one
   delete old list
if capacity > size:
   list[size] = value
   size++

如果容量不足，如果无法memcopy，请逐个复制数据
删除旧列表
如果容量>大小：
列表[大小]=值
大小++

您的想法是正确的，但是实现可能需要一些“肘油”

试试这个：

保持2整数

容量-分配到的长度

大小-数组的当前结尾

if capacity <= size:
   make new list( size = capacity x 2 )
   memcopy old list into new list -> if you can't memcopy, copy over the data one-by-one
   delete old list
if capacity > size:
   list[size] = value
   size++

如果容量不足，如果无法memcopy，请逐个复制数据
删除旧列表
如果容量>大小：
列表[大小]=值
大小++

我突然想到的一个问题是，您没有在列表添加函数的作用域之外更改列表指针的值。您应该进行一些更改，如

bool list_add(int *list, int& space_used, int max_size, int value)

变成

bool list_add(int **list, int& space_used, int max_size, int value)

*list = list_new

及

变成

bool list_add(int **list, int& space_used, int max_size, int value)

*list = list_new

否则，我想您会发现，当您重新分配列表时，从“列表添加”返回后，列表指针仍将指向旧位置。
我突然想到的一个问题是，您没有在列表添加函数的范围之外更改列表指针的值。您应该进行一些更改，如

bool list_add(int *list, int& space_used, int max_size, int value)

变成

bool list_add(int **list, int& space_used, int max_size, int value)

*list = list_new

及

变成

bool list_add(int **list, int& space_used, int max_size, int value)

*list = list_new

否则，我想您会发现，当您重新分配列表时，从列表返回后，添加列表指针仍将指向旧位置。
知道如何解决问题有很多话要说，但这不是其中之一

#include <vector>
#include <iostream>

int main() 
{
    std::vector<int> numbers;

    for (int i = 0; i < 11; i++) {
        numbers.push_back(i);
    }

    for (int i = 0; i < numbers.size(); i++) {
        std::cout << numbers[i] << ". ";
    }

    std::cout << "\n";
}

#包括
#包括
int main（）
{
std：：向量数；
对于（int i=0；i<11；i++）{
数字。推回（i）；
}
对于（int i=0；i知道如何解决问题有很多话要说，但这不是其中之一

#include <vector>
#include <iostream>

int main() 
{
    std::vector<int> numbers;

    for (int i = 0; i < 11; i++) {
        numbers.push_back(i);
    }

    for (int i = 0; i < numbers.size(); i++) {
        std::cout << numbers[i] << ". ";
    }

    std::cout << "\n";
}

#包括
#包括
int main（）
{
std：：向量数；
对于（int i=0；i<11；i++）{
数字。推回（i）；
}
对于（int i=0；istd:：cout代码的实现有四个问题：

它不会复制列表中的元素
它不会将
new\u list
的值分配给
main
中的
list
变量
它从后面到前面插入值，而不是在最后一个值之后
max\u size
不会更新。很容易忽略这一点，因为每次只增加一个数组的大小。这样，每次添加值时它都需要分配。如果将新大小增加一个以上，它仍会每次重新分配
第一个问题可以通过更改
列表\u add
中的for循环来解决，以便复制：

for (int i = 0; i < space_used; i++) {   // this also changed.
    list_new[i] = list[i];
    cout ...
}
// insert the new value (in the front?)
list_new[max_size-space_used-1] = value;     
delete [] list;         // Delete the list afterwards instead of earlier.

第三个问题可以通过更改此行来解决

list_new[max_size-space_used-1] = value;

int new_max_size = space_used+1;

到

在此之后，还应删除+++
中使用的
空格

要查看第四个问题，您应该更改此行

list_new[max_size-space_used-1] = value;

int new_max_size = space_used+1;

到

它仍然会每次重新分配。但是，它应该只重新分配两次


这是完整的代码：

#include <iostream>
using std::cout;
using std::endl;

int* list_add(int *list, int& space_used, int& max_size, int value) {
    if (max_size - space_used > 0) {
        list[space_used++] = value;
        return list;
    }
    else {
        cout << "Increasing size of array!" << endl;
        int new_max_size = space_used+1;

        int *list_new = new int[new_max_size];

        for (int i = 0; i < space_used; i++) {
            list_new[i] = list[i];
            cout << list_new[i] << ". ";
        }
        cout << endl;

        list_new[space_used++] = value;
        max_size=new_max_size;

        delete [] list;
        return list_new;
    }
}

int main() {
    int N = 7;

    //declaring dynamic array allocation
    int* list = new int[N];

    int used = 0, a_val;

    for (int i = 0; i < 11; i++) {
        list=list_add(list, used, N, i);
    }

    cout << endl << "Storlek: " << N << endl << endl;
    cout << "Printar listan " << endl;

    for (int i = 0; i < used; i++) {
        cout << list[i] << ". ";
    }
}

#包括
使用std：：cout；
使用std：：endl；
int*列表添加（int*列表、使用的int和space、int和max大小、int值）{
如果（最大大小-使用的空间>0）{
列表[space_used++]=值；
退货清单；
}
否则{
cout代码的实现有四个问题：

它不会复制列表中的元素
它不会将
new\u list
的值分配给
main
中的
list
变量
它从后面到前面插入值，而不是在最后一个值之后
max\u size
不会更新。很容易忽略这一点，因为每次只增加一个数组的大小。这样，每次添加值时它都需要分配。如果将新大小增加一个以上，它仍会每次重新分配
第一个问题可以通过更改
列表\u add
中的for循环来解决，以便复制：

for (int i = 0; i < space_used; i++) {   // this also changed.
    list_new[i] = list[i];
    cout ...
}
// insert the new value (in the front?)
list_new[max_size-space_used-1] = value;     
delete [] list;         // Delete the list afterwards instead of earlier.

第三个问题可以通过更改此行来解决

list_new[max_size-space_used-1] = value;

int new_max_size = space_used+1;

到

在此之后，还应删除+++
中使用的
空格

要查看第四个问题，您应该更改此行

list_new[max_size-space_used-1] = value;

int new_max_size = space_used+1;

到

它仍然会每次重新分配。但是，它应该只重新分配两次


这是完整的代码：

#include <iostream>
using std::cout;
using std::endl;

int* list_add(int *list, int& space_used, int& max_size, int value) {
    if (max_size - space_used > 0) {
        list[space_used++] = value;
        return list;
    }
    else {
        cout << "Increasing size of array!" << endl;
        int new_max_size = space_used+1;

        int *list_new = new int[new_max_size];

        for (int i = 0; i < space_used; i++) {
            list_new[i] = list[i];
            cout << list_new[i] << ". ";
        }
        cout << endl;

        list_new[space_used++] = value;
        max_size=new_max_size;

        delete [] list;
        return list_new;
    }
}

int main() {
    int N = 7;

    //declaring dynamic array allocation
    int* list = new int[N];

    int used = 0, a_val;

    for (int i = 0; i < 11; i++) {
        list=list_add(list, used, N, i);
    }

    cout << endl << "Storlek: " << N << endl << endl;
    cout << "Printar listan " << endl;

    for (int i = 0; i < used; i++) {
        cout << list[i] << ". ";
    }
}

#包括
使用std：：cout；
使用std：：endl；
int*列表添加（int*列表、使用的int和space、int和max大小、int值）{
如果（最大大小-使用的空间>0）{
列表[space_used++]=值；
退货清单；
}
否则{
你的函数为什么会返回布尔值？是和否，这是我在互联网上找到的一个学校作业。我这么做只是为了学习。看起来你不是将原始数组中的值复制到新数组中，而是删除旧数组，创建一个同名的全新数组并添加新值。乔治，没有理由。它是ca也可能是空的。为什么你的函数返回布尔值？是和否，这是我在网上找到的学校作业。我只是为了学习。L