数据结构C语言实现数组

头文件

#ifndef ARRAYHEAD_H_INCLUDED
#define ARRAYHEAD_H_INCLUDED

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

#define MAX_DIM 8

typedef struct
{
int* base ;
int dim ;
int* bounds ;
int* constants ;
} Array ;

int InitArray( Array* A , int dim , ... ) ;
int DestroyArray( Array* A ) ;
int LocateArray( Array* A , int* off , va_list Loc_dim ) ;
int GetValue( Array* A , int* elem , ... ) ;
int SetValue( Array* A , int* elem , ... ) ;

#endif // ARRAYHEAD_H_INCLUDED

函数实现

#include "arrayhead.h"

int InitArray( Array* A , int dim , ... )
{
if( dim < 0 || dim > MAX_DIM )
{
printf( "DIM ERROR!\n" ) ;
exit( 1 ) ;
}
A->dim = dim ;

A->bounds = ( int* )malloc( dim * sizeof( int ) ) ;
if( !A->bounds )
{
printf( "BOUNDS ERROR!\n" ) ;
exit( 1 ) ;
}

int TotalElem = 1 ;
va_list len_dim ;
va_start( len_dim , dim ) ;
int i ;
for( i = 0 ; i < dim ; i++ )
{
A->bounds[i] = va_arg( len_dim , int ) ;
if( A->bounds[i] <= 0 )
{
printf( "BOUNDS ILLEGAL!\n" ) ;
exit( 1 ) ;
}
TotalElem *= A->bounds[i] ;
}
va_end( len_dim ) ;

A->base = ( int* )malloc( TotalElem * sizeof( int ) ) ;
if( !A->base )
{
printf( "BASE ERROR!\n" ) ;
exit( 1 ) ;
}

A->constants = ( int* )malloc( dim * sizeof( int ) ) ;
if( !A->constants )
{
printf( "CONSTANTS ERROR!\n" ) ;
exit( 1 ) ;
}

A->constants[dim -1] = 1 * sizeof( int ) ;
for( i = dim - 2 ; i >= 0 ; i-- )
{
A->constants[i] = A->constants[i + 1] * A->bounds[i + 1] ;
}

return 0 ;
}

int DestroyArray( Array* A )
{
if( !A->base )
{
exit( 1 ) ;
}
free( A->base ) ;
A->base = NULL ;

if( !A->bounds )
{
exit( 1 ) ;
}
free( A->bounds ) ;
A->bounds = NULL ;

if( !A->constants )
{
exit( 1 ) ;
}
free( A->constants ) ;
A->constants = NULL ;

A->dim = 0 ;
return 0 ;
}

int LocateArray( Array* A , int* off , va_list Loc_dim )
{
*off = 0 ;
int i ;
int posdim = -1 ;
for( i = 0 ; i < A->dim ; i++ )
{
posdim = va_arg( Loc_dim , int ) ;
if( posdim < 0 || posdim >= A->bounds[i] )
{
printf( "LOCATION ERROR!\n" ) ;
exit( 1 ) ;
}
off = off + posdim * A->constants[i] ;
}
return 0 ;
}

int GetValue( Array* A , int* elem , ... )
{
va_list Off_Loc ;
va_start( Off_Loc , elem ) ;
int off = 0 ;
LocateArray( A , &off , Off_Loc ) ;
va_end( Off_Loc ) ;
*elem = *( A->base + off ) ;
return 0 ;
}
int SetValue( Array* A , int* elem , ... )
{
va_list Off_Loc ;
va_start( Off_Loc , elem ) ;
int off = 0 ;
LocateArray( A , &off , Off_Loc ) ;
va_end( Off_Loc ) ;
*( A->base + off ) = *elem ;
return 0 ;
}

main函数测试

#include "arrayhead.h"

int main()
{
Array A ;
int elem = 20 ;
int e = 0 ;
InitArray( &A , 3 , 5 , 6 , 7 , 8 ) ;
printf( "%d\n" , A.dim ) ;
SetValue( &A , &elem , 4 , 5 , 6 ) ;
GetValue( &A , &e , 4 , 5 , 6 ) ;
printf( "%d\n" , e ) ;
return 0 ;
}

总结：因为数组主要是存取和修改的操作，而没有增删的操作，所以使用顺序结构存储。对多维数组是一个随机存取的结构。