Как инвертировать массив и сохранить значения обращенного массива в новом массиве - PullRequest
Новая
       23

Как инвертировать массив и сохранить значения обращенного массива в новом массиве

0 голосов
/ 23 апреля 2020

Моя программа должна сделать следующее:

  1. Обратный массив (например, niz[] = { 2, 4, 5, 7, 4, 8, 3 } должен стать niz[] = { 3, 8, 4, 7, 5, 4, 2 }
  2. Сохранить значения обратного массива в бренд новый массив
  3. Все это должно быть сделано без использования printf внутри функции, которая переворачивает массив и сохраняет значения в новом массиве. Кроме того, массив и его размер должны быть предопределены (поэтому нет пользовательский ввод).
  4. Результат (в этом случае новый массив, содержащий обратные значения предыдущего массива) должен быть напечатан в main

Однако вместо обращая массив и сохраняя его в новом массиве и возвращая его. Программа всегда печатает следующие числа: 

6356668

Так кто-нибудь видит проблему в моем коде? 

int koko(int *array, int *array2, int c, int d) {
    for (c = 6; c > -1; c--, d++) {
        array2[d] = array[c];
    }
    return array2;
}

int main() {
    int niz[] = { 2, 4, 5, 7, 4, 8, 3 };
    int niz2[7];
    int a, b, c;
    c = koko(niz, niz2, a, b);
    printf("%d", c);
}

Ответы [ 4 ]

0 голосов
/ 23 апреля 2020

Вам не нужно передавать 4 аргумента в koko, достаточно только массивов и количества элементов. Также не сравнивайте с -1, запишите l oop как нисходящее l oop, которое останавливается на 0, таким образом, вы можете использовать типы индексов без знака, такие как size_t. Еще лучше использовать classi c l oop с исключенным индексом от 0 до length и сохранить исходный элемент в соответствующем целевом элементе.

Причина, по которой вы получаете одно бессмысленное число в качестве вывода если вы печатаете возвращаемое значение koko, которое набирается с ошибкой int, тогда как вы возвращаете указатель на целевой массив, и вы все равно не можете печатать массив таким образом, вы должны использовать al oop для итерации по массиву элементы.

Вот модифицированная версия: 

#include <stdio.h>

void koko(const int *array, int *array2, size_t length) {
    for (size_t i = 0; i < length; i++) {
        array2[length - 1 - i] = array[i];
    }
}

int main() {
    int niz[] = { 2, 4, 5, 7, 4, 8, 3 };
    size_t length = sizeof(niz) / sizeof(niz[0]);
    int niz2[length];
    koko(niz, niz2, length);
    for (size_t i = 0; i < length; i++) {
        printf("%d ", niz2[i]);
    }
    printf("\n");
    return 0;
}
0 голосов
/ 23 апреля 2020

Так кто-нибудь видит проблему в моем коде?

Да:

  • d получает унифицированный параметр c, так как вы никогда не инициализируете ее в области действия функции перед ее использованием, она вызывает неопределенное поведение .

  • Тип возврата koko неверен, если вы пытаются вернуть array2, фактически niz2, вам потребуется int* тип возвращаемого значения, а не int.

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

На основе вашего кода , вы можете сделать что-то вроде:

Запуск образца 

#include <stdio.h>

void koko(int *array, int *array2, size_t size) // pass the size of the array
{                                              // size_t more appropriate for object sizes  
    for (int j = 0; size > 0; size--, j++) // initialize j, you can use size as iterator
    {
        array2[j] = array[size - 1]; // changes made to array2 are permanent
    }
}

int main()
{
    int niz[] = {2, 4, 5, 7, 4, 8, 3};
    const size_t SIZE = sizeof(niz) / sizeof(niz[0]); // determine the size of the array
    int niz2[SIZE]; // same size as non reversed array

    koko(niz, niz2, SIZE);

    for (size_t i = 0; i < SIZE; i++) // test print the reversed array
        printf("%d", niz2[i]);
}
0 голосов
/ 23 апреля 2020

Поскольку вы используете новый массив в качестве аргумента функции koko, вам не нужно его возвращать. Если вы хотите вернуть его, вы должны изменить тип возврата с int на int *.

В koko функции, d всегда должен начинаться с 0, так что вы делаете не нужно объявлять это как аргумент этой функции. Давайте объявим его как локальную переменную в этой функции.

c является одним из итераторов for l oop, поэтому давайте объявим его в этой функции с начальным значением, равным size - 1 ( size - это размер массива или количество элементов в этом массиве.)

Кстати, эта функция выглядит следующим образом: 

void koko(int *array,int *array2,int size)
{
    int d = 0;
    int c;
    for(c = size - 1;c>-1;c--,d++)
    {
        array2[d]=array[c];
    }
}

Для использования этой функции в основном, вы просто нужно указать два массива и размер массива (7 в данном случае): 

 koko(niz,niz2,7);

Полный код для тестирования: 

#include <stdio.h>

void koko(int *array,int *array2,int size)
{
    int d = 0;
    int c;
    for(c = size - 1;c>-1;c--,d++)
    {
        array2[d]=array[c];
    }
}

int main()
{
    int niz[]={2, 4, 5, 7, 4, 8, 3};
    int niz2[7];
    koko(niz,niz2,7);
    for(int i = 0; i <7; i++)
        printf("%d ",niz2[i]);
}

Вывод: 

3 8 4 7 5 4 2
0 голосов
/ 23 апреля 2020

Тип возвращаемого значения функции неправильный. 

int koko(int *array,int *array2,int c,int d)
{
for(c=6;c>-1;c--,d++)
{
    array2[d]=array[c];
}
return array2;
}

Возвращаемое выражение имеет тип int *, а тип возвращаемого значения - int.

И этот вызов 

c=koko(niz,niz2,a,b);

не имеет смысла, потому что переменные a и b неинициализированы.

Также этот единственный вызов функции printf

printf("%d", c);

имеет ничего общего с выводом всего массива результатов.

Кажется, вам нужно следующее: 

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

int * reverse( const int *a, size_t n )
{
    int *result = malloc( n * sizeof( int ) );

    if ( result != NULL )
    {
        for ( size_t i = 0; i < n; i++ )
        {
            result[i] = a[n - i - 1];
        }
    }

    return result;
}

int main(void) 
{
    int a[] = { 2, 4, 5, 7, 4, 8, 3 };
    const size_t N = sizeof( a ) / sizeof( *a );

    int *b = reverse( a, N );

    if ( b != NULL )
    {
        for ( size_t i = 0; i < N; i++ )
        {
            printf( "%d ", b[i] );
        }

        putchar( '\n' );
    }

    free( b );

    return 0;
}

Вывод программы: 

3 8 4 7 5 4 2

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

#include <stdio.h>

void reverse_copy( const int *a, size_t n, int *b )
{
    const int *p = a + n;

    while ( p-- != a )
    {
        *b++ = *p;
    }
}

int main(void) 
{
    enum { N = 7 };
    int a[N] = { 2, 4, 5, 7, 4, 8, 3 };
    int b[N];

    reverse_copy( a, N, b );

    for ( size_t i = 0; i < N; i++ )
    {
        printf( "%d ", b[i] );
    }

    putchar( '\n' );

    return 0;
}

Вывод программы будет таким же, как показано выше . 

3 8 4 7 5 4 2

Без введения какой-либо дополнительной переменной (которая фактически является избыточной) в функцию ее можно определить следующим образом: 

void reverse_copy( const int *a, size_t n, int *b )
{
    while ( n-- )
    {
        *b++ = a[n];
    }
}

Как вы можете видеть, внутри функции используются только его номинал ameters.

Кстати, рекурсивная функция может выглядеть следующим образом. :)

#include <stdio.h>

void reverse_copy( const int *a, size_t n, int *b )
{
    if ( n )
    {
        *b = a[n-1];
        reverse_copy( a, n - 1, b + 1 );
    }
}

int main(void) 
{
    enum { N = 7 };
    int a[N] = { 2, 4, 5, 7, 4, 8, 3 };
    int b[N];

    reverse_copy( a, N, b );

    for ( size_t i = 0; i < N; i++ )
    {
        printf( "%d ", b[i] );
    }

    putchar( '\n' );

    return 0;
}

И снова ее вывод равен 

3 8 4 7 5 4 2
...