为什么我的新数组只复制并反转旧数组的前 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 

Answer 2

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

void 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 main(void) {

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

  reverse_copy(numbers, 20);

  for( int i = 0; i < 20; i++ ) {
    printf("%d ", numbers[i]);
  }
  return 0;
}

我假设您并不真正想要一个新数组，并且您想要反转现有数组中的数字，否则为什么不使用 for 循环从旧数组向后复制呢？因此我猜测您希望

reverse_copy

返回

void

，即不返回任何内容。

除了返回类型之外，你的函数似乎工作正常（尽管以一种奇怪和危险的方式，我不会编写一个在任何输入指针上实际执行

++

的函数）。

编辑：现在我看到了你的主要内容，如果你想要一个新数组，这就是你编写整个内容的方式：

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

void reverse_copy(int *A, int * B, int N) { 
    for (int i = N-1;i>0;i--){
      B[N-i-1]=A[i];
    }
}

int main(void) {

  const int kLen = 20;
  int* A;
  int* B;
  A = (int*) malloc(kLen * sizeof(int));
  B = (int*) malloc(kLen * sizeof(int));

  for (int i = 0; i < kLen; i++){
    A[i] = i; 
  }

  reverse_copy(A, B, kLen);

  printf("A:");
  for( int i = 0; i < kLen; i++ ) {
    printf("%d ", A[i]);
  }

  printf("\nB:");
  for( int i = 0; i < kLen; i++ ) {
    printf("%d ", B[i]);
  }
  printf("\n");

  free(A);
  free(B);

  return 0;
}