#ifndef NUM_LIST_H
#define NUM_LIST_H

#include <list>

class Num_List {
  // неявное копирование запрещено
  Num_List(const Num_List& nl); // нет реализации
  Num_List& operator=(const Num_List& nl); // нет реализации
public:
  Num_List(int min, int max);
  void add(int elem);
  int get_count() const;
  int get_elem(int index) const;
private:
  int _min, _max;
  std::list<int> _elems;
};

inline int Num_List::get_count() const {
  return _elems.size();
}

#endif // !NUM_LIST_H

#include "num_list.h"
#include <stdexcept> // для invalid_argument
#include <iterator> // для advance

using namespace std;

Num_List::Num_List(int min, int max) {
  if (min <= max) /* всё хорошо */;
  else throw invalid_argument("Num_List::Num_List");

  _min = min;
  _max = max;
}

void Num_List::add(int elem) {
  if ((_min <= elem) && (elem <= _max)) /* всё хорошо */;
  else throw invalid_argument("Num_List::add");

  _elems.push_back(elem); // может бросить bad_alloc
}

int Num_List::get_elem(int index) const {
  if ((0 <= index) && (index < static_cast<int>(_elems.size()))) /* всё хорошо */;
  else throw invalid_argument("Num_List::get_elem");

  list<int>::const_iterator it = _elems.begin();
  advance(it, index);
  return *it;
}

#ifndef LIB_H
#define LIB_H

#include <limits.h> // для INT_MAX

typedef enum {
  _result_ok,
  _result_error_alloc_mem_failed,
  _result_error_invalid_param,
  _result_error_unknown,
  _result_force_int = INT_MAX // костыль, чтобы enum хранился как int
} Result_Code;

#ifdef __cplusplus
class Num_List;
#else
typedef struct { int dummy; } Num_List;
#endif

#ifdef __cplusplus
extern "C" {
#endif

Result_Code num_list_new(int min, int max, Num_List** list);
Result_Code num_list_delete(Num_List* list);
Result_Code num_list_add(Num_List* list, int elem);
Result_Code num_list_get_count(const Num_List* list, int* count);
Result_Code num_list_get_elem(const Num_List* list, int index, int* elem);

#ifdef __cplusplus
}
#endif

#endif // !LIB_H

#include "lib.h"
#include "num_list.h"
#include <new> // для bad_alloc
#include <stdexcept> // для invalid_argument

// !!! можно вызывать только в рамках catch
static Result_Code result_code_from_exception() {
  try {
    // повторно возбуждаем то же самое исключение
    throw;
  }
  catch (std::bad_alloc& e) { return _result_error_alloc_mem_failed; }
  catch (std::invalid_argument& e) { return _result_error_invalid_param; }
  catch (...) { return _result_error_unknown; }
}

extern "C" Result_Code num_list_new(int min, int max, Num_List** list) {
  try {
    *list = new Num_List(min, max);
  } catch (...) {
    return result_code_from_exception();
  }
  return _result_ok;
}

extern "C" Result_Code num_list_delete(Num_List* list) {
  delete list;
  return _result_ok;
}

extern "C" Result_Code num_list_add(Num_List* list, int elem) {
  try {
    list->add(elem);
  } catch (...) {
    return result_code_from_exception();
  }
  return _result_ok;
}

extern "C" Result_Code num_list_get_count(const Num_List* list, int* count) {
  try {
    *count = list->get_count();
  } catch (...) {
    return result_code_from_exception();
  }
  return _result_ok;
}

extern "C" Result_Code num_list_get_elem(const Num_List* list, int index, int* elem) {
  try {
    *elem = list->get_elem(index);
  } catch (...) {
    return result_code_from_exception();
  }
  return _result_ok;
}

#include "lib.h"
#include <stdio.h>

void demo() {
  Result_Code rc;
  Num_List* list = NULL;
  int count, i, elem;

  rc = num_list_new(/*min:*/0, /*max:*/100, &list);
  if (rc != _result_ok) goto cleanup;

  rc = num_list_add(list, 50);
  rc = num_list_add(list, 100);
  rc = num_list_add(list, 500);

  rc = num_list_get_count(list, &count);
  if (rc != _result_ok) goto cleanup;
  printf("%i element(s):\n", count);
  for (i = 0; i < count; i++) {
    rc = num_list_get_elem(list, i, &elem);
    if (rc != _result_ok) goto cleanup;
    printf("  %i\n", elem);
  }

cleanup:
  if (list != NULL) {
    rc = num_list_delete(list);
  }
}

int main() {
  demo();
  return 0;
}

2 element(s):
  50
  100