compile c++ clang online

Language: Layout:

#include <iostream>
#include <limits>
#include <limits.h>
#include <stdint.h>
#include <assert.h>
#include <string.h>

struct Data {
  uint8_t storage[8];

template <class T>
  void Write(const T& object) {
    static_assert(sizeof(object) <= sizeof(storage), "object is too big");
    memcpy(storage, &object, sizeof(object));
  }
  template <class T>
  void Read(T& object) const {
    static_assert(sizeof(object) <= sizeof(storage), "object is too big");
    memcpy(&object, storage, sizeof(object));
  }
};

template <class T, class U>
T checked_cast(U from) {
  if (from > std::numeric_limits<T>::max()) {
    std::cout << "OOPS: checked_cast failed: "
      << from << " (" << std::hex << from << std::dec << ") "
      << "is larger than the max value "
      << std::numeric_limits<T>::max() << " (" << std::hex << std::numeric_limits<T>::max() << std::dec << ")"
      << std::endl;
    return 0xDEADBEEF;
  }
  if (from < std::numeric_limits<T>::min()) {
    std::cout << "OOPS: checked_cast failed: "
      << from << " (" << std::hex << from << std::dec << ") "
      << "is smaller than the min value "
      << std::numeric_limits<T>::min() << " (" << std::hex << std::numeric_limits<T>::min() << std::dec << ")"
      << std::endl;
    return 0xDEADBEEF;
  }
  return static_cast<T>(from);
}

Data SerializeULong(unsigned long value) {
  Data data;
  data.Write(static_cast<uint64_t>(value));
  return data;
}
unsigned long DeserializeULong(const Data& data) {
  uint64_t value64;
  data.Read(value64);
  return checked_cast<unsigned long>(value64);
}

#if 1

Data SerializeUInt(unsigned int value) {
  Data data;
  data.Write(static_cast<int64_t>(static_cast<int>(value)));
  return data;
}
unsigned int DeserializeUInt(const Data& data) {
  int64_t value64;
  data.Read(value64);
  if (value64 < INT_MIN) {
    std::cout << "OOPS: can't deserialize "
      << value64 << " (" << std::hex << value64 << std::dec << ") "
      << "because it's smaller than INT_MIN" << std::endl;
    return 0xDEADBEEF;
  }
  if (value64 < 0) {
    return static_cast<int>(value64);
  }
  if (value64 <= UINT_MAX) {
    return static_cast<unsigned int>(value64);
  }
  std::cout << "OOPS: can't deserialize "
    << value64 << " (" << std::hex << value64 << std::dec << ") "
    << "because it's larger than UINT_MAX" << std::endl;
  return 0xDEADBEEF;
}

#else

// Convert between unsigned types, special case for -1

Data SerializeUInt(unsigned int value) {
  uint64_t value64 = value;
  if (value64 == static_cast<unsigned int>(-1)) {
    value64 = -1;
  }
  Data data;
  data.Write(value64);
  return data;
}
unsigned int DeserializeUInt(const Data& data) {
  uint64_t value64;
  data.Read(value64);
  if (value64 == static_cast<uint64_t>(-1)) {
    return static_cast<unsigned int>(-1);
  }
  return checked_cast<unsigned int>(value64);
}

#endif

unsigned long DeserializeToULong(unsigned int value) {
  Data data = SerializeUInt(value);
  unsigned long value2 = DeserializeULong(data);
  std::cout << "UInt "
    << value << " (" << std::hex << value << std::dec << ") "
    << "deserialized to ULong "
    << value2 << " (" << std::hex << value2 << std::dec << ") "
    << std::endl;
  return value2;
}
unsigned int DeserializeToUInt(unsigned long value) {
  Data data = SerializeULong(value);
  unsigned int value2 = DeserializeUInt(data);
  std::cout << "ULong "
    << value << " (" << std::hex << value << std::dec << ") "
    << "deserialized to UInt "
    << value2 << " (" << std::hex << value2 << std::dec << ") "
    << std::endl;
  return value2;
}

int main() {
  std::cout << "assertions" << std::endl;
  assert(DeserializeToUInt(-1) == -1);
  assert(DeserializeToULong(-1) == -1);
  std::cout << std::endl;

std::cout << "0x80000000 -> UInt" << std::endl;
  DeserializeToUInt(0x80000000);
  std::cout << std::endl;

std::cout << "0xFFFFFFFF -> UInt" << std::endl;
  DeserializeToUInt(0xFFFFFFFF);
  std::cout << std::endl;

std::cout << "UInt(-1) -> ULong -> UInt " << std::endl;
  DeserializeToUInt(DeserializeToULong(-1));
  std::cout << std::endl;

std::cout << "UInt(-2) -> ULong -> UInt " << std::endl;
  DeserializeToUInt(DeserializeToULong(-2));
  std::cout << std::endl;

std::cout << "ULong(-1) -> UInt -> ULong " << std::endl;
  DeserializeToULong(DeserializeToUInt(-1));
  std::cout << std::endl;

std::cout << "ULong(-2) -> UInt -> ULong " << std::endl;
  DeserializeToULong(DeserializeToUInt(-2));
  std::cout << std::endl;

std::cout << "UInt(INT_MAX) -> ULong -> UInt " << std::endl;
  DeserializeToUInt(DeserializeToULong(INT_MAX));
  std::cout << std::endl;

std::cout << "ULong(INT_MAX) -> UInt -> ULong " << std::endl;
  DeserializeToULong(DeserializeToUInt(INT_MAX));
  std::cout << std::endl;

std::cout << "UInt(INT_MIN) -> ULong -> UInt " << std::endl;
  DeserializeToUInt(DeserializeToULong(INT_MIN));
  std::cout << std::endl;

std::cout << "ULong(INT_MAX + 1) -> UInt" << std::endl;
  DeserializeToUInt(static_cast<long>(INT_MAX) + 1);
  std::cout << std::endl;

/* Large values */

std::cout << "ULong(INT_MIN - 1) -> UInt" << std::endl;
  DeserializeToUInt(static_cast<long>(INT_MIN) - 1);
  std::cout << std::endl;

std::cout << "ULong(UINT_MAX + 1) -> UInt" << std::endl;
  DeserializeToUInt(static_cast<long>(UINT_MAX) + 1);
  std::cout << std::endl;

return 0;
}

Show compiler warnings [ + ] Compiler args [ + ] Show input
Compilation time: 0.74 sec, absolute running time: 0.13 sec, cpu time: 0 sec, memory peak: 4 Mb, absolute service time: 0.88 sec