如何向 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 + + 中我不能这样做，它会给我一个编译器错误。你们有什么建议？

650604 次浏览
小开

Arrays in C++ cannot change size at runtime. For that purpose, you should use vector<int> instead.

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.

As mentioned in the comments, vector is defined in vector header and std namespace. To use it, you should:

#include <vector>

and also, either use std::vector in your code or add 

using std::vector;

or 

using namespace std;

after the #include <vector> line.

小开

Use a vector:

#include <vector>


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

There is no way to do what you say in C++ with plain arrays. The C++ solution for that is by using the STL library that gives you the std::vector.

You can use a vector in this way:

#include <vector>


std::vector< int > arr;


arr.push_back(1);
arr.push_back(2);
arr.push_back(3);
小开 
int arr[] = new int[15];

The variable arr holds a memory address. At the memory address, there are 15 consecutive ints in a row. They can be referenced with index 0 to 14 inclusive.

In php i can just do this arr[]=22; this will automatically add 22 to the next empty index of array.

There is no concept of 'next' when dealing with arrays.
One important thing that I think you are missing is that as soon as the array is created, all elements of the array already exist. They are uninitialized, but they all do exist already. So you aren't 'filling' the elements of the array as you go, they are already filled, just with uninitialized values. There is no way to test for an uninitialized element in an array.

It sounds like you want to use a data structure such as a queue or stack or vector.

小开

I fully agree with the vector way when implementing a dynamic array. However, bear in mind that STL provides you with a host of containers that cater to different runtime requirements.You should choose one with care. E.g: For fast insertion at back you have the choice between a vector and a deque.

And I almost forgot, with great power comes great responsibility :-) Since vectors are flexible in size, they often reallocate automagically to adjust for adding elements.So beware about iterator invalidation (yes, it applies as well to pointers). However, as long as you are using operator[] for accessing the individual elements you are safe.

小开

I may be missing the point of your question here, and if so I apologize. But, if you're not going to be deleting any items only adding them, why not simply assign a variable to the next empty slot? Every time you add a new value to the array, just increment the value to point to the next one.

In C++ a better solution is to use the standard library type std::list< type >, which also allows the array to grow dynamically, e.g.:

#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);
小开

If you are writing in C++ -- it is a way better to use data structures from standard library such as vector.

C-style arrays are very error-prone, and should be avoided whenever possible.

小开

Initialize all your array elements to null first, then look for the null to find the empty slot

小开

You don't have to use vectors. If you want to stick with plain arrays, you can do something like this:

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

Now, if you want to add an element to the end of the array, you can do this:

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

It's not as short and graceful as the PHP equivalent, but it accomplishes what you were attempting to do. To allow you to easily change the size of the array in the future, you can use a #define.

#define ARRAY_MAX 15


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


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

This makes it much easier to manage the array in the future. By changing 15 to 100, the array size will be changed properly in the whole program. Note that you will have to set the array to the maximum expected size, as you can't change it once the program is compiled. For example, if you have an array of size 100, you could never insert 101 elements.

If you will be using elements off the end of the array, you can do this:

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

If you want to be able to delete elements off the beginning, (ie a FIFO), the solution becomes more complicated. You need a beginning and end index as well.

#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.
}

Here, we are using the modulus operator (%) to cause the indexes to wrap. For example, (99 + 1) % 100 is 0 (a wrapping increment). And (99 + 99) % 100 is 98 (a wrapping decrement). This allows you to avoid if statements and make the code more efficient.

You can also quickly see how helpful the #define is as your code becomes more complex. Unfortunately, even with this solution, you could never insert over 100 items (or whatever maximum you set) in the array. You are also using 100 bytes of memory even if only 1 item is stored in the array.

This is the primary reason why others have recommended vectors. A vector is managed behind the scenes and new memory is allocated as the structure expands. It is still not as efficient as an array in situations where the data size is already known, but for most purposes the performance differences will not be important. There are trade-offs to each approach and it's best to know both.

小开

You can use a variable to count places in the array, so when ever you add a new element, you put it in the right place. For example:

int a = 0;
int arr[5] = { };
arr[a] = 6;
a++;
小开

Since I got so many negative feedback I realized my solution was wrong so i changed it.

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


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


push(6)

New array will contain value from 1 to 6 and you can make function for deletion like this as well.


提交答案