C++ 如何将元素添加到C++；阵列？

我想在数组中添加一个int，但问题是我现在不知道索引是什么

int[] arr = new int[15];
arr[0] = 1;
arr[1] = 2;
arr[2] = 3;
arr[3] = 4;
arr[4] = 5;

这段代码之所以有效，是因为我知道要分配给哪个索引，但如果我不知道该索引怎么办

---

在PHP中，我只需执行

arr[]=22，它将自动将22添加到数组的下一个空索引中。但是C++中我不能这样做，它给了我编译错误。你们建议什么？
 
 C++中的数组不能在运行时改变大小。为此，您应该改用
vector

vector<int> arr;
arr.push_back(1);
arr.push_back(2);

// arr.size() will be the number of elements in the vector at the moment.

或

在
#include
行之后。
使用向量：

#include <vector>

void foo() {
    std::vector <int> v;
    v.push_back( 1 );       // equivalent to v[0] = 1
}

#包括
void foo（）{
std：：向量v；
v、 向后推（1）；//相当于v[0]=1
}
 > > P> >在C++中，没有用简单数组来做的事情。C++的解决方案是使用STL库，它提供了.< /P>
可以通过以下方式使用
向量
：

#include <vector>

std::vector< int > arr;

arr.push_back(1);
arr.push_back(2);
arr.push_back(3);

#包括
std:：vectorarr；
arr.push_back（1）；
arr.push_back（2）；
arr.push_back（3）；

变量
arr
保存一个内存地址。在内存地址，一行中有15个连续整数。可以使用索引0到14（包括0到14）引用它们

在php中，我可以做到arr[]=22；
这将自动将22添加到
数组的下一个空索引

处理数组时没有“下一步”的概念。

我认为您缺少的一件重要事情是，一旦创建了数组，数组的所有元素都已经存在。它们尚未初始化，但都已存在。因此，您不会在执行时“填充”数组的元素，它们已经被填充了，只是使用了未初始化的值。无法在数组中测试未初始化的元素

听起来你想使用一个数据结构，比如or。
我完全同意在实现动态数组时使用
向量的方式。但是，请记住，STL为您提供了大量满足不同运行时需求的容器。您应该小心选择其中一个。例如：为了在背面快速插入，您可以在
向量
和
deque
之间进行选择

我几乎忘记了，强大的力量带来了巨大的责任：-）由于
向量在大小上是灵活的，它们经常自动重新分配以调整添加元素。所以要小心迭代器失效（是的，它也适用于指针）。但是，只要您使用
操作符[]
访问各个元素，您就安全了。
我可能没有抓住您问题的重点，如果是这样，我深表歉意。但是，如果您不打算删除任何项目而只是添加它们，为什么不简单地为下一个空槽分配一个变量呢？每次向数组添加新值时，只需增加该值以指向下一个值

C++中一个更好的解决方案是使用标准库类型<代码> STD::List< <类型> <代码>，这也允许数组动态增长，例如：

#include <list>

std::list<int> arr; 

for (int i = 0; i < 10; i++) 
{
    // add new value from 0 to 9 to next slot
    arr.push_back(i); 
}

// add arbitrary value to the next free slot
arr.push_back(22);

#包括
std：：列表arr；
对于（int i=0；i<10；i++）
{
//将新值从0到9添加到下一个插槽
arr.推回（i）；
}
//向下一个可用插槽添加任意值
arr.推回（22）；
<代码> > p>如果你用C++编写，那么它是一个更好的方法来使用标准库中的数据结构，比如vector。
C型数组非常容易出错，应尽可能避免使用。
首先将所有数组元素初始化为null，然后查找null以找到空插槽。
您不必使用向量。如果要坚持使用普通数组，可以执行以下操作：

int arr[] = new int[15];
unsigned int arr_length = 0;

现在，如果要向数组末尾添加元素，可以执行以下操作：

if (arr_length < 15) {
  arr[arr_length++] = <number>;
} else {
  // Handle a full array.
}

if (arr_length > 0) {
  int value = arr[arr_length--];
} else {
  // Handle empty array.
}

如果您希望能够从开头删除元素（即FIFO），解决方案将变得更加复杂。您还需要一个开始和结束索引

#define ARRAY_MAX 15

int arr[] = new int[ARRAY_MAX];
unsigned int arr_length = 0;
unsigned int arr_start = 0;
unsigned int arr_end = 0;

// Insert number at end.
if (arr_length < ARRAY_MAX) {
  arr[arr_end] = <number>;
  arr_end = (arr_end + 1) % ARRAY_MAX;
  arr_length ++;
} else {
  // Handle a full array.
}

// Read number from beginning.
if (arr_length > 0) {
  int value = arr[arr_start];
  arr_start = (arr_start + 1) % ARRAY_MAX;
  arr_length --;
} else {
  // Handle an empty array.
}

// Read number from end.
if (arr_length > 0) {
  int value = arr[arr_end];
  arr_end = (arr_end + ARRAY_MAX - 1) % ARRAY_MAX;
  arr_length --;
} else {
  // Handle an empty array.
}

#定义数组_最大15
int arr[]=新的int[ARRAY_MAX]；
无符号整数arr_长度=0；
无符号整数arr_start=0；
无符号整数arr_end=0；
//在末尾插入数字。
if（阵列长度<阵列最大值）{
arr[arr_end]=；
arr\u end=（arr\u end+1）%ARRAY\u MAX；
arr_长度++；
}否则{
//处理完整数组。
}
//从头读数字。
如果（arr_长度>0）{
int value=arr[arr_start]；
arr\u start=（arr\u start+1）%ARRAY\u MAX；
arr_长度--；
}否则{
//处理空数组。
}
//从末尾读出数字。
如果（arr_长度>0）{
int值=arr[arr_end]；
arr\u end=（arr\u end+数组最大值-1）%ARRAY\u MAX；
arr_长度--；
}否则{
//处理空数组。
}

在这里，我们使用模运算符（%）使索引换行。例如，（99+1）%100为0（换行增量）。（99+99）%100是98（包裹减量）。这允许您避免使用if语句，并使代码更加高效

随着代码变得越来越复杂，您还可以很快看到#define是多么有用。不幸的是，即使使用此解决方案，也无法在数组中插入超过100项（或设置的最大值）。即使阵列中只存储了1项，您也将使用100字节的内存

这是其他人推荐向量的主要原因。在后台管理一个向量，并随着结构的扩展分配新内存。在数据大小已知的情况下，它仍然不如数组有效，但在大多数情况下，性能差异并不重要。每种方法都有权衡，最好两者都知道。
您可以使用一个变量来计算数组中的位置，因此每次添加新元素时，都要将其放在正确的位置。例如：

inta=0；
int-arr[5]={}；
arr[a]=6；
a++；
因为我收到了太多的负面反馈，我意识到我的解决方案是错误的，所以我改变了它

int arr[20] = {1,2,3,4,5};
int index = 5;

void push(int n){
    arr[index] = n;
    index++;
}

push(6)

新数组将包含从1到6的值，您也可以像这样创建删除函数

int array arraySize = 25;   
int array[arraySize];
array[0] = 3;
array[1] = 9;
array[2] = 27;

如果您将阵列大小声明为25，则无法
if (arr_length > 0) {
  int value = arr[arr_length--];
} else {
  // Handle empty array.
}

#define ARRAY_MAX 15

int arr[] = new int[ARRAY_MAX];
unsigned int arr_length = 0;
unsigned int arr_start = 0;
unsigned int arr_end = 0;

// Insert number at end.
if (arr_length < ARRAY_MAX) {
  arr[arr_end] = <number>;
  arr_end = (arr_end + 1) % ARRAY_MAX;
  arr_length ++;
} else {
  // Handle a full array.
}

// Read number from beginning.
if (arr_length > 0) {
  int value = arr[arr_start];
  arr_start = (arr_start + 1) % ARRAY_MAX;
  arr_length --;
} else {
  // Handle an empty array.
}

// Read number from end.
if (arr_length > 0) {
  int value = arr[arr_end];
  arr_end = (arr_end + ARRAY_MAX - 1) % ARRAY_MAX;
  arr_length --;
} else {
  // Handle an empty array.
}

int arr[20] = {1,2,3,4,5};
int index = 5;

void push(int n){
    arr[index] = n;
    index++;
}

push(6)

int array arraySize = 25;   
int array[arraySize];
array[0] = 3;
array[1] = 9;
array[2] = 27;