I want to copy and reverse a array in C pointer, but I found the result can only shown first 10 elements, why?
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
my func:
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;
}
}
main
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;
}
For starters the name of the function reverse_copy
only confuses readers because the function copies nothing. It reverses an array in place.
So it is better to name the function simply as reverse
.
Secondly, the function has the return type int *
but returns nothing. There is no sense to declare the return type of the function as int *
instead of void
provided that the function does not allocate dynamically a new array..
As a result this statement
B = reverse_copy(A, N);
does not make sense and invokes undefined behavior.
You allocated only one array that is pointed to by the pointer A. The pointer B does not point to a newly dynamically allocated array. So this statement
free(B);
again invokes undefined behavior.
Here is a demonstrative program that shows how the two functions, reverse
and reverse_copy
, can be implemented using pointers.
#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;
}
The program output is
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
An alternative and more flexible approach of implementation of the function reverse_copy
is to provide to the function an already existent/allocated array.
Here is a demonstrative program
#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;
}
The program output is
Original array: 0 1 2 3 4 5
Reversed array: 5 4 3 2 1 0 0 1 2 3 4 5