На месте против возврата Новые шаблоны проектирования в C

Question

Исходя из языков более высокого уровня, я пытаюсь успокоиться, изучая c. Я пытаюсь понять указатели и распределение памяти (то, о чем мне никогда не приходилось думать раньше).

Код, который я пытаюсь

#include <stdio.h>

int main()
{

    int array[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52 };

    printf("\nShuffling...\n\n");
    shuffle(array, sizeof(array)/sizeof(int));

    int i;
    for(i = 0; i < sizeof(array)/sizeof(int); i++)
    {
        printf("%d\n", array[i]);
    }

}

int shuffle(int *shuffle_array, int length)
{
    int i, j, newArray[length];
    for(i = 0, j = length; i < length; j--, i++)
    {
        newArray[i] = shuffle_array[j];
    }

    shuffle_array = newArray;
}

Сначала , это не работает, и я пытаюсь выяснить, почему массив не переворачивается при печати. ​​

Второй , сравнивающий концепцию редактирования на месте с возвратом нового элемента в c с использованием malloc() и free().

Answer 1

Внутри shuffle вы создаете массив с именем newArray в стеке (что означает, что он будет освобожден после завершения функции).

Затем вы помещаете каждый предмет из shuffle_array в newArray в обратном направлении.

Затем вы создаете указатель shuffle_array, локальная переменная (что означает, что изменения в ней не отражаются вне функции), указывают на первый элемент newArray. Это ничего не меняет за пределами shuffle, потому что shuffle_array является локальной переменной.

После возврата функции ничего не произошло за пределами функции. Это потому, что вы просто изменяете локальные данные с помощью shuffle.

Чтобы перетасовать массив (или перевернуть его, или сделать с ним что-нибудь), вы должны изменить его напрямую, а не изменять копию. Так и должно быть

int tmp = shuffle_array[i];
shuffle_array[i] = shuffle_array[j];
shuffle_array[j] = tmp;

Так что вы меняете два значения элементов массива, на которых находитесь. Даже если shuffle_array является временной переменной, она указывает на блок памяти в main, поэтому изменение этой памяти видно даже после возврата из функции.

Вы можете визуализировать это так:

in main:

array  - - - - 
               \
                \
                 1, 2, 3, 4, 5, ...,  52 };

когда shuffle вызывается:

array  - - - - 
               \
                \
                 1, 2, 3, 4, 5, ...,  52
                /
               /
              /
shuffle_array

newArray - - -
              \
               52, ..., 5, 4, 3, 2, 1

Тогда, когда вы делаете

shuffle_array = newArray;

Похоже,

array  - - - - 
               \
                \
                 1, 2, 3, 4, 5, ...,  52



shuffle_array -
               \
newArray - - -  |
              \ /
               52, ..., 5, 4, 3, 2, 1

Затем shuffle возвращается, и все возвращается к

array  - - - - 
               \
                \
                 1, 2, 3, 4, 5, ...,  52

Answer 2

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

Вы должны memcpy вернуться через shuffle_array ...

memcpy( shuffle_array, newArray, length * sizeof( int ) );

Более того, вытакже начинаем чтение с конца shuffle_array.Последний элемент в массиве - это «длина -1».

Редактировать : чтение конца массива не обязательно вызовет проблему.Просто то, что вы делаете, это неопределенное поведение.

Причина, по которой вы видите, что возвращаются те же данные, что и вы, заключается в том, что вы на самом деле не изменяете данные вообще.

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

for(i = 0, j = (length - 1); i < j; j--, i++)
{
    int temp = shuffle_array[i];
    shuffle_array[i] = shuffleArray[j];
    shuffle_array[j] = temp;
}

Таким образом, вы полностью избежите необходимости в отдельном массиве и последнем копировании.Вы также сохраняете загрузку стековой памяти.На мой взгляд, все вокруг.

Answer 3

newArray выделяется в стеке и будет освобожден после выхода из shuffle -> shuffle_array будет указывать на мусор.

Вы передаете указатель, а не ссылку на указатель (или указатель на указатель), поэтому ваш результат не будет возвращен основному -> без изменений после случайного воспроизведения.

Как насчет этого решения:

//note, the returned array needs to be freed using free();
int *newShuffledArray(int *shuffle_array, int length)
{
    int i, j;
    int *newArray = malloc(length * sizeof(int));
    for(i = 0, j = length-1; i < length-1; j--, i++)
    {
        newArray[i] = shuffle_array[j];
    }
    return newArray;
}

Answer 4

FWIW, это будет намного эффективнее (я предпочитаю решения для кода).

#include <stdio.h>
#include <stdlib.h>

void shuffle(int *shuffle_array, int length)
{
        int i, j, tmp;
        for (i = 0, j = length - 1; i < j; ++i, --j) {
                tmp = shuffle_array[i];
                shuffle_array[i] = shuffle_array[j];
                shuffle_array[j] = tmp;
        }
}

int main(void)
{
        int i, array[] = {
                1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
                11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
                21, 22, 23, 24, 25, 26, 27, 28, 29, 30,
                31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
                41, 42, 43, 44, 45, 46, 47, 48, 49, 50,
                51, 52
        }, length = sizeof(array) / sizeof(int);
        shuffle(array, length);
        for (i = 0; i < length; ++i) {
                printf("%d\n", array[i]);
        }
        return EXIT_SUCCESS;
}

Как уже упоминалось, проблема с вашей программой заключалась в том, что вы присваивали свой результат локальной переменной.

Answer 5

Вы вообще ничего не меняете.Вы устанавливаете только локальную переменную, чего вы ожидали?;)

#include <stdio.h>

void foo(int* a) {
    ++a;
}

int main(void) {
    int array[3] = {1,2,3};
    foo(array);
    for (int i = 0; i < 3; ++i)
        printf("%d\n", array[i]); // results in 1\n2\n3\n, not 2\n3\nSegmentation fault\n
}

Answer 6

1) Вы назначаете из массива в стеке. Эти данные не будут там, когда функция вернется.

2) Мне интересно, почему

shuffle_array = newArray

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

3) Вам нужно будет присвоить значения локальных массивов обратно массиву, переданному с помощью цикла for или memcpy.