c++实现最快的boost::lexical_cast类型转换器

已于 2022-07-04 15:57:08 修改
阅读量378 收藏 2
点赞数
分类专栏： c/c++ tool 文章标签： c++ 开发语言
于 2022-06-26 21:29:21 首次发布
原文链接：https://juejin.cn/post/7113472949004271647
版权
c/c++ 同时被 2 个专栏收录
17 篇文章 1 订阅
订阅专栏
tool
7 篇文章 0 订阅
订阅专栏

boost库一直都很重量级，所以只能重新实现一遍boost::lexical_cast，为了区分原boost库，只能写到std标准库的namespace命名空间里面，这样的话，替换的时候只需要把boost改为std就很方便换。最后的测试也比boost更快。

#ifndef LEXICAL_CAST_HPP
#define LEXICAL_CAST_HPP
#include <type_traits>
#include <string>
#include <string_view>
#include <stdexcept>
#include <string.h>
#pragma warning(disable:4244)
namespace std {
#if defined(_MSC_VER)
#define _INLINE __forceinline
#else
#define _INLINE inline
#endif
  static const std::string STD_TURE("true", 4), STD_FALSE("false", 5);
  template <typename S, typename T> _INLINE S lexical_cast(T& i);
  template <> _INLINE std::string lexical_cast<std::string>(signed char& i) { return std::to_string(i); }
  template <> _INLINE std::string lexical_cast<std::string>(unsigned char& i) { return std::to_string(i); }
  template <> _INLINE std::string lexical_cast<std::string>(short& i) { return std::to_string(i); }
  template <> _INLINE std::string lexical_cast<std::string>(unsigned short& i) { return std::to_string(i); }
  template <> _INLINE std::string lexical_cast<std::string>(int& i) { return std::to_string(i); }
  template <> _INLINE std::string lexical_cast<std::string>(unsigned int& i) { return std::to_string(i); }
  template <> _INLINE std::string lexical_cast<std::string>(long long& i) { return std::to_string(i); }
  template <> _INLINE std::string lexical_cast<std::string>(unsigned long long& i) { return std::to_string(i); }
  template <> _INLINE std::string lexical_cast<std::string>(bool& b) { return b ? STD_TURE : STD_FALSE; }
  template <> _INLINE std::string lexical_cast<std::string>(double& f) { return std::to_string(f); }
  template <> _INLINE std::string lexical_cast<std::string>(float& f) { return std::to_string(f); }
  template <> _INLINE std::string lexical_cast<std::string>(long double& f) { return std::to_string(f); }
  template <typename S, typename T> _INLINE S lexical_cast(T&& i);
  template <> _INLINE std::string lexical_cast<std::string>(signed char&& i) { return std::to_string(i); }
  template <> _INLINE std::string lexical_cast<std::string>(unsigned char&& i) { return std::to_string(i); }
  template <> _INLINE std::string lexical_cast<std::string>(short&& i) { return std::to_string(i); }
  template <> _INLINE std::string lexical_cast<std::string>(unsigned short&& i) { return std::to_string(i); }
  template <> _INLINE std::string lexical_cast<std::string>(int&& i) { return std::to_string(i); }
  template <> _INLINE std::string lexical_cast<std::string>(unsigned int&& i) { return std::to_string(i); }
  template <> _INLINE std::string lexical_cast<std::string>(long long&& i) { return std::to_string(i); }
  template <> _INLINE std::string lexical_cast<std::string>(unsigned long long&& i) { return std::to_string(i); }
  template <> _INLINE std::string lexical_cast<std::string>(bool&& b) { return b ? STD_TURE : STD_FALSE; }
  template <> _INLINE std::string lexical_cast<std::string>(double&& f) { return std::to_string(f); }
  template <> _INLINE std::string lexical_cast<std::string>(float&& f) { return std::to_string(f); }
  template <> _INLINE std::string lexical_cast<std::string>(long double&& f) { return std::to_string(f); }

  static unsigned short STD_PO[] = {
	1,
	10,
	100,
	1000,
	10000
  };
  static unsigned long STD_POW[] = {
	1,
	10,
	100,
	1000,
	10000,
	100000,
	1000000,
	10000000,
	100000000,
	1000000000
  };
  static unsigned long long STD_POWS[] = {
	1,
	10,
	100,
	1000,
	10000,
	100000,
	1000000,
	10000000,
	100000000,
	1000000000,
	10000000000,
	100000000000,
	1000000000000,
	10000000000000,
	100000000000000,
	1000000000000000,
	10000000000000000,
	100000000000000000,
	1000000000000000000,
	10000000000000000000ull
  };
  template <typename T> inline T lexical_cast(const char* c);

  template <> std::string lexical_cast<std::string>(const char* c) { return std::string(c); }

  template <> [[nodiscard]] _INLINE
	bool lexical_cast<bool>(const char* c) {
	if ((c[0] == '1' && c[1] == 0) || (c[0] == 't' && c[1] == 'r' && c[2] == 'u' && c[3] == 'e' && c[4] == 0)) return true;
	if ((c[0] == '0' && c[1] == 0) || (c[0] == 'f' && c[1] == 'a' && c[2] == 'l' && c[3] == 's' && c[4] == 'e' && c[5] == 0))
	  return false; throw std::invalid_argument("");
  }
  template <> [[nodiscard]] _INLINE
	signed char lexical_cast<signed char>(const char* c) {
	signed char r; if (*c != 0x2D) {
	  if (*c > 0x39 || 0x30 > *c) throw std::invalid_argument(""); r = *c - 0x30;
	  while (*++c) {
		r = r * 10 + *c - 0x30; if (r <= 0 || *c > 0x39 || 0x30 > *c) throw std::range_error("");
	  }
	} else {
	  r = 0x30 - *++c; if (*c > 0x39 || 0x30 > *c) throw std::invalid_argument("");
	  while (*++c) {
		r = r * 10 - *c + 0x30; if (r >= 0 || *c > 0x39 || 0x30 > *c) throw std::range_error("");
	  };
	} return r;
  }
  template <> [[nodiscard]] _INLINE
	unsigned char lexical_cast<unsigned char>(const char* c) {
	if (*c > 0x39 || 0x30 > *c) throw std::invalid_argument(""); unsigned char r = *c - 0x30; char z = 0;
	while (z != 1 && *++c) {
	  if (*c > 0x39 || 0x30 > *c) throw std::invalid_argument(""); r = r * 10 + *c - 0x30; ++z;
	}
	if (z == 1 && *++c) {
	  if (r > 25 || *c > 0x35 || 0x30 > *c) throw std::range_error("");
	  r = r * 10 + *c - 0x30;
	} return r;
  }
  template <> [[nodiscard]] _INLINE
	short lexical_cast<short>(const char* c) {
	short r; if (*c != 0x2D) {
	  if (*c > 0x39 || 0x30 > *c) throw std::invalid_argument(""); r = *c - 0x30;
	  while (*++c) {
		r = r * 10 + *c - 0x30; if (r <= 0 || *c > 0x39 || 0x30 > *c) throw std::range_error("");
	  }
	} else {
	  r = 0x30 - *++c; if (*c > 0x39 || 0x30 > *c) throw std::invalid_argument("");
	  while (*++c) {
		r = r * 10 - *c + 0x30; if (r >= 0 || *c > 0x39 || 0x30 > *c) throw std::range_error("");
	  };
	} return r;
  }
  template <> [[nodiscard]] _INLINE
	unsigned short lexical_cast<unsigned short>(const char* c) {
	if (*c > 0x39 || 0x30 > *c) throw std::invalid_argument(""); unsigned short r = *c - 0x30; char z = 0;
	while (z != 3 && *++c) {
	  if (*c > 0x39 || 0x30 > *c) throw std::invalid_argument(""); r = r * 10 + *c - 0x30; ++z;
	}
	if (z == 3 && *++c) {
	  if (r > 6553 || *c > 0x35 || 0x30 > *c) throw std::range_error("");
	  r = r * 10 + *c - 0x30;
	} return r;
  }
  template <> [[nodiscard]] _INLINE
	int lexical_cast<int>(const char* c) {
	size_t l = strlen(c); if (*c != 0x2D) {
	  if (l < 11) {
		if (*c > 0x39 || 0x30 > *c) throw std::invalid_argument("");
		int r = STD_POW[--l] * (*c - 0x30);
		while (--l) {
		  if (*++c > 0x39 || 0x30 > *c) throw std::invalid_argument("");
		  r += STD_POW[l] * (*c - 0x30);
		}
		if (*++c > 0x39 || 0x30 > *c) throw std::range_error("");
		r += *c - 0x30; if (r < 0) throw std::range_error("");
		return r;
	  } throw std::out_of_range("");
	} else if (--l < 11) {
	  if (*++c > 0x39 || 0x30 > *c) throw std::invalid_argument("");
	  int r = STD_POW[--l] * (0x30 - *c);
	  while (--l) {
		if (*++c > 0x39 || 0x30 > *c) throw std::invalid_argument("");
		r -= STD_POW[l] * (*c - 0x30);
	  }
	  if (*++c > 0x39 || 0x30 > *c) throw std::range_error("");
	  r -= *c - 0x30; if (r > 0) throw std::range_error("");
	  return r;
	} throw std::out_of_range("");
  }
  template <> [[nodiscard]] _INLINE
	unsigned int lexical_cast<unsigned int>(const char* c) {
	size_t l = strlen(c); if (--l < 9) {
	  if (*c > 0x39 || 0x30 > *c) throw std::invalid_argument("");
	  unsigned int r = STD_POW[l] * (*c++ - 0x30);
	  while (--l > 1) {
		if (*c > 0x39 || 0x30 > *c) throw std::invalid_argument("");
		r += STD_POW[l] * (*c++ - 0x30);
	  }
	  if (*c > 0x39 || 0x30 > *c) throw std::range_error("");
	  r += *c - 0x30; return r;
	} else if (--l == 8) {
	  if (*c > 0x39 || 0x30 > *c) throw std::invalid_argument("");
	  unsigned int r = STD_POW[l] * (*c++ - 0x30);
	  while (--l) {
		if (*c > 0x39 || 0x30 > *c) throw std::invalid_argument("");
		r += STD_POW[l] * (*c++ - 0x30);
	  }
	  if (*c > 0x39 || 0x30 > *c) throw std::invalid_argument("");
	  r += *c++ - 0x30;
	  if (r > 429496729 || *c > 0x35 || 0x30 > *c) throw std::range_error("");
	  r = r * 10 + *c - 0x30; return r;
	} throw std::invalid_argument("");
  }
  template <> [[nodiscard]] _INLINE
	long long lexical_cast<long long>(const char* c) {
	size_t l = strlen(c); if (*c != 0x2D) {
	  if (l < 20) {
		if (*c > 0x39 || 0x30 > *c) throw std::invalid_argument("");
		long long r = STD_POWS[--l] * (*c - 0x30);
		while (--l) {
		  if (*++c > 0x39 || 0x30 > *c) throw std::invalid_argument("");
		  r += STD_POWS[l] * (*c - 0x30);
		}
		if (*++c > 0x39 || 0x30 > *c) throw std::range_error("");
		r += *c - 0x30; if (r < 0) throw std::range_error("");
		return r;
	  } throw std::out_of_range("");
	} else if (--l < 20) {
	  if (*++c > 0x39 || 0x30 > *c) throw std::invalid_argument("");
	  long long r = STD_POWS[--l] * (0x30 - *c);
	  while (--l) {
		if (*++c > 0x39 || 0x30 > *c) throw std::invalid_argument("");
		r -= STD_POWS[l] * (*c - 0x30);
	  }
	  if (*++c > 0x39 || 0x30 > *c) throw std::range_error("");
	  r -= *c - 0x30; if (r > 0) throw std::range_error("");
	  return r;
	} throw std::out_of_range("");
  }
  template <> [[nodiscard]] _INLINE
	unsigned long long lexical_cast<unsigned long long>(const char* c) {
	size_t l = strlen(c); if (--l < 19) {
	  if (*c > 0x39 || 0x30 > *c) throw std::invalid_argument("");
	  unsigned long long r = STD_POWS[l] * (*c++ - 0x30);
	  while (--l > 1) {
		if (*c > 0x39 || 0x30 > *c) throw std::invalid_argument("");
		r += STD_POWS[l] * (*c++ - 0x30);
	  }
	  if (*c > 0x39 || 0x30 > *c) throw std::range_error("");
	  r += *c - 0x30; return r;
	} else if (--l == 18) {
	  if (*c > 0x39 || 0x30 > *c) throw std::invalid_argument("");
	  unsigned long long r = STD_POWS[l] * (*c++ - 0x30);
	  while (--l) {
		if (*c > 0x39 || 0x30 > *c) throw std::invalid_argument("");
		r += STD_POWS[l] * (*c++ - 0x30);
	  }
	  if (*c > 0x39 || 0x30 > *c) throw std::invalid_argument("");
	  r += *c++ - 0x30;
	  if (r > 1844674407370955161 || *c > 0x35 || 0x30 > *c) throw std::range_error("");
	  r = r * 10 + *c - 0x30; return r;
	} throw std::invalid_argument("");
  }
  template <> [[nodiscard]] _INLINE
	float lexical_cast<float>(const char* c) {
	char* $; const float _ = ::strtof(c, &$); if (*$ == 0) return _; throw std::invalid_argument("");
  }
  template <> [[nodiscard]] _INLINE
	double lexical_cast<double>(const char* c) {
	char* $; const double _ = ::strtod(c, &$); if (*$ == 0) return _; throw std::invalid_argument("");
  }
  template <> [[nodiscard]] _INLINE
	long double lexical_cast<long double>(const char* c) {
	char* $; const long double _ = ::strtold(c, &$); if (*$ == 0) return _; throw std::invalid_argument("");
  }
  template <> _INLINE
  tm lexical_cast<tm>(const char* c) {
	int year = 0, month = 0, day = 0, hour = 0, min = 0, sec = 0; tm t;
	if (sscanf(c, "%4d-%2d-%2d %2d:%2d:%2d", &year, &month, &day, &hour, &min, &sec) == 6) {
	  t.tm_mday = day;
	  t.tm_hour = hour;
	  t.tm_min = min;
	  t.tm_sec = sec;
	}
	t.tm_year = year - 1900;
	t.tm_mon = month - 1;
	return t;
  }
  //std::string
  template <typename T> inline T lexical_cast(std::string& s);

  template <> [[nodiscard]] _INLINE
	bool lexical_cast<bool>(std::string& s) {
	if (s == "1" || s == "true")return true; if (s == "0" || s == "false")return false; throw std::invalid_argument("");
  }
  template <> [[nodiscard]] _INLINE
	signed char lexical_cast<signed char>(std::string& s) {
	const char* c = s.c_str(); signed char r;
	if (*c != 0x2D) {
	  if (*c > 0x39 || 0x30 > *c) throw std::invalid_argument(""); r = *c - 0x30;
	  while (*++c) {
		r = r * 10 + *c - 0x30; if (r <= 0 || *c > 0x39 || 0x30 > *c) throw std::range_error("");
	  } return r;
	}
	if (*++c > 0x39 || 0x30 > *c) throw std::invalid_argument(""); r = 0x30 - *c;
	while (*++c) {
	  r = r * 10 - *c + 0x30; if (r >= 0 || *c > 0x39 || 0x30 > *c) throw std::range_error("");
	}; return r;
  }
  template <> [[nodiscard]] _INLINE
	unsigned char lexical_cast<unsigned char>(std::string& s) {
	const char* c = s.c_str();
	if (*c > 0x39 || 0x30 > *c) throw std::invalid_argument(""); unsigned char r = *c - 0x30; char z = 0;
	while (z != 1 && *++c) {
	  if (*c > 0x39 || 0x30 > *c) throw std::invalid_argument(""); r = r * 10 + *c - 0x30; ++z;
	}
	if (z == 1 && *++c) {
	  if (r > 25 || *c > 0x35 || 0x30 > *c) throw std::range_error("");
	  r = r * 10 + *c - 0x30;
	} return r;
  }
  template <> [[nodiscard]] _INLINE
	short lexical_cast<short>(std::string& s) {
	const char* c = s.c_str(); size_t l = s.size();
	if (*c != 0x2D) {
	  if (l < 6) {
		if (*c > 0x39 || 0x30 > *c) throw std::invalid_argument("");
		short r = STD_PO[--l] * (*c - 0x30);
		while (--l) {
		  if (*++c > 0x39 || 0x30 > *c) throw std::invalid_argument("");
		  r += STD_PO[l] * (*c - 0x30);
		}
		if (*++c > 0x39 || 0x30 > *c) throw std::range_error("");
		r += *c - 0x30; if (r < 0) throw std::range_error("");
		return r;
	  } throw std::out_of_range("");
	}
	if (--l < 6) {
	  if (*++c > 0x39 || 0x30 > *c) throw std::invalid_argument("");
	  short r = STD_PO[--l] * (0x30 - *c);
	  while (--l) {
		if (*++c > 0x39 || 0x30 > *c) throw std::invalid_argument("");
		r -= STD_PO[l] * (*c - 0x30);
	  }
	  if (*++c > 0x39 || 0x30 > *c) throw std::range_error("");
	  r -= *c - 0x30; if (r > 0) throw std::range_error("");
	  return r;
	} throw std::out_of_range("");
  }
  template <> [[nodiscard]] _INLINE
	unsigned short lexical_cast<unsigned short>(std::string& s) {
	const char* c = s.c_str(); size_t l = s.length();
	if (--l < 4) {
	  if (*c > 0x39 || 0x30 > *c) throw std::invalid_argument("");
	  unsigned short r = STD_PO[l] * (*c++ - 0x30);
	  while (--l > 1) {
		if (*c > 0x39 || 0x30 > *c) throw std::invalid_argument("");
		r += STD_PO[l] * (*c++ - 0x30);
	  }
	  if (*c > 0x39 || 0x30 > *c) throw std::range_error("");
	  r += *c - 0x30;
	  return r;
	}
	if (--l == 3) {
	  if (*c > 0x39 || 0x30 > *c) throw std::invalid_argument("");
	  unsigned short r = STD_PO[l] * (*c++ - 0x30);
	  while (--l) {
		if (*c > 0x39 || 0x30 > *c) throw std::invalid_argument("");
		r += STD_PO[l] * (*c++ - 0x30);
	  }
	  if (*c > 0x39 || 0x30 > *c) throw std::invalid_argument("");
	  r += *c++ - 0x30;
	  if (r > 6553 || *c > 0x35 || 0x30 > *c) throw std::range_error("");
	  r = r * 10 + *c - 0x30;
	  return r;
	} throw std::invalid_argument("");
  }
  template <> [[nodiscard]] _INLINE
	int lexical_cast<int>(std::string& s) {
	const char* c = s.c_str(); size_t l = s.size();
	if (*c != 0x2D) {
	  if (l < 11) {
		if (*c > 0x39 || 0x30 > *c) throw std::invalid_argument("");
		int r = STD_POW[--l] * (*c - 0x30);
		while (--l) {
		  if (*++c > 0x39 || 0x30 > *c) throw std::invalid_argument("");
		  r += STD_POW[l] * (*c - 0x30);
		}
		if (*++c > 0x39 || 0x30 > *c) throw std::range_error("");
		r += *c - 0x30; if (r < 0) throw std::range_error("");
		return r;
	  } throw std::out_of_range("");
	}
	if (--l < 11) {
	  if (*++c > 0x39 || 0x30 > *c) throw std::invalid_argument("");
	  int r = STD_POW[--l] * (0x30 - *c);
	  while (--l) {
		if (*++c > 0x39 || 0x30 > *c) throw std::invalid_argument("");
		r -= STD_POW[l] * (*c - 0x30);
	  }
	  if (*++c > 0x39 || 0x30 > *c) throw std::range_error("");
	  r -= *c - 0x30; if (r > 0) throw std::range_error("");
	  return r;
	} throw std::out_of_range("");
  }
  template <> [[nodiscard]] _INLINE
	unsigned int lexical_cast<unsigned int>(std::string& s) {
	const char* c = s.c_str(); size_t l = s.length();
	if (--l < 9) {
	  if (*c > 0x39 || 0x30 > *c) throw std::invalid_argument("");
	  unsigned int r = STD_POW[l] * (*c++ - 0x30);
	  while (--l > 1) {
		if (*c > 0x39 || 0x30 > *c) throw std::invalid_argument("");
		r += STD_POW[l] * (*c++ - 0x30);
	  }
	  if (*c > 0x39 || 0x30 > *c) throw std::range_error("");
	  r += *c - 0x30;
	  return r;
	}
	if (--l == 8) {
	  if (*c > 0x39 || 0x30 > *c) throw std::invalid_argument("");
	  unsigned int r = STD_POW[l] * (*c++ - 0x30);
	  while (--l) {
		if (*c > 0x39 || 0x30 > *c) throw std::invalid_argument("");
		r += STD_POW[l] * (*c++ - 0x30);
	  }
	  if (*c > 0x39 || 0x30 > *c) throw std::invalid_argument("");
	  r += *c++ - 0x30;
	  if (r > 429496729 || *c > 0x35 || 0x30 > *c) throw std::range_error("");
	  r = r * 10 + *c - 0x30;
	  return r;
	} throw std::invalid_argument("");
  }
  template <> [[nodiscard]] _INLINE
	long long lexical_cast<long long>(std::string& s) {
	const char* c = s.c_str(); size_t l = s.size();
	if (*c != 0x2D) {
	  if (l < 20) {
		if (*c > 0x39 || 0x30 > *c) throw std::invalid_argument("");
		long long r = STD_POWS[--l] * (*c - 0x30);
		while (--l) {
		  if (*++c > 0x39 || 0x30 > *c) throw std::invalid_argument("");
		  r += STD_POWS[l] * (*c - 0x30);
		}
		if (*++c > 0x39 || 0x30 > *c) throw std::range_error("");
		r += *c - 0x30; if (r < 0) throw std::range_error("");
		return r;
	  } throw std::out_of_range("");
	}
	if (--l < 20) {
	  if (*++c > 0x39 || 0x30 > *c) throw std::invalid_argument("");
	  long long r = STD_POWS[--l] * (0x30 - *c);
	  while (--l) {
		if (*++c > 0x39 || 0x30 > *c) throw std::invalid_argument("");
		r -= STD_POWS[l] * (*c - 0x30);
	  }
	  if (*++c > 0x39 || 0x30 > *c) throw std::range_error("");
	  r -= *c - 0x30; if (r > 0) throw std::range_error("");
	  return r;
	} throw std::out_of_range("");
  }
  template <> [[nodiscard]] _INLINE
	unsigned long long lexical_cast<unsigned long long>(std::string& s) {
	const char* c = s.c_str(); size_t l = s.length();
	if (--l < 19) {
	  if (*c > 0x39 || 0x30 > *c) throw std::invalid_argument("");
	  unsigned long long r = STD_POWS[l] * (*c++ - 0x30);
	  while (--l > 1) {
		if (*c > 0x39 || 0x30 > *c) throw std::invalid_argument("");
		r += STD_POWS[l] * (*c++ - 0x30);
	  }
	  if (*c > 0x39 || 0x30 > *c) throw std::range_error("");
	  r += *c - 0x30;
	  return r;
	}
	if (--l == 18) {
	  if (*c > 0x39 || 0x30 > *c) throw std::invalid_argument("");
	  unsigned long long r = STD_POWS[l] * (*c++ - 0x30);
	  while (--l) {
		if (*c > 0x39 || 0x30 > *c) throw std::invalid_argument("");
		r += STD_POWS[l] * (*c++ - 0x30);
	  }
	  if (*c > 0x39 || 0x30 > *c) throw std::invalid_argument("");
	  r += *c++ - 0x30;
	  if (r > 1844674407370955161 || *c > 0x35 || 0x30 > *c) throw std::range_error("");
	  r = r * 10 + *c - 0x30;
	  return r;
	} throw std::invalid_argument("");
  }
  template <> [[nodiscard]] _INLINE
	float lexical_cast<float>(std::string& s) {
	const char* c = s.c_str();
	char* $; const float _ = ::strtof(c, &$); if (*$ == 0) return _; throw std::invalid_argument("");
  }
  template <> [[nodiscard]] _INLINE
	double lexical_cast<double>(std::string& s) {
	const char* c = s.c_str();
	char* $; const double _ = ::strtod(c, &$); if (*$ == 0) return _; throw std::invalid_argument("");
  }
  template <> [[nodiscard]] _INLINE
	long double lexical_cast<long double>(std::string& s) {
	const char* c = s.c_str();
	char* $; const long double _ = ::strtold(c, &$); if (*$ == 0) return _; throw std::invalid_argument("");
  }
  template <> _INLINE
  tm lexical_cast<tm>(std::string& s) {
	const char* c = s.c_str();
	int year = 0, month = 0, day = 0, hour = 0, min = 0, sec = 0; tm t;
	if (sscanf(c, "%4d-%2d-%2d %2d:%2d:%2d", &year, &month, &day, &hour, &min, &sec) == 6) {
	  t.tm_mday = day;
	  t.tm_hour = hour;
	  t.tm_min = min;
	  t.tm_sec = sec;
	}
	t.tm_year = year - 1900;
	t.tm_mon = month - 1;
	return t;
  }
  #undef _INLINE
}
#endif // LEXICAL_CAST_HPP

使用

上面的代码保存为lexical_cast.hpp,然后引入;然后编译运行即可。

#include "lexical_cast.hpp"
#include <time.h>
#include <iostream>

int main() {
  clock_t start = clock();
  unsigned long long l;
  std::string s("18446744073709551615", 20),
	num("18446744073709551615", 20);
  for (unsigned long long i = 5; i < 9672955; ++i) {
	l = std::lexical_cast<unsigned long long>(num);
  }
  printf("use %.6f seconds\n", (float)(clock() - start) / CLOCKS_PER_SEC);
  l = std::lexical_cast<unsigned long long>(s);
  std::cout << l;
  return 0;
}

运行效果

为了方便，推荐使用本人的开源库FabCc，引入即可使用刚刚介绍的功能
在这里插入图片描述

[FabCc开源仓库地址](asciphx/FabCc: Concise, fast, practical, reactive, functional. c++ web… (github.com))

[FabCc镜像仓库地址](FabCc: 码造一个比boost更快的库。目标：简洁、迅速、实用、活跃、全面。 (gitee.com))

本人来实现的lexical_cast的性能跟boost的库实现的性能更快，更牛逼。具体测试所花的时间来看比boost快数倍左右！这么操作的目的很简单，就是为了加快编译速度与运行速度，以及减少项目的库依赖。

友情链接

本文转载自，我最牛逼我最6的文章。原贴地址

Asciphx
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
boost::lexical_cast用法
05-03
boost::lexical_cast用法示例，包含数值转字串，字串转数值以及相应的异常处理代码
c++ boost库学习-01-lexical_cast
FairLikeSnow的博客
05-20 691
lexical_cast
C++ 笔记 boost::lexical_cast数据类型转换器
flyconley的博客
03-01 415
lexical_cast是boost库中提供的数据类型转换器，用法如下： #include <boost/lexical_cast.hpp> string s = "123"; int a = lexical_cast<int>(s); lexical_cast的原型如下： template<typename Target, ty...
【C++】Boost库LexicalCast模块介绍与使用
最新发布
qq_60755751的博客
12-06 1037
lexical_cast库进行”字面值“之间的通用转换头文件如果我们想要将lexical_cast应用于自定义的类，需要实现流操作符operator自定义类转字符串public:private:public :字符串转自定义类public:x_ = pt.x_;float x_;参考资料1参考资料2。
用boost::lexical_cast进行数值转换
weixin_30376163的博客
02-05 170
在STL库中，我们可以通过stringstream来实现字符串和数字间的转换： int i = 0;stringstream ss;ss << "123";ss >> i; 但stringstream是没有错误检查的功能，例如对如如下代码，会将i给赋值为12. ss << "12.3";ss &g...
boost之lexical_cast之字符串转换成数值.rar_Boost_boost_字符串转换成数值
09-24
总结一下，Boost库的`lexical_cast`是进行类型转换的强大工具，特别是对于字符串与数值之间的转换。它提供了异常安全的机制，并且代码简洁易读。在C++编程中，当你需要进行类型转换时，不妨考虑使用`lexical_cast`来...
lexical_cast:常规文字文本转换，例如以字符串表示的int，反之亦然
04-13
在C++编程中，数据类型转换是一个常见的任务，特别是在处理用户输入或进行数据解析时。Boost库提供了一个非常有用的工具，即`Boost.LexicalCast`，它简化了字符串与基本数据类型之间的转换过程。本篇文章将深入探讨`...
C++ boost::asio编程-域名解析详细介绍
09-01
这里的端口号使用`boost::lexical_cast<string>`转换为字符串类型，这是因为`resolve`方法期望接收字符串类型的端口。 4. 使用`slv.resolve(qry)`来发起解析请求。`resolve`方法会查找并返回一个迭代器，该迭代器...
boost的类型转换
01-31
原来我总结过c++的一些类型转换函数：static_cast,dynamic_cast,const_cast, reinterpret_cast其中各有各的用处和弊端。boost的Conversion库分别实现了四个类型转换函数：polymorphic_case, polymorphic_downcast,...
实现 boost lexical_cast（基本类型转换）
王伟挺的专栏
08-05 5923
boost 中的lexical_cast专门用于基本数据类型转换 比如 int float bool double string ,但是使用时必须引入boost 库，如何自己实现一个相似的函数呢，答案便是使用到模板。 实现如下： #include #include #include #include #include #include #include #include usi
4.6.2 万能转换器boost::lexical_cast
白乔专栏
08-19 1868
C++ foreach & boost::lexical_cast
chansoncc的专栏
08-31 143
C++ foreach 考虑下面的需求，对vector&lt;int&gt;中的每个元素加1，如何做？ void add(int&amp; lhs) // 注意：要修改主调方法中的数据，这里要使用引用 { lhs= lhs + 1; } int intArray[] = {1,2,3,4,5}; vector&lt;int&gt; intVector(intArray,intAr...
c++11实现一个简单的lexical_cast
weixin_34352449的博客
05-28 280
　　boost中有一个lexical_cast可以用统一的方式来做基本类型之间的转换，比如字符串到数字，数字到字符串，bool和字符串及数字之间的相互转换。boost::lexical_cast的用法比较简单： #include &lt;boost/lexical_cast.hpp&gt; #include &lt;iostream&gt; #include &lt;string&g...
Boost库Lexical_Cast模块使用介绍
xuyouqiang1987的博客
04-03 488
Boost库Lexical_Cast模块使用介绍
C++ Boost库：字符串格式化 format
超级大洋葱的博客
05-04 3539
文章目录1. C/C++格式化2. boost格式化 1. C/C++格式化 在字符串处理中少不了格式化字符串；C++中传统的格式化函数是C语言的 printf、sprintf，但它一个很大的问题就是不安全。因此，在STL中引入了 stringstream来实现安全格式化，但是 stringstream却远不如 sprintf来得直观。 printf("%s %d %c", "hello", 111, 'C') 2. boost格式化 boost::format提供了一个和C的 printf类似的格式化字
数值转换lexical_cast的使用
椛茶的博客
03-24 2267
1.C语言中的数值类型转换 在 C 语言中提供了几个标准库函数，可以将字符串与整型，浮点型等进行转换。 atof() 将字符串转换为双精度浮点型值 atoi() 将字符串转换为整型值 atol() 将字符串转换为长整型值 itoa() 将整型值转换为字符串 gcvt() 将浮点数类型值转换为字符串 ...
C++流实现内幕---由boost::lexical_cast引发的一个问题
ugg的专栏
11-26 7353
Normal 0 7.8 磅 0 2 false false false MicrosoftInternetExplorer4 <!-- /* Font
boost/lexical_cast.hpp的简单使用方法
静故了群动
11-24 2490
#include lexical_cast.hpp>  #include   #include    int main()   {           using std::string;         using std::cout;           using std::endl;          int i;           try           {           
boost::lexical_cast是怎么使用的
04-19
boost::lexical_cast是一个模板函数，用于将一个字符串转换为一个特定类型的值或将一个特定类型的值转换为字符串。使用时需要包含boost/lexical_cast.hpp头文件，并调用该函数的模板形式。 例如，将字符串转换为...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值