小小笔记

/**
 *@test memory organization
 */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>

#define FREE(p) {if(p){ free(p);p = NULL;}}

typedef struct _string_s
{
    char *content;
    int len ;
}string_s;

typedef struct _strcoll_s
{
    string_s *array;
    int count;
    int poolsize;
}strcoll_s;

typedef struct _coll_s
{
    void *array;
    int count;
    int poolsize;
}coll_s;

static void *ab_malloc(size_t size);

static void *ab_realloc(void *ptr,size_t size);

static void *ab_calloc(size_t nmemb,size_t size);

static void string_destroy(string_s *string);

static void string_destroy_content(string_s *string);

static void strcoll_destroy_one(strcoll_s *collector);

static void strcoll_destroy_two(strcoll_s *collectro);

static strcoll_s *strcoll_init(int poolsize);

static void strcoll_add(strcoll_s *collector,string_s *string);

static void strcoll_display(strcoll_s *collector);
static void test_strcoll();


int main(int argc,char *argv[])
{
    test_strcoll();

    return 0;   
}

static void test_strcoll()
{
    strcoll_s *collector = strcoll_init(10);
   
    string_s *str1 = ab_calloc(1,sizeof(string_s));
    str1->content = ab_calloc(10,sizeof(char));
    strcpy(str1->content,"zhang");
    strcoll_add(collector,str1);
    FREE(str1);
   
    string_s *str2 = ab_calloc(2,sizeof(string_s));
    str2->content = ab_calloc(10,sizeof(char));
    strcpy(str2->content,"bufeng");
    strcoll_add(collector,str2);
    FREE(str2);
   
    strcoll_display(collector);
   
    strcoll_destroy_two(collector);
}

static void string_destroy(string_s *string)
{
    assert(string != NULL);

    string_destroy_content(string);
    FREE(string);
}

static void string_destroy_content(string_s *string)
{
    assert(string != NULL);

    FREE(string->content);
}

/**
 *@brief this destroy method is right
 */
static void strcoll_destroy_one(strcoll_s *collector)
{
    assert(collector != NULL);
   
    int i = 0;
    for(i = 0;i < collector->count;i++)
        string_destroy_content(collector->array + i);
   
    FREE(collector->array);   
   
    FREE(collector);   
}

/**
 *@brief this destroy method will be wrong
 * double free
 */
static void strcoll_destroy_two(strcoll_s *collector)
{
    assert(collector != NULL);
   
    int i = 0;
    for( i = 0;i < collector->poolsize;i++)
        string_destroy(collector->array + i);

    FREE(collector);
}

static strcoll_s *strcoll_init(int poolsize)
{
    assert(poolsize > 0);

    strcoll_s *collector = ab_calloc(1,sizeof(strcoll_s));
       
    collector->array = ab_calloc(poolsize,sizeof(string_s));

    collector->count = 0;
   
    collector->poolsize = poolsize;
   
    return collector;
}

static void strcoll_add(strcoll_s *collector,string_s *string)
{
    assert(collector != NULL && string != NULL);
   
    if(collector->count == collector->poolsize)
    {
        collector->array = ab_realloc(collector->array,
                            2 * collector->poolsize * sizeof(string_s));

        collector->poolsize *= 2;
    }
   
    memcpy(collector->array + collector->count,string,sizeof(string_s));
   
    collector->count += 1;
}

static void strcoll_display(strcoll_s *collector)
{
    assert(collector != NULL);
   
    int i = 0;
    for( i = 0;i < collector->count;i++)
    {
        fprintf(stderr,"the %d string:%s\n",i,(collector->array + i)->content);
    }
}

void *ab_malloc(size_t size)
{
    void *p;
    if( (p = malloc(size) ) == NULL)
    {
        fprintf(stderr,"Malloc error:can't malloc %u bytes\n",size);
        exit(0);
    }
    return p;
}

void *ab_realloc(void *ptr,size_t size)
{
    void *p;
    if( (p = realloc(ptr,size) ) == NULL)
    {
        fprintf(stderr,"Realloc error:can't relloc %u bytes\n",size);
        exit(0);
    }
    return p;
}

void *ab_calloc(size_t nmemb,size_t size)
{
    void *p;
    if( (p = calloc(nmemb,size)) == NULL)
    {
        fprintf(stderr,"Calloc error:can't calloc %u bytes\n",size);
        exit(0);
    }
    return p;
}

Trackback: http://tb.donews.net/TrackBack.aspx?PostId=1188135