摘要：新手學習，模擬思想編寫程序數組中是實際上存在的最小空間大小個數內存使用完了的時候正常的，在范圍內的往后面偏移一位返回新的，下一個元素的存放位置只能通過這樣子，將個字節的內存轉為整數

#include "stdio.h"
typedef unsigned char u_char;//windows 中 是 byte

struct array_s {
    u_char*     startpos;
    size_t      maxlength;
    size_t      size;
    size_t      length; //實際上存在的最小空間大小個數  1

};

typedef struct array_s array_t;



array_t* array_create( size_t length, size_t size);
void array_destory(array_t * array);
void* array_push(array_t* a);

array_t* array_create( size_t length, size_t size)
{
    array_t* a;
    a = (array_t*)malloc(sizeof(array_t));
    if (a==NULL){return NULL;}

   // a->startpos=(u_char*)_aligned_malloc(size*length,16);
    a->startpos = (u_char*)malloc(size * length);
    if (a->startpos == NULL) {return NULL;}
    a->maxlength = length;
    a->size = size;
    a->length = 0;
    return a;
}

void array_destory(array_t * array)
{
    free(array->startpos);
    free(array);
}


void* array_push(array_t* a)
{
    u_char *startpos,*newstartpos;
    size_t size;

    if (a->length == a->maxlength) //內存使用完了的時候....
    {
        size = a->maxlength * a->size;

        newstartpos = (u_char*)malloc(size * 2);

        if (newstartpos != NULL)
        {
            memcpy(newstartpos,a->startpos,size);
            free(a->startpos);
            a->startpos = newstartpos;
            a->maxlength *= 2;
        }else{
            printf("memerror!");
            return NULL;
        }
    }

    //正常的，在范圍內的array......
    newstartpos = (u_char*)a->startpos + a->length * a->size; // 往后面偏移一位 .....
    a->length++;
    return newstartpos; //返回新的，下一個元素的存放位置......
}




dump(array_t * a)
{
    int tmp=0;
    for(size_t i=0;ilength;++i)
    {
        memcpy(&tmp,(a->startpos + i*a->size),a->size);//只能通過這樣子，將4個字節的內存轉為整數
        printf("%d-->%x,size=%d,value_is:%d
",i,a->startpos + i*a->size,a->size,tmp);
    }
}

typedef struct{
    int length;
    char* data;
} string;

dump1(array_t * a)
{
    string* tmp;

    for(size_t i=0;ilength;++i)
    {
        tmp = (string*)(a->startpos + i*a->size);
        printf("%d-->%x,size=%d,value_is : %s,strlen=%d
",i,a->startpos + i*a->size,a->size,tmp->data,tmp->length);
    }
}

int main(int argc,char ** argv)
{
    array_t * myarray = array_create(10,sizeof(int));
    int* tmp=0;

    for(int i = 200 ; i< 228 ; ++i)
    {
        tmp=array_push(myarray);
        *tmp = i * i;
    }
   dump(myarray);

    array_t * myarray1;

    string* tmp1;
    char tmp2[255]="111";

    for(int i=0; i< 3;++i)
    {
        myarray = array_create(10,sizeof(string));

        for(int i=0; i< 9;++i)
        {
            tmp1 = (string*)array_push(myarray);
            sprintf(tmp2,"---%d---",i);
            tmp1->data = malloc(strlen(tmp2)+1);        //這里調試花了好長時間， 是因為， 沒有給字符串指針分配內存空間， 就往字符串指針里面復制內容， 導致堆溢出。
            if (tmp1->data == NULL){printf("error!");}
            memset(tmp1->data,"