fork(1) download
copy 
  1. #include <iostream>
  2. #include <iomanip>
  3. #include <vector>
  4. #include <sstream>
  5. #include <chrono>
  6. #include <type_traits>
  7.  
  8. template<bool B>
  9. using BoolType = std::integral_constant<bool, B >;
  10.  
  11. template<char C> struct IsNumber : BoolType<(C >= '0' && C <= '9')>{};
  12. template<char C> struct IsLower : BoolType<(C >= 'a' && C <= 'f')>{};
  13. template<char C> struct IsUpper : BoolType<(C >= 'A' && C <= 'F')>{};
  14. template<char C> struct ToNibble : std::integral_constant<unsigned char,
  15. 	IsNumber<C>::value ? C-'0' : IsLower<C>::value ? (C-'a') +10 : IsUpper<C>::value ? (C-'A') +10 : 0xFF
  16. >{};
  17. template<unsigned char...> struct Sequence{};
  18. template<int I, typename T> struct MakeSequence;
  19. template<int I, unsigned char... Cs> struct MakeSequence<I,Sequence<Cs...>>:
  20. 	MakeSequence<I+1, Sequence<Cs...,ToNibble<I>::value>>{};
  21. template<unsigned char... Cs> struct MakeSequence<256,Sequence<Cs...>>{	
  22. 	using Type = Sequence<Cs...>; 
  23. };
  24. template<typename T> struct HexASCIITable;
  25. template<unsigned char... Cs> struct HexASCIITable<Sequence<Cs...>>{
  26. 	static unsigned char convert(const char c){
  27. 		static const unsigned char table[256] = {Cs...};
  28. 		return table[static_cast<int>(c)];
  29. 	}
  30. };
  31.  
  32. using Table = HexASCIITable<typename MakeSequence<0,Sequence<>>::Type>;
  33.  
  34. class ToHexIterator : public std::iterator<std::input_iterator_tag, unsigned char>{
  35.     char* it_;
  36.     char* end_;
  37.     unsigned char current_;
  38.     void skipInvalid(){ while (Table::convert(*it_) == 0xFF && it_ != end_){ ++it_; }; }
  39. public:
  40.     ToHexIterator() :it_{ nullptr }, end_{ nullptr }, current_{}{}                  //default constructed means end iterator
  41.     ToHexIterator(char* begin, char* end) :it_{ begin }, end_{ end }, current_{}{
  42.         skipInvalid();  //make sure we are pointing to valid stuff
  43.         ++(*this);
  44.     }
  45.     bool operator==(const ToHexIterator &other){
  46.         return it_ == nullptr && end_ == nullptr && other.it_ == nullptr && other.end_ == nullptr;
  47.     }
  48.     bool operator!=(const ToHexIterator &other){
  49.         return !(*this == other);
  50.     }
  51.     unsigned char operator*(){
  52.         return current_;
  53.     }
  54.     ToHexIterator & operator++(){
  55.         current_ = 0;
  56.         if (it_ != end_) {
  57.             do{
  58.             	current_ <<= 4;
  59.                 current_ += Table::convert(*it_);
  60.                 ++it_;
  61.             } while (Table::convert(*it_) != 0xFF && it_ != end_);
  62.             skipInvalid();
  63.         }
  64.         else {
  65.             it_ = nullptr;
  66.             end_ = nullptr;
  67.         }
  68.         return *this;
  69.     }
  70.     ToHexIterator operator++(int){
  71.         ToHexIterator temp(*this);
  72.         ++(*this);
  73.         return temp;
  74.     }
  75. };
  76.  
  77. void __attribute__ ((noinline)) test1(std::vector<unsigned char> &v){
  78. 	char in[] = "1,3,8,b,e,ff,10,3,8,b,e,ff,10,3,8,b,e,ff,10,3,8,b,e,ff,10,3,8,b,e,ff,10,3,8,b,e,ff,10,3,8,b,e,ff,10,3,8,b,e,ff,10,3,8,b,e,ff,10,3,8,b,e,ff,10,3,8,b,e,ff,10,3,8,b,e,ff,10,3,8,b,e,ff,10,3,8,b,e,ff,10,3,8,b,e,ff,10,3,8,b,e,ff,10,3,8,b,e,ff,10,3,8,b,e,ff,10,3,8,b,e,ff,10";
  79. 	std::copy(ToHexIterator{ std::begin(in), std::end(in) }, ToHexIterator{}, std::back_inserter(v));
  80. }
  81.  
  82. void __attribute__ ((noinline)) test2(std::vector<unsigned char> &v){
  83. 	std::istringstream iss("1,3,8,b,e,ff,10,3,8,b,e,ff,10,3,8,b,e,ff,10,3,8,b,e,ff,10,3,8,b,e,ff,10,3,8,b,e,ff,10,3,8,b,e,ff,10,3,8,b,e,ff,10,3,8,b,e,ff,10,3,8,b,e,ff,10,3,8,b,e,ff,10,3,8,b,e,ff,10,3,8,b,e,ff,10,3,8,b,e,ff,10,3,8,b,e,ff,10,3,8,b,e,ff,10,3,8,b,e,ff,10,3,8,b,e,ff,10,3,8,b,e,ff,10");
  84.     unsigned int num = 0;
  85.     while(iss >> std::hex >> num || !iss.eof()) 
  86.     {
  87.         if(iss.fail()) 
  88.         {
  89.             iss.clear();
  90.             char dummy;
  91.             iss >> dummy;
  92.             continue;
  93.         }
  94.         if(num <= 0xff) {
  95.             v.push_back(num);
  96.         }
  97.         else {
  98.         	// Error single byte value expected
  99.         }
  100.     }	
  101. }
  102.  
  103. int main() {
  104.  
  105.     std::vector<unsigned char> dataValues;
  106.     std::vector<unsigned char> dataValues2;
  107.  
  108.     	std::chrono::nanoseconds time[2]{{},{}};
  109.  
  110. 	for(int i=0;i<100;i++){
  111. 		const auto t1 = std::chrono::high_resolution_clock::now();
  112. 		test2(dataValues2);
  113. 		const auto t2 = std::chrono::high_resolution_clock::now();
  114. 		time[0] += t2 - t1;
  115. 		const auto t3 = std::chrono::high_resolution_clock::now();
  116. 		test1(dataValues);
  117. 		const auto t4 = std::chrono::high_resolution_clock::now();
  118. 		time[1] += t4 - t3;
  119. 	}
  120.  
  121. 	typedef std::chrono::nanoseconds output_time;
  122. 	const char* const out_unit = " ns";
  123.  
  124. 	std::cout << "1: " << std::chrono::duration_cast<output_time>(time[0]).count() << out_unit << "\n";
  125. 	std::cout << "2: " << std::chrono::duration_cast<output_time>(time[1]).count() << out_unit << "\n";
  126.  
  127.     std::cout << std::hex << std::setfill('0');
  128.     for(int i=0;i<6;i++){
  129.     	std::cout << "0x" << std::setw(2) << static_cast<unsigned int>(dataValues2[i]) << std::endl;
  130.     	std::cout << "0x" << std::setw(2) << static_cast<unsigned int>(dataValues[i]) << std::endl;
  131.     }
  132. 	return 0;
  133. }
Success #stdin #stdout 0s 3480KB
comments ()
stdin
copy 
Standard input is empty
stdout
copy 
1: 3994383 ns
2: 206848 ns
0x01
0x01
0x03
0x03
0x08
0x08
0x0b
0x0b
0x0e
0x0e
0xff
0xff
https://ideone.com/ady8GY
language:
C++14 (gcc 8.3)
created:
10 years ago
visibility:
public

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!