深层复制 - void 的元素** - 结构的成员

Question

下面是代码，

/****** list.h **********/
#include<stddef.h>
#include<stdlib.h>
#include<string.h>
#include<stdio.h>

/***************** Usage-start ************/
typedef enum{false, true}bool;
typedef enum {CREATE_NEW_LIST, DOUBLE_THE_LIST, HALF_THE_LIST}Op;

#if defined(ARRAY)

  /* To ensure Encapsulation(i.e., maintain invariants of array) */
  typedef struct List List;

#elif defined(LINKED_LIST)

  /* To ensure Encapsulation(i.e., maintain invariants of linked list) */
  /* User will not get access to node*/
  typedef struct List List;


#else
  #error "Wrong list implementation macro name !!!"
#endif


void insertItem(List *, void *newItem);
void *deleteItem(List *, int listIndex);
List* createList(List *, Op opType);

/************* arrayImpl.c ***********/


#include"list.h"


/************ Representation - start ************/
typedef struct List{
  void **array;

  /* Following members for Housekeeping - Array enhancement*/
  int lastItemPosition;
  int size;
}List;

#define INITIAL_LIST_SIZE 50
List *createList(List *list, Op opType){
  if(opType == CREATE_NEW_LIST){
    list = malloc(sizeof(List));
    list->array = malloc(INITIAL_LIST_SIZE*sizeof(void*));


    /* Is it safe to initialise zero to  array of  pointers? */
    list->array = memset(list->array, 0, INITIAL_LIST_SIZE*sizeof(void *));

    list->lastItemPosition = -1;
    list->size = INITIAL_LIST_SIZE;
  }else if(opType == DOUBLE_THE_LIST){

    list->array = realloc(list->array, 2*(list->size)*sizeof(void *));

    list->lastItemPosition = list->lastItemPosition;;
    list->size = 2*(list->size);
  }else if(opType == HALF_THE_LIST){

    list->array = realloc(list->array, ((list->size)/2)*sizeof(void *));

    list->lastItemPosition = list->lastItemPosition;
    list->size = (list->size)/2;
  }

  return list;

}

/********** arrayImpl.c*********/
void *deleteItem(List *arrayList, int listIndex){
  void *returnElement; //Deep copy before freeing the object
  free(arrayList->array[listIndex]);

  /* Delete operation - O(n) operation */
  for(int accumulator = listIndex; accumulator <= arrayList->lastItemPosition; accumulator++){
    arrayList->array[accumulator] = arrayList->array[++accumulator];
  }
  arrayList->lastItemPosition--;


  /* House keeping - Half the list */
  if(arrayList->size > INITIAL_LIST_SIZE){ /* Minimum size maintained */
    if((arrayList->lastItemPosition + 1) == ((arrayList->size)/2)){
      arrayList = createList(arrayList, HALF_THE_LIST);
    }
  }
  return returnElement;

}

/***************arrayImpl.c***************/
void insertItem(List *arrayList, void *newItem){

  /* House keeping - Enhance the array */
  if(arrayList->lastItemPosition + 1 == arrayList->size){
    arrayList = createList(arrayList, DOUBLE_THE_LIST);
  }


  /* Insert new element - O(1) operation */
  arrayList->array[++(arrayList->lastItemPosition)] = newItem;


  return;
}

用户代码，

#include"list.h"

int main(void){

  List *arrayList = createList((List *)NULL, CREATE_NEW_LIST);


  if (arrayList == (List *)0){
    fprintf(stderr, "Unable to create list \n");
    exit(1); //Nothing else to do without arrayList
  }

  // Objects should only be on heap
  int *object1 = malloc(sizeof(int));
  *object1 = 777;
  insertItem(arrayList, object1);

  int *object2 = malloc(sizeof(int));
  *object2 = 888;
  insertItem(arrayList, object2);

  object1 = deleteItem(arrayList, 0);
}

我想重新使用List抽象来写Stack抽象，如下图有push()/pop()

#include"../list/list.h"
typedef struct Stack{
  List *stack;
}Stack;

问题：

在deleteItem()函数中，如何从deleteItem()函数中深度复制arrayList->array[listIndex]和returnreturnElement？

pop() 会调用 deleteItem()

注：编译>gcc -DARRAY main.c arrayImpl.c

Answer 1

insertItem 没有分配项目 - 所以 deleteItem 不应该 free 它。

void *deleteItem(List *arrayList, int listIndex){
  void *returnElement = arrayList->array[listIndex];

  /* Delete operation - O(n) operation */
  ....

  /* House keeping - Half the list */
  ....

  return returnElement;
}

深层复制 - void 的元素** - 结构的成员

Deep copy - An element of a void** - Member of struct

c

struct

pointers

deep-copy

memcpy