Быстрый способ скопировать массив

Question

Итак, в конце каждой итерации, которую я делаю, я хочу, чтобы мой массив был равен моему новому массиву (который я назвал array_new). Я хочу, чтобы каждый элемент массива принимал то же значение, что и в array_new, но я заинтересован в том, чтобы как можно быстрее получить мой код и, таким образом, копировать все по элементам, поскольку этот текущий код не является вариантом:

for(i=0;i<N_a;i++) { 
    for(j=0;j<N_b;j++) { 
    array[i][j] = array_new[i][j]; 
    } 
} 

Это занимает довольно много времени, потому что мои значения N_a и N_b очень велики. Есть ли способ просто изменить то, что каждый из них указывает, чтобы я мог быстрее начать свою следующую итерацию? Я пытался делать такие вещи, как

double *temp = *array; 
*array = *array_new; 
*array_new = temp; 

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

Любая помощь была бы высоко оценена!

Answer 1

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

В c/c++ вы можете использовать memcpy, если это тот язык, который вы используете. У каждого языка есть что-то эквивалентное.

Edit: так как вы подтвердили использование c я могу получить более подробным:

memcpy(array_new,array,sizeof(VARIABLE_TYPE_of_ARRAY_ELEMENT)*N_a*N_b); 

Answer 2

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

//array is declared as 
double (*array)[N_b]; 

double (*temp)[N_b] = array; 
array = array_new; 
array_new = temp; 

или

//array is declared as 
double** array; 

double** temp = array; 
array = array_new; 
array_new = temp; 

Это все, что вам нужно, и это, безусловно, самый быстрый возможный способ обмена содержимым двух буферов. Гораздо быстрее, чем memcpy() ...

Answer 3

Два ответа на этот вопрос сначала вам нужно понять, как массив представлен в памяти. Например. см. этот вопрос: How are multi-dimensional arrays formatted in memory?

Итак, сначала нам нужно знать, есть ли у вас статический массив или нет. Если это статический массив, то задача особенно проста, потому что данные размещаются последовательно в памяти. Это означает, что если у вас есть 2х2 статический массив, с содержанием {{9, 8}, {7, 6}} ваша память может выглядеть следующим образом:

Address 0 1 2 3 4 5 6 7 8 
Content ? ? 9 8 7 6 ? ? ? 

В этом случае переменную, которая объявлена ​​как это:

int[2][2] myArray; 

на самом деле указатель на адрес «2», и вы можете легко скопировать все это.с тетсру:

int [2][2] newArray; 
memcpy(&newArray, &myArray, sizeof(int)*2*2); 

Обратите внимание, что это копии, начиная с Wherever "MyArray" точек (в моем примере это 2) столько байт, как 2 * 2 * SizeOf (INT). Таким образом, в 4 раза больше инт. (Для простоты мой пример предполагает размер одного байта для int, но, конечно, в большинстве систем он равен 4 байтам).

Если у вас есть динамический массив, то это совсем другая история. В этом случае ваша память для массива объявлен как это:

int** myArray; 

также может выглядеть следующим образом:

Address 0 1 2 3 4 5 6 7 8 
Content 9 8 0 6 ? ? 7 6 ? 

Обратите внимание, что указатель myArray все еще указывает на адрес «2». Однако по адресу «2» вы не найдете первое значение, а вместо этого указатель указывает на «0». И здесь вы найдете значения первой «строки», которые равны 9 и 8. Рядом с адресом «2» в номере «3» вы найдете указатель на свою вторую «строку», которая начинается с позиции 6. Как вы можете см., вы все равно можете найти все свои данные, но вы не можете скопировать их за один раз. Для того, чтобы скопировать весь массив, по крайней мере, нужно внешний ряд:

int SIZE_X = 2; 
int SIZE_Y = 2; 
int** newArray = malloc(sizeof(int*)*SIZE_X); 
for(i = 0; i < SIZE_X; ++i) { 
    newArray[i] = malloc(sizeof(int)*SIZE_Y); 
    memcpy(newArray[i], myArray, SIZE_Y*sizeof(int)); 
} 

Это должно быть быстрее, чем с помощью двух петель, если memcpy can use more efficient ways to copy than a copy loop.

Answer 4

Если вы просто хотите поменять местами указатели, физически не копируя данные, и по-прежнему быть в состоянии получить доступ массивы с помощью индексов, вот пример того, как это можно сделать:

#define N_a 2 
#define N_b 3 

typedef struct arr 
{ 
    int val[N_a][N_b]; 
} arr; 

arr array  = {{{11,12,13},{14,15,16}}}; 
arr array_new = {{{21,22,23},{24,25,26}}}; 

int main() 
{ 
    arr *p_array; 
    arr *p_array_new; 

    p_array  = &array; 
    p_array_new = &array_new; 
    printf("%d %d\n", p_array->val[1][2], p_array_new->val[1][2]); 
    // output: 16 26 

    p_array  = &array_new; 
    p_array_new = &array; 
    printf("%d %d\n", p_array->val[1][2], p_array_new->val[1][2]); 
    // output: 26 16 
}