Удалите элемент массива и сдвиньте остальные

Ответ 1

Вам просто нужно перезаписать то, что вы удаляете, со следующим значением в массиве, распространить это изменение и затем иметь в виду, где новый конец:

int array[] = {1, 2, 3, 4, 5, 6, 7, 8, 9};

// delete 3 (index 2)
for (int i = 2; i < 8; ++i)
    array[i] = array[i + 1]; // copy next element left

Теперь ваш массив {1, 2, 4, 5, 6, 7, 8, 9, 9}. Вы не можете удалить дополнительный 9, так как это массив статического размера, вам просто нужно его игнорировать. Это можно сделать с помощью std::copy:

std::copy(array + 3, // copy everything starting here
          array + 9, // and ending here, not including it,
          array + 2) // to this destination

В С++ 11 вместо этого используйте std::move (перегрузка алгоритма, а не перегрузка утилиты).

В общем случае используйте std::remove для удаления элементов, соответствующих значению:

// remove *all* 3's, return new ending (remaining elements unspecified)
auto arrayEnd = std::remove(std::begin(array), std::end(array), 3);

В более общем случае существует std::remove_if.

Обратите внимание, что использование std::vector<int> может быть здесь более подходящим, так как это "истинный" динамически распределенный массив изменения размера. (В том смысле, что запрос его size() отражает удаленные элементы.)

Ответ 2

Вы можете использовать memmove(), но вы должны сами отслеживать размер массива:

size_t array_size = 5;
int array[5] = {1, 2, 3, 4, 5};

// delete element at index 2
memmove(array + 2, array + 3, (array_size - 2 - 1) * sizeof(int));
array_size--;

В С++, однако, было бы лучше использовать std::vector:

std::vector<int> array;
// initialize array...

// delete element at index 2
array.erase(array.begin() + 2);

Ответ 3

std:: copy выполняет задание в отношении движущихся элементов:

 #include <algorithm>

 std::copy(array+3, array+5, array+2);

Обратите внимание, что предварительным условием для копирования является то, что пункт назначения не должен находиться в исходном диапазоне. Это допустимо для перекрытия диапазонов.

Кроме того, из-за того, как массивы работают на С++, это не "сокращает" массив. Он просто перемещает элементы внутри него. Невозможно изменить размер массива, но если вы используете отдельное целое число для отслеживания своего "размера", что означает размер части, о которой вы заботитесь, вы можете, конечно, уменьшить ее.

Итак, массив, в котором вы закончите, будет таким, как если бы он был инициализирован:

int array[] = {1,2,4,5,5};

Ответ 4

Вы не можете добиться того, чего хотите с помощью массивов. Вместо этого используйте векторы и прочитайте об алгоритме std:: remove. Что-то вроде:

std::remove(array, array+5, 3)

будет работать над вашим массивом, но он не сократит его (почему - потому что это невозможно). С векторами это будет что-то вроде

v.erase(std::remove(v.begin(), v.end(), 3), v.end())

Ответ 5

В зависимости от ваших требований вы можете использовать stl-списки для этих типов операций. Вы можете выполнять итерацию через свой список, пока не найдете элемент, и не удалите элемент. Если вы не можете использовать списки, вам придется переложить все самостоятельно, либо с помощью какого-либо алгоритма stl, либо вручную.

Ответ 6

Если вас больше всего беспокоит размер и/или производительность кода (также для анализа WCET, если он вам нужен), я думаю, что это, вероятно, будет одним из наиболее прозрачных решений (для поиска и удаления элементов):

unsigned int l=0, removed=0;

for( unsigned int i=0; i<count; i++ ) {
    if( array[i] != to_remove )
        array[l++] = array[i];
    else
        removed++;
}

count -= removed;

Ответ 7

Как раз так, обратите внимание: если требование сохранения порядка элементов ослаблено, гораздо эффективнее заменить элемент, удаляемый последним элементом.

Ответ 8

Программирование концентратор случайным образом предоставил фрагмент кода, который фактически делает уменьшить длину массива

for (i = position_to_remove; i < length_of_array; ++i) {
        inputarray[i] = inputarray[i + 1];
}

Не уверен, что это поведение, которое было добавлено только позже. Это делает трюк, хотя.