c - 为什么我的新数组只复制并反转旧数组的前 10 个元素？

Question

我想复制并反转C指针中的数组，但我发现结果只能显示前10个元素，为什么？

Original array: 0 1 4 9 16 25 36 49 64 81 100 121 144 169 196 225 256 289 324 361
Reversed array: 81 64 49 36 25 16 9 4 1 0 29274861 12333 14041000 14036848 0 0 14036820 0 14036816 0

我的功能:

int * reverse_copy(int *A, int N) { 
    int *B,tmp; 
    for (B=A+N-1;A<B;A++,B--){
      tmp=*A;
      *A=*B;
      *B=tmp;
    }
}

主要内容

int * reverse_copy(int *A, int N);  
int main(int argc, char *argv[]) {   
    int N = 20;int i;int *A = NULL, *B = NULL;   
    if (argc > 1)   // first command line parameter
        N = atoi(argv[1]);  
    // allocate, fill, and print input array
    A = (int*) malloc(N * sizeof(int));
    for (i = 0; i < N; i++)
        A[i] = i*i;       
    // call task function
    B = reverse_copy(A, N);     
    // free allocated memory
    free(A);
    free(B);
    return 0;
}   

Answer 1

对于初学者来说，函数 reverse_copy 的名称只会让读者感到困惑，因为该函数不复制任何内容。它就地反转数组。

因此最好将函数简单地命名为reverse。

其次，该函数的返回类型为int *，但不返回任何内容。如果函数不动态分配新数组，则将函数的返回类型声明为 int * 而不是 void 是没有意义的。

因此这个声明

B = reverse_copy(A, N);

没有意义并调用未定义的行为。

您只分配了一个由指针 A 指向的数组。指针 B 并不指向新动态分配的数组。所以这个说法

free(B);

再次调用未定义的行为。

这是一个演示程序，展示了如何使用指针实现两个函数:reverse 和 reverse_copy。

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

void reverse( int *a, size_t n )
{
    if ( n != 0 )
    {
        for ( int *b = a + n; a < --b; ++a )
        {
            int tmp = *a;
            *a = *b;
            *b = tmp;
        }
    }
}

int * reverse_copy( const int *a, size_t n )
{
    int *b = NULL;

    if ( n != 0 )
    {
        b = malloc( n * sizeof( int ) );

        for ( int *p = b + n; p-- != b; ++a )
        {
            *p = *a; 
        }
    }

    return b;
}

int main(void) 
{
    int a[] = 
    { 
        0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100, 121, 144, 169, 196, 225, 256, 289, 324, 361 
    };

    const size_t N = sizeof( a ) / sizeof( *a );

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

    putchar( '\n' );

    reverse( a, N );

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

    putchar( '\n' );

    putchar( '\n' );

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

    putchar( '\n' );

    int *b = reverse_copy( a, N );

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

    putchar( '\n' );

    free( b );

    return 0;
}

程序输出为

Original array: 0 1 4 9 16 25 36 49 64 81 100 121 144 169 196 225 256 289 324 361 
Reversed array: 361 324 289 256 225 196 169 144 121 100 81 64 49 36 25 16 9 4 1 0 

Original array: 361 324 289 256 225 196 169 144 121 100 81 64 49 36 25 16 9 4 1 0 
Reversed array: 0 1 4 9 16 25 36 49 64 81 100 121 144 169 196 225 256 289 324 361

实现函数reverse_copy的另一种更灵活的方法是向函数提供一个已经存在/分配的数组。

这是一个演示程序

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

int * reverse_copy( const int *a, size_t n, int *b )
{
    for ( const int *p = a + n; p != a; ++b )
    {
        *b = *--p;
    }

    return b;
}

int main(void) 
{
    int a[] = { 0, 1, 2, 3, 4, 5 };

    const size_t N = sizeof( a ) / sizeof( *a );

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

    putchar( '\n' );


    int *b = malloc( 2 * N * sizeof( int ) );

    int *p = reverse_copy( a, N, b );;

    for ( const int *q = a; q != a + N; ++q, ++p )
    {
        *p = *q;
    }

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

    putchar( '\n' );

    free( b );

    return 0;
}

程序输出为

Original array: 0 1 2 3 4 5 
Reversed array: 5 4 3 2 1 0 0 1 2 3 4 5