vector的实现

实现如下

int VectorCInit(VectorC *vc, size_t per_malloc_size) {
  if (per_malloc_size == 0) {
    return NNACL_ERR;
  }
  vc->data_ = (int *)malloc(per_malloc_size * sizeof(int));
  if (vc->data_ == NULL) {
    return NNACL_ERR;
  }
  vc->size_ = 0;
  vc->max_size_ = per_malloc_size;
  vc->per_malloc_size_ = per_malloc_size;
  return NNACL_OK;
}

int VectorCSet(VectorC *vc, const int *src_shape, size_t src_shape_size) {
  if (src_shape_size == 0) {
    vc->size_ = 0;
  } else {
    free(vc->data_);
    if (vc->per_malloc_size_ == 0) {
      return NNACL_ERR;
    }
    vc->max_size_ = (src_shape_size / vc->per_malloc_size_ + 1) * vc->per_malloc_size_;
    vc->data_ = (int *)malloc(sizeof(int) * vc->max_size_);
    if (vc->data_ == NULL) {
      return NNACL_ERR;
    }
    for (size_t i = 0; i < src_shape_size; i++) {
      vc->data_[i] = src_shape[i];
    }
    vc->size_ = src_shape_size;
  }
  return NNACL_OK;
}

int VectorCPush(VectorC *vc, int value) {
  if (vc->size_ + 1 > vc->max_size_) {
    int *tmp = (int *)malloc(vc->per_malloc_size_ * sizeof(int) + vc->max_size_ * sizeof(int));
    if (tmp == NULL) {
      return NNACL_ERR;
    }
    memcpy(tmp, vc->data_, vc->size_ * sizeof(int));
    free(vc->data_);
    vc->data_ = tmp;
    vc->max_size_ = vc->max_size_ + vc->per_malloc_size_;
  }
  vc->data_[vc->size_] = value;
  vc->size_++;
  return NNACL_OK;
}

int VectorCInsert(VectorC *vc, int index, int value) {
  if (vc->size_ + 1 > vc->max_size_) {
    int *tmp = (int *)malloc(vc->per_malloc_size_ * sizeof(int) + vc->max_size_ * sizeof(int));
    if (tmp == NULL) {
      return NNACL_ERR;
    }
    memcpy(tmp, vc->data_, vc->size_ * sizeof(int));
    free(vc->data_);
    vc->data_ = tmp;
    vc->max_size_ = vc->max_size_ + vc->per_malloc_size_;
  }
  memmove(vc->data_ + index + 1, vc->data_ + index, (size_t)(vc->size_ - index) * sizeof(int));
  vc->data_[index] = value;
  vc->size_++;
  return NNACL_OK;
}

void VectorCErase(VectorC *vc, int index) {
  memmove(vc->data_ + index, vc->data_ + index + 1, (size_t)(vc->size_ - index - 1) * sizeof(int));
  vc->size_--;
}

bool VectorCEqual(const VectorC *vc1, const VectorC *vc2) {
  if (vc1->size_ != vc2->size_) {
    return false;
  }
  for (size_t i = 0; i < vc1->size_; i++) {
    if (vc1->data_[i] != vc2->data_[i]) {
      return false;
    }
  }
  return true;
}

void VectorCFree(VectorC *vc) {
  free(vc->data_);
  vc->data_ = NULL;
}