CODEWITHSUNDEEP
c++c++11error-handling
Desmond Rhodes
Desmond Rhodes

Reputation: 78

C++ Handling error/exception that comes in multiple forms

Is there a better way to do this? I feel like this will be horrible to maintain.

const unsigned int set_max {32};
std::vector<unsigned int> base;
base.reserve(argc-1);
for (int i = 1; i < argc; ++i) {
  unsigned long tmp;
  try { tmp = std::stoul(argv[i], nullptr, 10); }
  catch (std::invalid_argument) { std::cerr << "Invalid base! Conversion failed.\n"; return -2; }
  catch (std::out_of_range) { std::cerr << "Invalid base! Too large.\n"; return -2; }
  if (tmp > std::numeric_limits<unsigned int>::max()) { std::cerr << "Invalid base! Too large.\n"; return -2; }
  if (tmp < 2) { std::cerr << "Invalid base! Must at least be 2.\n"; return -2; }
  if (tmp > set_max) { std::cerr << "Invalid base! Must be within " << set_max << ".\n"; return -2; }
  base.push_back(static_cast<unsigned int>(tmp));
}

Edit: reposted here

Upvotes: 0

Views: 339

Answers (1)

Remy Lebeau
Remy Lebeau

Reputation: 596672

I would suggest splitting out the logic into utility functions to make each operation easier to manage, eg:

enum class eConvFailure {NoError, ConvFailed, OutOfRange, TooSmall, TooLarge};

std::pair<unsigned int, eConvFailure> my_stoui(const std::string &s)
{
  unsigned long tmp;

  try
  {
    tmp = std::stoul(s, nullptr, 10);
    if (tmp > std::numeric_limits<unsigned int>::max()) {
      throw std::out_of_range("");
    }
  }
  catch (const std::invalid_argument &) {
    return std::make_pair(0, eConvFailure::ConvFailed);
  }
  catch (const std::out_of_range &) {
    return std::make_pair(0, eConvFailure::OutOfRange);
  }

  /* alternatively:
  errno = 0;
  tmp = std::stroul(s.c_str(), nullptr, 10);
  if (errno != 0) {
    if (tmp == ULONG_MAX && errno == ERANGE)
      return std::make_pair(0, eConvFailure::OutOfRange);
    else
      return std::make_pair(0, eConvFailure::ConvFailed);
  }
  if (tmp > std::numeric_limits<unsigned int>::max()) {
    return std::make_pair(0, eConvFailure::TooLarge);
  }
  */

  return std::make_pair(static_cast<unsigned int>(tmp), eConvFailure::NoError);
}

std::pair<unsigned int, eConvFailure> my_stoui(const std::string &s, unsigned int max_value)
{  
  auto res = my_stoui(s);
  if (res.second != eConvFailure::NoError) {
    return res;
  }
  if (res.first < 2) {
    return std::make_pair(0, eConvFailure::TooSmall);
  }
  if (res.first > max_value) {
    return std::make_pair(0, eConvFailure::TooLarge);
  }
  return res;
}

const unsigned int set_max {32};

std::string reason(eConvFailure err) {
  switch (err) {
    case eConvFailure::ConvFailure:  return "Conversion Failed";
    case eConvFailure::OutOfRange:   return "Too Large";
    case eConvFailure::TooSmall:     return "Must at least be 2";
    case eConvFailure::TooLarge:     return "Must be within " + std::to_string(set_max);
    default:                         return "Error " + std::to_string(static_cast<int>(eConvFailure));
  }
}

std::vector<unsigned int> base;
base.reserve(argc-1);
for (int i = 1; i < argc; ++i) {
  auto res = my_stoui(argv[i], set_max);
  if (res.second != eConvFailure::NoError) {
    std::cerr << "Invalid base! " << reason(res.second) << ".\n";
    return -2;
  }
  base.push_back(res.first);
}

Or, you can use exception handling to your advantage instead, eg:

unsigned int my_stoui(const std::string &s)
{
  unsigned long tmp = std::stoul(s, nullptr, 10);
  if (tmp > std::numeric_limits<unsigned int>::max()) {
    throw std::out_of_range("");
  }
  return static_cast<unsigned int>(tmp);
}

unsigned int my_stoui(const std::string &s, unsigned int max_value)
{  
  unsigned int tmp = my_stoui(s);
  if (tmp < 2) {
    throw std::runtime_error("Must at least be 2");
  }
  if (tmp > max_value) {
    return std::runtime_error("Must be within " + std::to_string(max_value));
  }
  return tmp;
}

const unsigned int set_max {32};

std::vector<unsigned int> base;
base.reserve(argc-1);

try
{
  for (int i = 1; i < argc; ++i) {
    base.push_back(my_stoui(argv[i], set_max));
  }
}
catch (const std::exception &ex)
{
  std::cerr << "Invalid base! ";
  if (dynamic_cast<const std::invalid_argument*>(&ex)) {
    std::cerr << "Conversion failed";
  }
  else if (dynamic_cast<const std::out_of_range*>(&ex)) {
    std::cerr << "Too large";
  }
  else {
    std::cerr << ex.what();
  }
  std::cerr << ".\n";
  return -2;
}

Upvotes: 1

Related Questions