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 ++에서 말하는 것을 수행 할 수있는 방법은 없습니다. 이를위한 C ++ 솔루션은 std::vector.

다음 vector과 같이 사용할 수 있습니다 .

std::vector< int > arr;

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

---

C ++의 배열은 런타임에 크기를 변경할 수 없습니다. 이를 위해 vector<int>대신 사용해야 합니다.

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.

주석에서 언급했듯이 헤더와 네임 스페이스에 vector정의되어 있습니다. 사용하려면 다음을 수행해야합니다.vectorstd

#include <vector>

또한 std::vector코드에서 사용 하거나

using std::vector; 

또는

using namespace std;

#include <vector>줄 뒤에 .

---

벡터 사용 :

#include <vector>

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

---

int arr[] = new int[15];

변수 arr는 메모리 주소를 보유합니다. 메모리 주소에는 15 개의 연속 된 int가 연속되어 있습니다. 인덱스 0에서 14까지 참조 할 수 있습니다.

PHP에서 나는 이것을 할 수있다 arr [] = 22; 이것은 배열의 다음 빈 인덱스에 22를 자동으로 추가합니다.

배열을 다룰 때 'next'라는 개념이 없습니다.
내가 생각하는 한 가지 중요한 것은 배열이 생성 되 자마자 배열의 모든 요소가 이미 존재한다는 것입니다. 초기화되지 않았지만 모두 이미 존재합니다. 따라서 배열의 요소를 '채울'것이 아니라 이미 초기화되지 않은 값으로 채워져 있습니다. 배열에서 초기화되지 않은 요소를 테스트 할 방법은 없습니다.

큐 , 스택 또는 벡터 와 같은 데이터 구조를 사용하려는 것 같습니다 .

---

벡터를 사용할 필요가 없습니다. 일반 배열을 고수하려면 다음과 같이 할 수 있습니다.

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

이제 배열 끝에 요소를 추가하려는 경우 다음을 수행 할 수 있습니다.

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

PHP에 해당하는 것만 큼 짧고 우아하지는 않지만 시도한 작업을 수행합니다. 나중에 배열의 크기를 쉽게 변경할 수 있도록 #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.
}

이를 통해 향후 어레이를 훨씬 쉽게 관리 할 수 ​​있습니다. 15에서 100으로 변경하면 전체 프로그램에서 배열 크기가 올바르게 변경됩니다. 프로그램이 컴파일 된 후에는 변경할 수 없으므로 배열을 예상되는 최대 크기로 설정해야합니다. 예를 들어, 크기가 100 인 배열이있는 경우 101 개의 요소를 삽입 할 수 없습니다.

배열 끝에서 요소를 사용하는 경우 다음을 수행 할 수 있습니다.

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

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.

---

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.

---

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

---

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.

---

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.

ReferenceURL : https://stackoverflow.com/questions/755835/how-to-add-element-to-c-array