int row = 0;
int missing_cnt = 0;
std::for_each(begin, end, [&](const auto &result) {
  auto attr_dict_api = interop::WrapItemAttrAsAttrDictApi(context, result.item_key);
  auto *attr = attr_dict_api->Lookup(input_config.attr_name);
  if (attr) {
    FillMatrixRow(attr, input->value_view(), row++, input_config.dim, context);
  } else {
    ++missing_cnt;
  }
});

// 👎
int v = *p++;
// 👍
int v = *(p++);

// 👎
for (int i = 0; i < item_list.size(); ++i) {
  const auto &item = item_list[i];
  // do something with item
}
// 👍
for (const auto &item : item_list) {
  // do something with item
}

// 👎
for (auto obj : some_list) {
  // do something with obj
}
// 👍
for (auto &obj : some_list) {
  // do something with obj
}

// 👎
class Abc {
 private:
  int count_;
  const double *ptr_;
};
// 👍
class Abc {
 private:
  int count_ = 0;
  const double *ptr_ = nullptr;
};

ConstArray<double> double_list;

double_list.SetData(GetData());
for (auto val : double_list) {
  std::cout << val << "\n";
}

template <typename T>
struct ConstArray {
  const T *list = nullptr;
  int size = 0;

  void SetData(const char *data, int data_size) {
    if (data_size % sizeof(T) == 0) {
      list = reinterpret_cast<const T *>(data);
      size = data_size / sizeof(T);
    } else {
      list = nullptr;
      size = 0;
    }
  }

  void SetData(const std::string &data) { SetData(data.data(), data.size()); }
}

std::vector<std::string> str_list;
for (int i = 0; i < 1'000'000; ++i) {
  str_list.push_back(std::to_string(i));
}

std::vector<std::string *> str_list;
for (int i = 0; i < 1'000'000; ++i) {
  auto *p = new std::string(std::to_string(i));
  str_list.push_back(p);
}

void Handle(const std::vector<int *> &list);

void Calculate(std::vector<int> *data) {
  if (!data) return;
  const int size = 100;
  data->reserve(size);
  std::vector<int *> addr_list;
  for (int i = 0; i < size; ++i) {
    data->push_back(i);
    int *p = &(data->back());
    addr_list.push_back(p);
  }
  Handle(addr_list);
}