Thread: length of dynamic array

how do I get the length (or size) of a dynamic array? tried this but I get 0

Code:

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


typedef struct a
{
	int age;
	char name[10];
} el;

int main (int argc, const char * argv[]) 
{
	int i,n;
	el *array;
	int d;

	printf("length :> ");
	scanf("%d",&n);	

	array = (el *) calloc (n,sizeof(el));

	


	printf("\nINPUT\n\n");
	for (i=0; i<n; i++)
	{
			printf("name %d. el :> ",i);
			scanf("%s", array[i]. name);
			printf("age %d. el :> ",i);
			scanf("%d",& array[i]. age);
	}
	
	printf("\nPRINTOUT\n\n");
	for (i=0; i<n; i++)
	{
			printf("%d. el :> NAME:\t%s\tAGE:\t%d\n",i, array[i]. name, array[i]. age);		
	}	
	
	d =  sizeof(array)/sizeof(el);
	
					printf("Length is :> %d",d);

	return 0;
}

Variable n is not initialized. The value of n * sizeof(el) will be how large array is - you have to keep track of that.

Code:

d =  sizeof(array)/sizeof(el);

This will not work since sizeof(array) is just the size of a pointer on your machine (probably 4 or 8 bytes depending on your CPU architecture). As Dino said, the only way to get the size is to use what you passed to calloc() or malloc().

I'll put it in simple words:
There is no (standard) way to calculate the length of a dynamic array in C.

If you really, really, really, really must do it, there are non-portable solutions.
Microsoft's compilers gives you the option of _msize.
Then you could use the OS's allocation APIs to allocate and find the size of it.

Another option is to store the size information in the data itself.

Code:

#include <stdlib.h>

size_t* b_element_size_ptr_( void* buf )
{
    return ( size_t* )( ( char* )buf - sizeof( size_t ) );
}

size_t* b_length_ptr_( void* buf )
{
    return ( size_t* )( ( char* )buf - ( sizeof( size_t ) << 1 ) );
}

void* b_allocate( size_t siz, size_t len )
{
    char*
        buf = malloc( siz * len + ( sizeof( size_t ) << 1 ) );
    if( buf )
    {
        buf += sizeof( size_t ) << 1;
        *b_element_size_ptr_( buf ) = siz;
        *b_length_ptr_( buf ) = len;
    }
    return buf;
}

void b_deallocate( void* buf )
{
    if( buf )
        free( b_length_ptr_( buf ) );
}

size_t b_length( void* buf )
{
    return *b_length_ptr_( buf );
}

size_t b_bytes( void* buf )
{
    return b_length( buf ) * *b_element_size_ptr_( buf );
}

Example:

Code:

#include <stdio.h>

int main( void )
{
    int*
        data = b_allocate( sizeof( int ), 1024 );
    if( data )
    {
        printf( "Length of data: %d\n", b_length( data ) );
        printf( "Size (in bytes): %d\n", b_bytes( data ) );
    }
    b_deallocate( data );
    return 0;
}

There's probably some OS specific system call you could make prior to the malloc, to determine your process's free memory, and then you could call it again after the malloc, and figure out the difference.

Sounds like a contrived class exercise to me.

This is just me thinking out loud... but perhaps you should just get a book on C and start with chapter 1 ... of course you will go through parts of it pretty quickly... but at least then you'll have all the required information...

In deference to Salem's obvious smarts... In this case I might suggest that your real problem is that you're trying to understand C as some sort of mystical subset of C# ... Believe me the language similarities are completely absent beyond the totally disastrous choices of names. If the big guns had been smart they would have followed their predicessor's lead and moved up the alphabet C++ would be E (D already existed) and when they got to C# they would have said "Oh F it"...

Learn C ... don't try to learn C as it applies to C#... Just learn the language on it's own merrits.