C 如何将元素插入此结构中

我是C新手，我做了一些练习，在这个例子中，我想构造一个表，其中可以包含很多符号类型的元素，但我不知道如何编写这部分。我想使用malloc将堆内存分配给符号并插入表中（SymbolTable）

#包括
#包括
#包括
#包括
类型定义结构{
字符*名称；
uint32地址；
}象征；
类型定义结构{
符号*待定；
uint32_t len；
uint32_t盖；
int模式；
}符号化/*这是我想要的桌子*/
SymbolTable*创建表格（int模式）{
SymbolTable*st=（SymbolTable*）malloc（sizeof（SymbolTable））；
如果（st！=NULL）
{
st->mode=模式；
st->len=0；
返回st；
}
printf（“内存分配失败！\n”）；
返回NULL；
}
无空洞表格（SymbolTable*表格）{
int i；
对于（i=0；ilen；++i）
{
免费（表->待处理[i].名称）；
自由（&（表->待决条件[i]）；
}
免费（餐桌）；
}
int add_to_表（SymbolTable*表，const char*名称，uint32_t addr）{
如果（地址%4！=0）
{
printf（“地址对齐错误！\n”）；
返回-1；
}
int table_len=table->len；
如果（表->模式==1）
{
int i；
对于（i=0；itbl[i]）.name）==*name）
{
printf（“名称存在！\n”）；
返回-1；
}
`我不知道如何在这里插入元素`
}
}
返回0；
}
int main（）
{
SymbolTable*st=create_表（0）；
将_添加到_表（st，“aaa”，4）；
将_添加到_表（st，“bb”，8）；
写入表（st、stdout）；
自由表（st）；
}

首先，我认为您需要分配

*tbl

并在

create_table（）

中设置

cap

（如果他包含表中单元格的最大nb）

下一步，在

add_to_table（）

中，尝试

malloc（sizeof（struct symbol））

if

（len

并为

*name

分配内存，并设置为您的值（不要忘记

*name

末尾的

\0

）。将其分配给

tbl[len]

，不要忘记递增

len

尝试在小函数中分离，例如

int is_in_table（const char*name）

返回索引或-1的人，或

symbol new_symbol（const char*name，Uint32 addr）

创建和设置新符号的人

---

我希望我对您有所帮助：）。

您的代码没有什么问题；此外，由于您在问题中没有具体说明这些细节，我不得不做出一些假设：

cap

是

table->tbl

的容量，即我们分配了多少内存

添加新符号时，我们应该复制包含其名称的字符串，而不仅仅是将该指针指定给新的

symbol

条目

您还应该选择一种编码风格并坚持它（同一行与新行上的括号，

T*ptr

vs

T*ptr

等）。最后，我删除了cast-in

create_表

；看

这是您的代码的固定版本；在

add_to_table

中，如果我们没有足够的内存来添加一个新的，我们会将

Symbol

数组的容量增加一倍（每次调用

realloc

为多个元素添加空间将是浪费）。当我们扩展数组的容量时，我们必须注意将每个

名称
指针设置为
NULL
，因为如果我们不这样做，并且
在
cap
len
时调用
free_table
，我们将尝试
释放
未初始化的指针（而在
NULL
上调用
free
则完全没有问题，什么也不做）

#包括
#包括
#包括
#包括
类型定义结构
{
字符*名称；
uint32地址；
}象征；
类型定义结构
{
符号*待定；
uint32_t len；
uint32_t盖；
int模式；
}SymbolTable；/*这是我要处理的表*/
SymbolTable*创建表格（int模式）
{
SymbolTable*st=malloc（sizeof（SymbolTable））；
如果（st！=NULL）
{
st->tbl=NULL；
st->mode=模式；
st->len=0；
st->cap=0；
返回st；
}
printf（“内存分配失败！\n”）；
返回NULL；
}
无空洞表格（SymbolTable*表格）
{
int i；
对于（i=0；icap；++i）
{
免费（表->待处理[i].名称）；
}
免费（表格->待定）；
免费（餐桌）；
}
int add_to_表（SymbolTable*表，const char*名称，uint32_t addr）
{
如果（地址%4！=0）
{
printf（“地址对齐错误！\n”）；
返回-1；
}
int table_len=table->len；
如果（表->模式==1）
{
int i；
对于（i=0；itbl[i].名称，名称））
{
printf（“名称存在！\n”）；
返回-1；
}
}
如果（表列+1>表->上限）
{
//分配更多内存
uint32\u t new\u cap=表格->cap？表格->cap*2:2；
table->tbl=realloc（table->tbl，新的_cap*sizeof（*table->tbl））；
如果（表->tbl==NULL）
{
//处理错误
}
表->上限=新的上限；
int i；
对于（i=表长度；i<新的上限；++i）
{
table->tbl[i]。name=NULL；
}
}
uint32\u t name\u len=strlen（名称）；
表->tbl[表列].name=malloc（名称列+1）；
strncpy（表->tbl[表列]。名称，名称，名称列）；
表->tbl[表列]。名称[名称列]='\0'；
表->tbl[表列].addr=addr；
表->len++；
}
返回0；
}
内部主（空）
{
SymbolTable*st=创建表格（1）；
将_添加到_表（st，“aaa”，4）；
将_添加到_表（st，“bb”，8）；
写入表（st、stdout）；
自由表（st）；
}
使用实现自引用结构的概念
#include<stdio.h>
#include<stdlib.h> 
#include<stdint.h>
#include<string.h>

typedef struct {

    char *name;
    uint32_t addr;
}Symbol;

typedef struct {
    Symbol* tbl;
    uint32_t len;
    uint32_t cap;
    int mode;
} SymbolTable; /*this is the table i want to mantiply*/

SymbolTable* create_table(int mode) {
    SymbolTable* st = (SymbolTable*)malloc(sizeof(SymbolTable));
    if (st != NULL)
    {
        st->mode = mode;
        st->len = 0;
        return st;
    }
    printf("Memory allocation failed!\n");
    return NULL;
}

void free_table(SymbolTable* table) {
    int i;
    for (i = 0; i < table->len; ++i)
    {
        free(table->tbl[i].name);
        free(&(table->tbl[i]));
    }
    free(table);
}

int add_to_table(SymbolTable* table, const char* name, uint32_t addr) {
    if (addr % 4 != 0)
    {
        printf("Address alignment erron!\n");
        return -1;
    }
    int table_len = table->len;
    if (table->mode == 1)
    {
        int i;
        for (i = 0; i < table_len; ++i)
        {
            if (*((table->tbl[i]).name) == *name)
            {
                printf("Name existed!\n");
                return -1;
            }
            `I don't know how to inset element here`
        }
    }
    return 0;
}

int main()
{
    SymbolTable * st = create_table(0);
    add_to_table(st, "aaa", 4);
    add_to_table(st, "bb", 8);
    write_table(st, stdout);
    free_table(st);
}

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

typedef struct
{
    char* name;
    uint32_t addr;
} Symbol;

typedef struct
{
    Symbol* tbl;
    uint32_t len;
    uint32_t cap;
    int mode;
} SymbolTable; /*this is the table i want to mantiply*/

SymbolTable* create_table(int mode)
{
    SymbolTable* st = malloc(sizeof(SymbolTable));
    if (st != NULL)
    {
        st->tbl = NULL;
        st->mode = mode;
        st->len = 0;
        st->cap = 0;
        return st;
    }
    printf("Memory allocation failed!\n");
    return NULL;
}

void free_table(SymbolTable* table)
{
    int i;
    for (i = 0; i < table->cap; ++i)
    {
        free(table->tbl[i].name);
    }
    free(table->tbl);
    free(table);
}

int add_to_table(SymbolTable* table, const char* name, uint32_t addr)
{
    if (addr % 4 != 0)
    {
        printf("Address alignment erron!\n");
        return -1;
    }
    int table_len = table->len;
    if (table->mode == 1)
    {
        int i;
        for (i = 0; i < table_len; ++i)
        {
            if (!strcmp(table->tbl[i].name, name))
            {
                printf("Name existed!\n");
                return -1;
            }
        }

        if (table_len + 1 > table->cap)
        {
            // allocate more memory
            uint32_t new_cap = table->cap ? table->cap * 2 : 2;
            table->tbl = realloc(table->tbl, new_cap * sizeof(*table->tbl));
            if (table->tbl == NULL)
            {
                // handle the error
            }

            table->cap = new_cap;
            int i;
            for (i = table_len; i < new_cap; ++i)
            {
                table->tbl[i].name = NULL;
            }
        }

        uint32_t name_len = strlen(name);
        table->tbl[table_len].name = malloc(name_len + 1);
        strncpy(table->tbl[table_len].name, name, name_len);
        table->tbl[table_len].name[name_len] = '\0';

        table->tbl[table_len].addr = addr;
        table->len++;
    }

    return 0;
}

int main(void)
{
    SymbolTable*  st = create_table(1);
    add_to_table(st, "aaa", 4);
    add_to_table(st, "bb", 8);
    write_table(st, stdout);
    free_table(st);
}

typedef struct S{
    char *name;
    uint32_t addr;
    S* next;
}Symbol;

typedef struct {
    Symbol* tbl;
    uint32_t len;
    int mode;
} SymbolTable;

#include<stdio.h>
#include<stdlib.h> 
#include<stdint.h>
#include<string.h>
#include <stdio.h> 
typedef struct S{
    char *name;
    uint32_t addr;
    S* next;
}Symbol;

typedef struct {
    Symbol* tbl;
    uint32_t len;
    int mode;
} SymbolTable; /*this is the table I want to maltiply*/

SymbolTable* create_table(int mode) {
    SymbolTable* st = (SymbolTable*)malloc(sizeof(SymbolTable));
    if (st != NULL)
    {
        st->tbl = NULL;
        st->mode = mode;
        st->len = 0;
        return st;
    }
    printf("Memory allocation failed!\n");
    return NULL;
}

void free_table(SymbolTable* table) {
    free(table);
}

int add_to_table(SymbolTable* table,  char* name, uint32_t addr) {
    if (addr % 4 != 0)
    {
        printf("Address alignment erron!\n");
        return -1;
    }
    int table_len = table->len;
    if (table->mode == 1)
    {
        if (table_len == 0)
        {
            Symbol *t = (Symbol*)malloc(sizeof(Symbol));
            t->name = name;
            t->next = NULL;
            table->len++;
            table->tbl = t;
        }
        else
        {
            Symbol *t = table->tbl;
            while (t->next != NULL)
            {
                if (t->name == name)
                {
                    printf("Name existed!\n");
                    return -1;
                }
                t = t->next;
            }   
            if (t->name == name)
            {
                printf("Name existed!\n");
                return -1;
            }
            t->next = (Symbol*)malloc(sizeof(Symbol));
            table->len++;
            t->next->name = name;
            t->next->next = NULL;
        }
    }
    return 0;
}
void write_table(SymbolTable *st)
{
    Symbol *t = st->tbl;
    while (t != NULL)
    {
        printf("%s\n",t->name);
        t = t->next;
    }
    printf("\n");
}
int main()
{
    SymbolTable *st = create_table(0);
    st->mode = 1;// Table mode setting to 1 for importing next value to table.
    // You may implement it in your own way.
    add_to_table(st, "cc", 8);
    st->mode = 1;
    add_to_table(st, "bb", 8);
    st->mode = 1;
    write_table(st);
    free_table(st);
}