Optimise IntToString by avoiding string allocation.

base/strings/string_number_conversions.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/strings/string_number_conversions.h"
 
 #include <ctype.h>
 #include <errno.h>
 #include <stdlib.h>
 #include <wctype.h>
 
 #include <limits>
 
 #include "base/logging.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/numerics/safe_math.h"
 #include "base/scoped_clear_errno.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/third_party/dmg_fp/dmg_fp.h"
 
 namespace base {
 
 namespace {
 
 template <typename STR, typename INT>
 struct IntToStringT {
   static STR IntToString(INT value) {
     // log10(2) ~= 0.3 bytes needed per bit or per byte log10(2**8) ~= 2.4.
     // So round up to allocate 3 output characters per byte, plus 1 for '-'.
-    const int kOutputBufSize =
+    const size_t kOutputBufSize =
         3 * sizeof(INT) + std::numeric_limits<INT>::is_signed;
 
-    // Allocate the whole string right away, we will right back to front, and
+    // Create the string in a temporary buffer, write it back to front, and
     // then return the substr of what we ended up using.
-    STR outbuf(kOutputBufSize, 0);
+    using CHR = typename STR::value_type;
+    CHR outbuf[kOutputBufSize];
 
     // The ValueOrDie call below can never fail, because UnsignedAbs is valid
     // for all valid inputs.
     auto res = CheckedNumeric<INT>(value).UnsignedAbs().ValueOrDie();
 
-    typename STR::iterator it(outbuf.end());
+    CHR* end = outbuf + kOutputBufSize;
+    CHR* i = end;
     do {
-      --it;
-      DCHECK(it != outbuf.begin());
-      *it = static_cast<typename STR::value_type>((res % 10) + '0');
+      --i;
+      DCHECK(i != outbuf);
+      *i = static_cast<CHR>((res % 10) + '0');
       res /= 10;
     } while (res != 0);
     if (IsValueNegative(value)) {
-      --it;
-      DCHECK(it != outbuf.begin());
-      *it = static_cast<typename STR::value_type>('-');
+      --i;
+      DCHECK(i != outbuf);
+      *i = static_cast<CHR>('-');
     }
-    return STR(it, outbuf.end());
+    return STR(i, end);
   }
 };
 
 // Utility to convert a character to a digit in a given base
 template<typename CHAR, int BASE, bool BASE_LTE_10> class BaseCharToDigit {
 };
 
 // Faster specialization for bases <= 10
 template<typename CHAR, int BASE> class BaseCharToDigit<CHAR, BASE, true> {
  public:
@@ skipping 412 matching lines @@
 bool HexStringToUInt64(const StringPiece& input, uint64* output) {
   return IteratorRangeToNumber<HexIteratorRangeToUInt64Traits>::Invoke(
       input.begin(), input.end(), output);
 }
 
 bool HexStringToBytes(const std::string& input, std::vector<uint8>* output) {
   return HexStringToBytesT(input, output);
 }
 
 }  // namespace base