C 语言中的动态字符串数组

对于初学者来说，函数至少应该像这样声明

int addItemToInventory( char ***Inv_content, size_t *Inv_length, const char *Item );

其次，根据条件将函数的主体分成两部分是没有意义的

if (*Inv_length==0)

该函数在语句中包含错误，例如

*Inv_content[*Inv_length] = malloc((item_name_size+1) * sizeof(char));

你需要写

( *Inv_content )[*Inv_length] = malloc((item_name_size+1) * sizeof(char));

该函数可以如下所示

int addItemToInventory( char ***Inv_content, size_t *Inv_length, const char *Item )
{
    char **tmp_pnt =  realloc( *Inv_content, ( *Inv_length +1 ) * sizeof( char* ) );

    int result = tmp_pnt != NULL ? 0 : 1;

    if ( result == 0 )
    {
        *Inv_content = tmp_pnt;

        ( *Inv_content )[*Inv_length] = malloc( strlen( item ) + 1 ); 

        if ( ( *Inv_content )[*Inv_length] == NULL ) result = 2;

        if ( result == 0 )
        {
            strcpy( ( *Inv_content )[*Inv_length], Item );
            ++*Inv_length;
        }
    }
        
    return result;
}

请注意，该函数不应发出任何消息。

函数的调用方将根据函数的返回值决定是否输出消息。

此外，您可以在函数中引入枚举，而不是在函数中使用 0、1 和 2 等幻数

enum { Success = 0, ReallocFailure = 1, MallocFailure = 2 };

在函数中写入例如

    int result = tmp_pnt != NULL ? Success : ReallocFailure;

    if ( result == Success )
    //... and so on

该功能存在一些严重问题。如果未为字符串分配字符数组，则指针数组已重新分配。因此，函数行为在逻辑上是不一致的。item

最好按以下方式重写函数

enum { Success = 0, ReallocFailure = 1, MallocFailure = 2 };

int addItemToInventory( char ***Inv_content, size_t *Inv_length, const char *Item )
{
    char *s = malloc( strlen( item ) + 1 );

    int result = s != NULL ? Success : MallocFailure;

    if ( result == Success )
    {
        char **tmp_pnt =  realloc( *Inv_content, ( *Inv_length +1 ) * sizeof( char* ) );

       if ( tmp_pnt == NULL ) result = ReallocFailure;

       if ( result == Success )
       {
            strcpy( s, Item );

            tmp_pnt[*Inv_length] = s;

            *Inv_content = tmp_pnt;

            ++*Inv_length;
        }
        else
        {
            free( s );
        }
    }
        
    return result;
}

该函数看起来更清晰，没有逻辑上的不一致。

*Inv_content[*Inv_length]在数组旁边查找内存中的下一个数组（可能分配也可能不分配）。您希望改用在数组中查找所选项的 Copy。(*Inv_content)[*Inv_length]

另外，这里有一个不太受诅咒的代码版本，你至少在代码中重写并使用错误的大小类型：strdup

typedef struct { const char* Name; } Item;

int addItemToInventory(Item** Inv_content, size_t* Inv_length, const char* Item)
{
    if (*Inv_length == 0)
    {
        *Inv_content = malloc(sizeof(struct Item*));
        if (*Inv_content)
            (*Inv_content)->Name = _strdup(Item);
        *Inv_length = 1;
    }
    else
    {
        char** tmp_pnt;
        tmp_pnt = realloc(*Inv_content, (*Inv_length + 1) * sizeof(struct Item*));

        if (tmp_pnt)
        {
            *Inv_content = tmp_pnt;
            (*Inv_content)[(*Inv_length)++].Name = _strdup(Item);
        }
        else // realloc failed
        {
            printf("Impossible to allocate memory for Inv. (Add Item (realloc))\n");
            return(1);
        }
    }

    return(0);
}

int main()
{
    Item* Inv_content = NULL;
    size_t Inv_length = 0;

    const char Item1[] = "Great Sword";
    const char Item2[] = "Big Bow";

    addItemToInventory(&Inv_content, &Inv_length, Item1);
    addItemToInventory(&Inv_content, &Inv_length, Item2);

    printf("\n");
    for (int i = 0; i <= Inv_length - 1; i++)
        printf("Item %d : %s \n", i, Inv_content[i].Name);
}

首先，我想指出的是，你正在做三星级的编程。你所说的 Inventory，实际上希望成为对象的容器。你不必尊重这一点，但你应该写更多的文档来弥补复杂性，因为单个指针已经足够复杂了，因为它不清楚它是否指向堆、堆栈或其他任何东西，只是通过查看它。这种复杂性也使得对设计进行更改变得更加困难，部分原因是与指针争吵的“沉没时间成本”感，部分原因是与实现细节的严重耦合。InventoryInventoryItemInventoryItem

我想提出一个粗略的、更统一的设计，它最初看起来更复杂，但实际上更简单，因为：

1. 一切都毫不含糊地在堆上。
2. 每个人都有责任照顾好自己，而不会给构建和发布 s 的复杂细节带来负担。InventoryItemInventoryInventoryItem
3. 长度与清单指针一起分组，这样可以更轻松地同时拥有多个清单，而无需执行诸如具有清单指针数组和另一个长度数组之类的操作。

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

#pragma region InventoryItem
/**
 * A heap-string representing an inventory item.
 * This object is intended to always be on the heap.
 */
typedef struct InventoryItem {
    char *name;
    int length;
} InventoryItem;

InventoryItem *InventoryItem_fromCString(const char *name)
{
    InventoryItem *tmp = malloc(sizeof(InventoryItem));
    
    assert((tmp != NULL) && "Critical error: malloc failed allocating memory for an InventoryItem object.");
    tmp->length = strlen(name) + 1;
    tmp->name = malloc(strlen(name) + 1);
    assert((tmp->name != NULL) && "Critical error: malloc failed allocating memory for an InventoryItem's internal string.");
    strcpy(tmp->name, name);
    
    return tmp;
}

/**
 * Weak contract: do not use the InventoryItem object after release.
 */
void InventoryItem_release(InventoryItem *This)
{
    free(This->name);
}
#pragma endregion

#pragma region Inventory
/**
 * A container for a heap-array of InventoryItem objects.
 * This object is intended to always be on the heap.
 */
typedef struct Inventory {
    InventoryItem **items;
    int length;
} Inventory;

void Inventory_init(Inventory *This)
{
    This->items = NULL;
    This->length = 0;
}

Inventory *Inventory_create()
{
    Inventory *tmp = malloc(sizeof(Inventory));
    
    assert((tmp != NULL) && "Critical error: malloc failed allocating memory for an Inventory object.");    
    Inventory_init(tmp);
    
    return tmp;
}

void Inventory_addItem(Inventory *This, const char *ItemToAdd)
{
    InventoryItem *item = InventoryItem_fromCString(ItemToAdd);
    
    This->items = realloc(This->items, (This->length + 1) * sizeof(Inventory *));
    assert((This->items != NULL) && "Critical error: realloc failed expanding memory of the specified Inventory object's items array while trying to add an item to it.");    
    This->items[This->length] = item;
    ++(This->length);    
}

void Inventory_dump(Inventory *This, FILE *stream)
{
    fprintf(stream, "The inventory has %d items.\n", This->length);
    
    for (int i = 0; i < This->length; ++i)
    {
        fprintf(stream, "Item %d: %s.\n", i, This->items[i]->name);
    }
}

/**
 * Weak contract: do not use the Inventory object after it has been released.
 */
void Inventory_release(Inventory *This)
{    
    for (int i = 0; i < This->length; ++i) {
        InventoryItem_release(This->items[i]);        
    }
    free(This->items);
}
#pragma endregion

int main() 
{
    Inventory *inv = Inventory_create();
    
    Inventory_addItem(inv, "Great Sword");
    Inventory_addItem(inv, "Big Bow");
    Inventory_addItem(inv, "Excalibur");
    Inventory_dump(inv, stdout);
    
    Inventory_release(inv);
}