C自定结构动态二维字符串表

tpye_row.h

======================

#ifndef TYPE_ROW_H
#define TYPE_ROW_H

#include "malloc.h"
#include "string.h"

typedef struct st_row
{
    unsigned int count;
    char** content;
}typerow;

int create_st_row(typerow *r,int columns)
{
    if(columns > 0)
    {
        r->count = (unsigned int)columns;
        r->content = (char**)malloc(columns * sizeof(char*));
        for(int i = 0; i < columns; i ++)
            r->content[i] = NULL;
        return 0;    // 创建成功    
    }
    else
    {
        r->count = 0;
        r->content = NULL;
        return -1;    // 参数错误
    }
}

int input_st_row(typerow *r,int y,char* str)
{
    if((r != NULL )&&(y >= 0)&&((unsigned int)y < r->count)&&(str != NULL))
    {
        if(r->content[y] != NULL)    // 当前位置数据为空
        {
            free(r->content[y]);    // 释放原始数据
            r->content[y] = (char*)malloc(strlen(str) * sizeof(char) + 1); // '\0'
            strcpy(r->content[y],str);
            return 0;
        }
        else
        {
            r->content[y] = (char*)malloc(strlen(str) * sizeof(char) + 1); // '\0'
            strcpy(r->content[y],str);
            return 0;    // 写入成功
        }
    }
    else
    {
        return -1; // 非法参数
    }
}

char* get_st_row(typerow *r,int y)
{
    if((r != NULL )&&(y >= 0)&&((unsigned int)y < r->count))
    {
        return r->content[y];
    }
    else
        return NULL;
}

int destroy_st_row(typerow *r)
{
    if(r != NULL && r->count != 0)
    {
        for(unsigned int i = 0; i < r->count; i++)
        {
            free(r->content[i]);
            r->content[i] = NULL;
        }
        r->count = 0;
        free(r->content);
        r->content = NULL;
        return 0;    // 释放成功
    }
    else
    {
        return -1;    // 没有内存需要释放
    }
}

int getCount_st_row(typerow *r)
{
    return r->count;
}

#endif

======================

tpye_table.h

======================

#ifndef TYPE_TABLE_H
#define TYPE_TABLE_H

#include "type_row.h"

typedef struct st_table
{
    unsigned int rows_num;
    unsigned int columns_num;
    typerow **table;
}typetable;

int create_typetable(typetable *t,int rows_num,int columns_num)
{
    if(rows_num > 0 && columns_num > 0 && t != NULL)
    {
        t->rows_num = 0;
        t->columns_num = 0;
        t->table = (typerow**)malloc(rows_num * sizeof(typerow*));
        if(t->table != NULL)
        {
            for(int i = 0 ;i < rows_num ; i ++)
            {
                t->table[i] = (typerow*)malloc(sizeof(typerow));
                if(t->table[i] != NULL)
                {
                    if(0 != create_st_row(t->table[i],columns_num))
                    {
                        if(i != 0)    // 不是所有申请都失败
                        {
                            for(int j = 0 ; j < i ;j ++)
                                destroy_st_row(t->table[j]);
                        }
                        free(t->table);
                        t->table = NULL;
                        return -2;    // 创建内存表失败
                    }
                }
                else
                    return -1;
            }
            t->rows_num = rows_num;
            t->columns_num = columns_num;
            return 0;
        }
        else
        {
            return -2;    // 申请失败
        }
    }
    else
    {
        return -1;    // 非法参数
    }    
}

int input_typetable(typetable *t,int x,int y,char *str)
{
    if(t != NULL && x >= 0 && (unsigned int)x < t->rows_num && y >= 0 && str != NULL)
    {
        input_st_row(t->table[x],y,str);    //
        return 0;
    }
    else
        return -1;    // 输入失败
}

char* get_typetable(typetable *t,int x,int y)
{
    if(t != NULL && x >= 0 && (unsigned int)x < t->rows_num && y >= 0)
    {
        return get_st_row(t->table[x],y);
    }
    else
        return NULL;
}

int destroy_typetable(typetable *t)
{
    if(t != NULL)
    {
        for(int i = 0; (unsigned int)i < t->rows_num; i++)
            destroy_st_row(t->table[i]);
        free(t->table);
        t->table = NULL;
        t->columns_num = 0;
        t->rows_num = 0;
        return 0;    // 释放成功
    }
    else
        return  -1;    // 当前所指空间不需要释放
}

int getRowsCount_typetable(typetable *t)
{
    return t->rows_num;
}

int getColumnsCount_typetable(typetable *t)
{
    return  t->columns_num;
}
#endif