如何在 C 中实现链表？

关键词：

【中文标题】如何在 C 中实现链表？【英文标题】：How to implement a linked list in C? 【发布时间】：2010-11-02 05:09:47 【问题描述】：

我正在创建一个linked list，就像我问的上一个问题一样。我发现开发链表的最佳方法是将头部和尾部置于另一种结构中。我的产品结构将嵌套在这个结构中。我应该将列表传递给添加和删除的函数。我觉得这个概念很混乱。

我已经实现了初始化、添加和清理。但是，我不确定我是否正确地做到了。

当我将产品添加到列表中时，我使用 calloc 声明了一些内存。但我在想我不应该为产品声明内存。我真的很困惑这个添加。

非常感谢您的任何建议，

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

#define PRODUCT_NAME_LEN 128

typedef struct product_data 

    int product_code;
    char product_name[PRODUCT_NAME_LEN];
    int product_cost;
    struct product_data_t *next;
product_data_t;

typedef struct list 

    product_data_t *head;
    product_data_t *tail;
list_t;

void add(list_t *list, int code, char name[], int cost); 
void initialize(list_t *list);
void clean_up(list_t *list);

int main(void)

    list_t *list = NULL;

    initialize(list);
    add(list, 10, "Dell Inspiron", 1500);
    clean_up(list);

    getchar();

    return 0;


void add(list_t *list, int code, char name[], int cost)

    // Allocate memory for the new product
    list = calloc(1, sizeof(list_t));
    if(!list)
    
        fprintf(stderr, "Cannot allocated memory");
        exit(1);
    

    if(list)
    
        // First item to add to the list
        list->head->product_code = code;
        list->head->product_cost = cost;
        strncpy(list->head->product_name, name, sizeof(list->head->product_name));
        // Terminate the string
        list->head->product_name[127] = '/0';
     


// Initialize linked list
void initialize(list_t *list)

    // Set list node to null
    list = NULL;
    list = NULL;


// Release all resources
void clean_up(list_t *list)
    
    list_t *temp = NULL;

    while(list)
    
        temp = list->head;
        list->head = list->head->next;
        free(temp);    
    
    list = NULL;
    list = NULL;
    temp = NULL;

===============================已编辑================ =============

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

#define PRODUCT_NAME_LEN 64

// typedef struct product_data product_data_t;
typedef struct product_data 

    int product_code;
    char product_name[PRODUCT_NAME_LEN];
    int product_cost;
product_data_t;

typedef struct list

    struct list *head;
    struct list *tail;
    struct list *next;
    struct list *current_node;
    product_data_t *data;

list_t;

void add(list_t *list, int code, char name[], int cost); 

int main(void)

    list_t *list = NULL;
    list = initialize(list);
    add(list, 1001, "Dell Inspiron 2.66", 1299);

    add(list, 1002, "Macbook Pro 2.66", 1499);

    clean_up(list);

    getchar();

    return 0;


void add(list_t *list, int code, char name[], int cost)

    /* Allocate memory for the new product */
    product_data_t *product = (product_data_t*) calloc(1, sizeof(*product));
    if(!product)
    
        fprintf(stderr, "Cannot allocate memory.");
        exit(1);
    

    /* This is the first item in the list */
    product->product_code = code;
    product->product_cost = cost;
    strncpy(product->product_name, name, sizeof(product->product_name));
    product->product_name[PRODUCT_NAME_LEN - 1] = '\0';

    if(!list->head)
    
        /* Assign the address of the product. */
        list = (list_t*) product;   
        /* Set the head and tail to this product */
        list->head = (list_t*) product;
        list->tail = (list_t*) product;
    
    else
    
        /* Append to the tail of the list. */
        list->tail->next = (list_t*) product;
        list->tail = (list_t*) product;
    

    /* Assign the address of the product to the data on the list. */
    list->data = (list_t*) product;

【问题讨论】：

initialize() 中的代码一定是错误的（您最多只需要编写两个作业中的一个，但这没有任何好处）；你的意思可能是 list->head = NULL;列表->尾 = NULL； clean_up() 中也有类似的问题。 相关：codereview.stackexchange.com/questions/139482/… 【参考方案1】：

受Linux内核中使用的实现启发的链表实现：

// for 'offsetof', see: https://***.com/q/6433339/5447906.
#include <stddef.h>

// See: https://***.com/q/10269685/5447906.
#define CONTAINER_OF(ptr, type, member) \
    ( (type *) ((char *)(ptr) - offsetof(type, member)) )

// The macro can't be used for list head.
#define LIST_DATA(ptr, type, member) \
    CONTAINER_OF(ptr, type, member);

// The struct is used for both: list head and list nodes.
typedef struct list_node

    struct list_node *prev, *next;

list_node;

// List heads must be initialized by this function.
// Using the function for list nodes is not required.
static inline void list_head_init(list_node *node)

    node->prev = node->next = node;


// The helper function, mustn't be used directly.
static inline void list_add_helper(list_node *prev, list_node *next, list_node *nnew)

    next->prev = nnew;
    nnew->next = next;
    nnew->prev = prev;
    prev->next = nnew;


// 'node' must be a list head or a part of a list.
// 'nnew' must not be a list head or a part of a list. It may
//   be uninitialized or contain any data (even garbage).
static inline void list_add_after(list_node *node, list_node *nnew)

    list_add_helper(node, node->next, nnew);


// 'node' must be a list head or a part of a list.
// 'nnew' must not be a list head or a part of a list. It may
//   be uninitialized or contain any data (even garbage).
static inline void list_add_before(list_node *node, list_node *nnew)

    list_add_helper(node->prev, node, nnew);


// 'node' must be part of a list.
static inline list_node *list_del(list_node *node)

    node->prev->next = node->next;
    node->next->prev = node->prev;
    return node->prev;

使用示例：

#include <stdio.h>

// The struct must contain 'list_node' to be able to be inserted to a list
typedef struct

    int       data;
    list_node node;

my_struct;

// Convert 'list_node *' to 'my_struct*' that contains this 'list_node'
static inline my_struct* get_my_struct(list_node *node_ptr)

    return LIST_DATA(node_ptr, my_struct, node);


void print_my_list(list_node *head)

    printf("list: ");
    for (list_node *cur = head->next; cur != head; cur = cur->next)
    
        my_struct *my = get_my_struct(cur);
        printf(" %d", my->data);
    
    printf(" \n");


// Print 'cmd' and run it. Note: newline is not printed.
#define TRACE(cmd) \
    (printf("%s -> ", #cmd), (cmd))

int main()

    // The head of the list and the list itself. It doesn't contain any data.
    list_node head;
    list_head_init(&head);

    // The list's nodes, contain 'int' data in 'data' member of 'my_struct'
    my_struct el1 = 1;
    my_struct el2 = 2;
    my_struct el3 = 3;

    print_my_list(&head); // print initial state of the list (that is an empty list)

    // Run commands and print their result.
    TRACE( list_add_after (&head    , &el1.node) ); print_my_list(&head);
    TRACE( list_add_after (&head    , &el2.node) ); print_my_list(&head);
    TRACE( list_add_before(&el1.node, &el3.node) ); print_my_list(&head);
    TRACE( list_del       (head.prev)            ); print_my_list(&head);
    TRACE( list_add_before(&head    , &el1.node) ); print_my_list(&head);
    TRACE( list_del       (&el3.node)            ); print_my_list(&head);

    return 0;

上面代码的执行结果：

list:  
list_add_after (&head , &el1.node) -> list:  1 
list_add_after (&head , &el2.node) -> list:  2 1 
list_add_before(&el1.node, &el3.node) -> list:  2 3 1 
list_del (head.prev) -> list:  2 3 
list_add_before(&head , &el1.node) -> list:  2 3 1 
list_del (&el3.node) -> list:  2 1 

http://coliru.stacked-crooked.com/a/6e852a996fb42dc2

当然，在现实生活中，您很可能将malloc 用于列表元素。

【讨论】：

【参考方案2】：

单链表的演示。如果您愿意，请尝试检查 循环链表 和 双向链表。

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


typedef struct node 
    int val;
    struct node * next;
 node_t;


// Iterating over a list
void
print_list(node_t *head)

    node_t *current = head;

    while(current != NULL)
    
        printf("%d\n", current->val);
        current = current->next;
    



// Adding an item to the end of the list
void
push_end(node_t *head, int val)

    node_t *current = head;
    while (current->next != NULL)
    
        current = current->next;
    

    current->next = malloc(sizeof(node_t));
    current->next->val = val;
    current->next->next = NULL;


// Adding an item to the head of the list
void
push_head(node_t **head, int val)

    node_t *new_node = NULL;

    new_node = malloc(sizeof(node_t));
    new_node->val = val;
    new_node->next = *head;

    *head = new_node;


// Removing the head item of the list
int
pop_head(node_t **head)

    int retval = -1;
    node_t *next_node = NULL;

    if (*head == NULL) 
        return -1;
    

    next_node = (*head)->next;
    retval = (*head)->val;
    free(*head);
    *head = next_node;

    return retval;


// Removing the last item of the list
int
pop_last(node_t *head)

    int retval = 0;
    node_t *current = NULL;

    if (head->next == NULL) 
        retval = head->val;
        free(head);
        return retval;
    

    /* get to the second to last node in the list */
    current = head;
    while (current->next->next != NULL) 
        current = current->next;
    

    /* now current points to the second to last item of the list.
       so let's remove current->next */
    retval = current->next->val;
    free(current->next);
    current->next = NULL;

    return retval;


// Removing a specific item
int
remove_by_index(node_t **head, int n)

    int i = 0;
    int retval = -1;
    node_t *current = *head;
    node_t *temp_node = NULL;

    if (n == 0) 
        return pop_head(head);
    

    for (i = 0; i < n - 1; i++) 
        if (current->next == NULL) 
            return -1;
        
        current = current->next;
    

    temp_node = current->next;
    retval = temp_node->val;
    current->next = temp_node->next;
    free(temp_node);

    return retval;



int
main(int argc, const char *argv[])

    int i;
    node_t * testnode;

    for (i = 0; i < argc; i++)
    
        push_head(&testnode, atoi(argv[i]));
    

    print_list(testnode);

    return 0;


// http://www.learn-c.org/en/Linked_lists
// https://www.geeksforgeeks.org/data-structures/linked-list/

【讨论】：

在你的 pop_head() 中，这里的 free(*head) 不会导致未定义的行为吗？你释放（*head）然后使用*head【参考方案3】：

我认为你首先需要想象后端。代码并不重要。去这里可视化所有插入的后端基本 c 代码。 1) 开头插入 Visit and scroll to get every instruction execution on back- end 你需要前面和想象去这里 Back end imagin

以及所有其他可能的插入。

重要的是你可以用这种方式。

结构节点 int data;//数据字段 struct Node*next;//指针字段 ;

结构节点*head,*tail; // 试试这个方法

或捷径

结构节点 int data;//数据字段 struct Node*next;//指针字段 *头，*尾； //全局根指针

还有

Click >> 可视化其他链表问题。

谢谢。

【讨论】：

【参考方案4】：

#include <stdio.h>
struct node
 
  int data;
  struct node* next;
 ;

int main()


//create pointer node for every new element

struct node* head = NULL;
struct node* second = NULL;
struct node* third = NULL;

//initialize every new pointer with same structure memory

head = malloc(sizeof(struct node));
second = malloc(sizeof(struct node));
third = malloc(sizeof(struct node));

head->data = 18;
head->next = second;

second->data = 20;
second->next = third;


third->data = 31;
third->next = NULL;

//print the linked list just increment by address 

  for (int i = 0; i < 3; ++i)
    
      printf("%d\n",head->data++);
      return 0;
    
 

这是了解指针如何与指针一起工作的简单方法。在这里，您只需使用新节点创建指针增量，以便我们可以将其设为自动。

【讨论】：

注释说“打印链表”，但代码增加了第一个节点的数据成员。你在for 循环中有一个return。 是的，我就是这么做的。我们通过循环递增节点地址并查看该地址的值。 不，您正在递增head->data（这不是节点地址，如果它正在递增，它将创建一个无效的指针）并且只执行循环的一次迭代，因为循环包含@ 987654325@。看，这个问题在 2009 年就已经回答了，就这样吧。【参考方案5】：

在C语言中，我们需要定义一个Node来存储一个整数数据和一个指向下一个值的指针。

struct Node
    int data;
    struct Node *next;
;

要添加一个新节点，我们有一个函数 add ，它有一个数据作为 int 参数。首先，我们创建一个新节点 n。如果程序没有创建 n，那么我们打印一条错误消息并返回值 -1。如果我们创建 n 然后我们将 n 的数据设置为具有参数的数据，并且下一个将包含根，因为它具有堆栈的顶部。之后，我们将根节点设置为引用新节点n。

【讨论】：

博客中显示的代码——大概是你的博客，但你应该承认这一点——使用全局变量来跟踪列表的根。因此，它只能维护一个列表。这不是一个非常有用的列表抽象/实现。【参考方案6】：

在您的情况下，head 和 tail 可以简单地指向链表的开头和结尾。对于单链表，真正需要的只是头部。最基本的，链表可以通过使用如下结构来创建：

typedef struct listnode

   //some data
   struct listnode *next;
listnodeT;

listnodeT *list;
listnodeT *current_node;
list = (listnodeT*)malloc(sizeof(listnodeT));
current_node = list;

只要列表始终指向列表的开头并且最后一项设置为 NULL，就可以了，可以使用 current_node 遍历列表。但有时为了使遍历列表更容易并存储有关列表的任何其他数据，使用头和尾标记，并将其包装到它们自己的结构中，就像您所做的那样。那么你的 add 和 initialize 函数将类似于（减去错误检测）

    // Initialize linked list
void initialize(list_t *list)

    list->head = NULL;
    list->tail = NULL;


void add(list_t *list, int code, char name[], int cost)

    // set up the new node
    product_data_t *node = (product_data_t*)malloc(sizeof(product_data_t));
    node->code = code;
    node->cost = cost;
    strncpy(node->product_name, name, sizeof(node->product_name));
    node->next = NULL;

    if(list->head == NULL) // if this is the first node, gotta point head to it
        list->head = node;
        list->tail = node;  // for the first node, head and tail point to the same node
    else
        tail->next = node;  // append the node
        tail = node;        // point the tail at the end
    

在这种情况下，因为它是一个单链表，所以尾部仅在将项目附加到列表时才真正有用。要插入一个项目，您必须从头部开始遍历列表。尾部真正派上用场的是双向链表，它允许您从任一端开始遍历列表。你可以像这样遍历这个列表

// return a pointer to element with product code
product_data_t*  seek(list_t *list, int code)
   product_data_t* iter = list->head;
   while(iter != NULL)
       if(iter->code == code)
           return iter;
       iter = iter->next;
   
   return NULL; // element with code doesn't exist

通常，头部和尾部是完全构造的节点，它们本身用作标记来表示列表的开头和结尾。他们自己不存储数据（更确切地说，他们的数据代表一个哨兵令牌），他们只是正面和背面的占位符。这可以使编写一些处理链表的算法更容易，但代价是必须有两个额外的元素。总的来说，链表是灵活的数据结构，有多种实现方式。

哦，是的，nik 是对的，使用链表是一个很好的方法来提高指针和间接性。它们也是练习递归的好方法！熟练使用链表后，接下来尝试构建一棵树并使用递归遍历这棵树。

【讨论】：

您好，感谢您的帮助。然而，看着其他的cmets。我试图使我的链表尽可能通用。就像 kung 提到的将列表数据与外部数据分开。所以改变了我的结构，一个只包含数据，另一个只包含列表数据。但是，我不确定我应该如何处理我在产品地址中分配的列表->数据。我想我仍然缺乏一些困惑。谢谢【参考方案7】：

走 STL 路线。声明链表应该与数据无关。如果你真的要自己写，看看它是如何在 STL 或 Boost 中实现的。

你甚至不应该在你的数据结构中保留 *next 指针。这允许您在各种数据结构中使用您的产品数据结构 - 树、数组和队列。

希望这些信息对您的设计决策有所帮助。

编辑：

由于帖子标记为 C，因此您可以使用遵循基本设计原则的 void* 指针实现等效。例如，请查看：

Documentation | list.c | list.h

【讨论】：

你有任何使用 STL 的 boost 实现链表的源代码的链接吗？ 似乎被标记为 C 问题，我不认为 STL 在 C 环境中可用 Tonylo/robUK，我编辑了我的答案以添加一个 C 示例。希望这会有所帮助。 C 文档的链接现在已断开，但 Web 服务器仍然存在。也许 WayBack Machine 会有所帮助。我仍然相信这是一个真正有建设性的答案，特别是因为它一开始是 C++ 在现在是一个 C 问题中的误导。 Documentation 截至 2012 年 1 月 4 日。 list.c 截至 2010 年 2 月 28 日。 Wayback Machine 没有 list.h 的链接记录。内容与链接列表完全不相关——链接在功能上是虚假的。【参考方案8】：

如果您正在学习 C 指针理论，这是一个很好的练习。 否则，对于非通用代码（如库中的代码）来说，感觉过于间接了。

您可能想要做更多的指针练习并使用在退出时清理的已分配的精确长度字符串，而不是分配一个静态的 128 字节字符串。

在学术上，kungfucraigs 的结构看起来比你定义的更通用。

【讨论】：

【参考方案9】：

可以说，您希望列表数据结构位于其存储的数据之外。

假设你有：

结构随便 诠释 x_;

那么您的列表结构将如下所示：

结构Whatever_Node 不管_Node* next_ 随便*数据_

Ryan Oberoi 发表了类似的评论，但没有示例。

【讨论】：

【参考方案10】：

在内存中，您的项目通过列表结构中的指针链接

item1 -> item2

为什么不将列表结构作为项目的一部分？

然后你分配一个产品项，列表结构就在其中。

typedef struct product_data 

    int product_code;
    char product_name[PRODUCT_NAME_LEN];
    int product_cost;
    struct list_t list; // contains the pointers to other product data in the list
product_data_t;

【讨论】：

【参考方案11】：

我不是在这里写代码，但您需要执行以下操作：

创建列表对象，这将在程序长度内保持全局。 Malloc 产品_data_t 的大小。 对于第一个元素（head 为 NULL），将 head 指向 malloced 的地址。 要添加下一个元素，移动到列表的末尾，然后将分配地址的指针添加到最后一个元素的下一个。 （最后一个元素的下一个元素将始终为 NULL，这就是您遍历结束的方式。） 暂时忘记尾巴。

【讨论】：

【参考方案12】：

您分配了错误的内存块。您不是为每个列表元素分配内存，而是为列表头和尾分配内存。

为简单起见，去掉头部和尾部的单独结构。使它们成为全局变量（它们现在所在的范围相同）并将它们更改为 listhead 和 listtail。这将使代码更具可读性（您不会不必要地通过单独的结构）并且您不会犯分配错误结构的错误。

除非你要创建一个双向链表，否则你不需要尾指针。创建链表后，它不是要添加的主要元素，但也不是必需的。

【讨论】：

【参考方案13】：

您正在为您的 list_t 结构分配空间，只是指向列表头和尾的指针，这不是您想要做的。

当您添加到链表时，为链表中的实际节点分配空间，即您的 product_data_t 结构。

【讨论】：

【参考方案14】：

如果您希望更好地了解链表的基础知识，请查看以下文档：

http://cslibrary.stanford.edu/103/LinkedListBasics.pdf

【讨论】：

chapter11_2lua链表与队列

链表　　由于table是动态的实体，所以在Lua中实现链表是很方便的。每个节点以一个table来表示，一个“链表”只是节点table中的一个字段。该字段包含了对其他table的引用。例如，要实现一个基础的列表，其中每个节点具... 查看详情

在 C++ 中实现双向链表时面临调试问题

】在C++中实现双向链表时面临调试问题【英文标题】：FacingdebuggingproblemwhenimplementingdoublylinkedlistinC++【发布时间】：2021-12-1100:30:03【问题描述】：我正在实现一个双向链表，其中每个节点都有两个指针。一个指向列表中的下一个... 查看详情

在 C++ 中实现双向链表时迭代器出错

】在C++中实现双向链表时迭代器出错【英文标题】：ErroriniteratorwhileimplementingdoublylinkedlistinC++【发布时间】：2016-04-0522:02:10【问题描述】：我在尝试实现链接列表类的迭代器时遇到一个模棱两可的错误。该程序说该函数不是我的... 查看详情

如何在 C 中实现位集？

】如何在C中实现位集？【英文标题】：HowtoimplementabitsetinC?【发布时间】：2011-05-2107:50:34【问题描述】：我一直在Java中使用Bitset类，我想在C中做类似的事情。我想我必须像C中的大多数东西一样手动完成。什么是一种有效的实现... 查看详情

如何在 C 中实现回调函数？

】如何在C中实现回调函数？【英文标题】：HowdoIimplementcallbackfunctionsinC?【发布时间】：2010-05-0814:59:11【问题描述】：gcc4.4.3c89我正在创建一个客户端服务器应用程序，我需要实现一些回调函数。但是，我在回调方面没有太多经验... 查看详情

如何在 C 中实现多分支树结构

】如何在C中实现多分支树结构【英文标题】：HowtoimplementamultibranchtreestructureinC【发布时间】：2011-08-2713:14:14【问题描述】：我很久没有用C写代码了。我正在尝试做一棵多叶树。我正在尝试将C#trie实现转换为C，以便使用CUDA在GPU... 查看详情

如何从链表中弹出？

】如何从链表中弹出？【英文标题】：Howtopopfromlinkedlist?【发布时间】：2013-08-2915:36:50【问题描述】：我在C中实现了一个带有Pop函数的Linked-List：Node*pop(Node*head)Node*temp=head;printf("Tempis:%s\\n",temp->val);if(head->next!=NULL)*head=*head->... 查看详情

如何在 C#/Silverlight 中实现带通滤波器

】如何在C#/Silverlight中实现带通滤波器【英文标题】：Howtoimplementaband-passfilterinc#/Silverlight【发布时间】：2009-11-0314:37:56【问题描述】：如何在C#中实现带通滤波器？我在Silverlight中使用自定义MediaStreamSource并使用加法合成来产生声... 查看详情

如何将数据动态存储在C中的链表中？

】如何将数据动态存储在C中的链表中？【英文标题】：HowtostorethedatadynamicallyinlinkedlistinC?【发布时间】：2021-11-0805:14:16【问题描述】：我正在尝试将值动态存储在链表中。我希望用户输入链接列表的大小。然后根据我要分配内存... 查看详情

如何在 C 中实现无锁共享标志？

】如何在C中实现无锁共享标志？【英文标题】：Howtoimplementalock-freesharedflaginC?【发布时间】：2012-10-0819:45:50【问题描述】：我有一个生产者一消费者模型，我需要生产者在数据可用时设置一个标志。我怀疑我可以在没有锁定共享... 查看详情

如何在 C++ 中实现这个结果？指向数组的数组

】如何在C++中实现这个结果？指向数组的数组【英文标题】：HowcanIachievethisresultinc++?Arrayspointingtoarrays【发布时间】：2015-02-0810:14:31【问题描述】：我正在尝试使用c/c++执行以下操作。为了解释代码应该如何工作，我编写了这个示... 查看详情

如何在没有中间副本的情况下在标准 C 中实现 memmove？

】如何在没有中间副本的情况下在标准C中实现memmove？【英文标题】：HowtoimplementmemmoveinstandardCwithoutanintermediatecopy?【发布时间】：2011-04-3017:09:00【问题描述】：来自我系统上的手册页：void*memmove(void*dst,constvoid*src,size_tlen);描述memm... 查看详情

如何在选择案例语句中实现枚举

】如何在选择案例语句中实现枚举【英文标题】：HowtoimplementEnuminselectcasestatement【发布时间】：2014-01-0718:33:32【问题描述】：我有一个包含许多项目的枚举，我想在VB.NET的selectcase语句中实现这些项目，就像我们在c#.net中所做的... 查看详情

如何在 C 中的链表中释放不同大小的分配内存

】如何在C中的链表中释放不同大小的分配内存【英文标题】：howtofreedifferentsizeallocatedmemoryinlinked-listinC【发布时间】：2016-05-2116:30:09【问题描述】：在这个问题中，我将使用部分代码。所以你明白我要解释什么。我有这个包含矩... 查看详情

C - 链表 - 如何分配和遍历列表

】C-链表-如何分配和遍历列表【英文标题】：C-LinkedList-howtoassignandgothroughthelist【发布时间】：2019-02-2402:01:26【问题描述】：我在使用两个结构构建链表时遇到问题节点-包含数据和指向下一个的指针，列表包含指向列表头的指针... 查看详情

如何在 Qt/C++/QML 中实现类似 WPF 的 MVVM？

】如何在Qt/C++/QML中实现类似WPF的MVVM？【英文标题】：HowtoimplementWPF-likeMVVMinQt/C++/QML?【发布时间】：2013-09-0601:00:21【问题描述】：我正在编写一个概念验证应用程序，这非常简单。基本上它由一个UI组成，其中在QMLListView中显示“... 查看详情

在 C 中实现 HashMap [关闭]

...hMapinC[closed]【发布时间】：2010-10-2417:11:08【问题描述】：如何像C++STL中那样从头开始在C中创建Hashmap？将考虑哪些参数以及如何测试哈希图？例如，在您可以说您的哈希图已完成之前，您将运行的基准测试用例是什么？【问题讨... 查看详情

如何在 C++11 中实现 make_unique 函数？ [复制]

】如何在C++11中实现make_unique函数？[复制]【英文标题】：Howtoimplementmake_uniquefunctioninC++11?[duplicate]【发布时间】：2013-07-2723:11:13【问题描述】：我的编译器不支持make_unique。一个怎么写？template<classT,class...Args>unique_ptr<T>mak... 查看详情