C++ 增加c+中数组的大小+；不使用向量

我正在为学校做作业，我们需要在不使用向量的情况下动态增加数组的大小。 这就是我所拥有的，但它一直在清除这两个列表

string name;
int numOfClasses = 1;
string *listOfCourses = new string[numOfClasses];
string studentclasses;

void addToList(string n,int i) {
    numOfClasses++;
    string *copyOfListOfCourses = new string[numOfClasses];
    memcpy(copyOfListOfCourses, listOfCourses, numOfClasses + 1);

    copyOfListOfCourses[i] = n;
    delete[] listOfCourses;
    listOfCourses = copyOfListOfCourses;


}

<> >代码> MycPy.（）是一个C库函数，对C++类、构造函数或析构函数一无所知。它不能用于复制包含

std:：string

s的数组。除了不能与

std:：string

s一起使用之外，这个

memcpy（）

至少还有两个问题

<正确的方法是使用C++算法<代码> STD:：复制< /C>，或者使用手册<代码> < /COD>循环> < /P>

#include <algorithm>

std::copy(listOfCourses, listOfCourses+(numOfClasses-1),
          copyOfListOfCourses);

---

不只是将整个现有数组复制到新数组，实际上必须进行另一次复制，以将调整大小的数组中的所有值移动，从索引#

i

处的现有值开始向上移动1，为新值腾出空间。这将是第二个

std:：copy（）

调用，您现在应该能够自己解决。

您可以创建一个新数组，将旧元素复制到新数组，然后用新数组替换旧数组。显然，使用指针

假设您有一个指向名为

arr

的

int

数组的指针，该数组是用动态内存创建的：

int  *arr = new int[3];
arr[0] = 1;
arr[1] = 2;
arr[2] = 3;

您需要调整它的大小，例如存储4个元素

您将创建一个指针，指向一个新的

int

数组，该数组名为

temp

，大小为：

int *temp = new int[4];

现在将旧元素复制到新数组：

for (int i = 0; i < 3 ; i++) // 3 for the size of the old array
{
    temp[i] = arr[i]; // copy the elements
}

现在你可以这样做了：

arr[3] = 4;

试试这个

#include<iostream>
#include<string.h>
using namespace std;
int *a;
int nCurrentSize =0;
void pushBack(int n)
{
  if(0 == nCurrentSize)
   {
    a= new int[1+nCurrentSize];
    a[nCurrentSize] = n;
   nCurrentSize++;
   }
   else
   {
     int *tmp = new int[nCurrentSize];
     memcpy(tmp,a,nCurrentSize*sizeof(int));
     delete []a;
     a= new int[1+nCurrentSize];
     memcpy(a,tmp,nCurrentSize*sizeof(int));
     a[nCurrentSize] = n;
     delete []tmp;
   nCurrentSize++;
    }
}
void display()
{
for(int i=0;i<nCurrentSize; i++)
  cout<<a[i]<<",";
}

int main()
{
pushBack(91);
pushBack(5);
pushBack(3);
pushBack(7);
pushBack(1);
pushBack(3);
pushBack(2);
pushBack(2);
pushBack(0);
pushBack(5); 

display();
cout<<endl<<nCurrentSize;
} 

#包括
#包括
使用名称空间std；
int*a；
int nCurrentSize=0；
无效回推（int n）
{
如果（0==nCurrentSize）
{
a=新整数[1+nCurrentSize]；
a[nCurrentSize]=n；
nCurrentSize++；
}
其他的
{
int*tmp=newint[nCurrentSize]；
memcpy（tmp，a，nCurrentSize*sizeof（int））；
删除[]a；
a=新整数[1+nCurrentSize]；
memcpy（a、tmp、nccurrentsize*sizeof（int））；
a[nCurrentSize]=n；
删除[]tmp；
nCurrentSize++；
}
}
无效显示（）
{
对于（inti=0；i，这里有一个可能就是您所寻找的示例。
它创建一个大小大一个单位的
临时数组
，将
我的数组
的内容复制到
临时数组
。然后将
输入值
添加到
临时数组
的末尾，
删除[]
s my_数组，并将
my_数组
分配给
临时数组
。最后，它会增加
旧数组的大小
，以便将来调用函数

int array_size = 1;
string *my_array = new string[array_size];

void add_to_array(string input_value, int &old_array_size) {

    int new_array_size = old_array_size + 1;

    string *temporary_array = new string[new_array_size];

    for(int i = 0; i < old_array_size; i++) {
        temporary_array[i] = my_array[i];
    }

    temporary_array[new_array_size - 1] = input_value;

    delete[] my_array;

    my_array = temporary_array;

    old_array_size++;

}

int数组_size=1；
字符串*my_数组=新字符串[数组大小]；
void add_to_数组（字符串输入_值、int和old_数组大小）{
int新数组大小=旧数组大小+1；
字符串*临时数组=新字符串[新数组大小]；
for（int i=0；i<旧数组大小；i++）{
临时_数组[i]=我的_数组[i]；
}
临时_数组[新_数组_大小-1]=输入_值；
删除[]我的_数组；
我的数组=临时数组；
旧_数组_size++；
}

这可能不是你想做的事情，但它不使用<代码> STD：：向量< /C> > /P> @ El SaDaOfft，OP在哪里使用静态大小的数组？请解释一下？不要将代码> MyCPy < /C> >与C++对象结合。这可以（也会）你的学校也教过你，你不能使用诸如<代码> MyStuts<代码>之类的函数来处理非POD类型，比如<代码> STD:：String ？或者它们被固定到不教你C++（即你不能使用STD:：vector）？@JjHagen--
这并不是说我们将来不能使用向量
--你现在应该使用向量，而不是“在未来”。其次，失败的原因是你被教导的
C
技术不起作用（例如
memset
），不要射击信使为了进一步说明@UnholySheep所说的内容，在这个特殊情况下，使用
memcpy
可能导致在免费发布后使用，因为
delete[]
将调用字符串上的析构函数，这意味着任何已分配其值的堆都将释放该数据。如果您尝试使用或删除[]

新的缓冲区。如果你想让人喜欢，你可以使用它来移动而不是复制字符串。小字符串优化可能不重要，但可能值得使用。不加解释的“试试这个”没有多大帮助。

arr[3] = 4;

#include<iostream>
#include<string.h>
using namespace std;
int *a;
int nCurrentSize =0;
void pushBack(int n)
{
  if(0 == nCurrentSize)
   {
    a= new int[1+nCurrentSize];
    a[nCurrentSize] = n;
   nCurrentSize++;
   }
   else
   {
     int *tmp = new int[nCurrentSize];
     memcpy(tmp,a,nCurrentSize*sizeof(int));
     delete []a;
     a= new int[1+nCurrentSize];
     memcpy(a,tmp,nCurrentSize*sizeof(int));
     a[nCurrentSize] = n;
     delete []tmp;
   nCurrentSize++;
    }
}
void display()
{
for(int i=0;i<nCurrentSize; i++)
  cout<<a[i]<<",";
}

int main()
{
pushBack(91);
pushBack(5);
pushBack(3);
pushBack(7);
pushBack(1);
pushBack(3);
pushBack(2);
pushBack(2);
pushBack(0);
pushBack(5); 

display();
cout<<endl<<nCurrentSize;
} 

int array_size = 1;
string *my_array = new string[array_size];

void add_to_array(string input_value, int &old_array_size) {

    int new_array_size = old_array_size + 1;

    string *temporary_array = new string[new_array_size];

    for(int i = 0; i < old_array_size; i++) {
        temporary_array[i] = my_array[i];
    }

    temporary_array[new_array_size - 1] = input_value;

    delete[] my_array;

    my_array = temporary_array;

    old_array_size++;

}