Как вставить пробелы в большое число, чтобы сделать его более читабельным?

Question

Я придумал это, так как другие примеры, представленные на stackoverflow, были в C #

string number_fmt(ulong n)
{
    // cout << "(" << n << ")" << endl;
    char s[128];
    sprintf(s, "%lu", n);
    string r(s);
    reverse(r.begin(), r.end());
    int space_inserted = 0;
    size_t how_many_spaces = r.length() / 3;

    if(r.length() % 3 != 0)
        how_many_spaces += 1;

    for(int i = 1; i < how_many_spaces; ++i)
    {
        r.insert(3 * i + space_inserted, " ");
        space_inserted += 1;
    }
    reverse(r.begin(), r.end());

    return r;
}

Знаете ли вы лучшее решение?

Answer 1

Я не знаю про "лучше", но эта версия использует std::locale и т. Д.

#include <iostream>
#include <locale>
#include <sstream>

template<class Char>
class MyFacet : public std::numpunct<Char> {
public:
  std::string do_grouping() const { return "\3"; }
  Char do_thousands_sep() const { return ' '; }
};

std::string number_fmt(unsigned long n)
{
  std::ostringstream oss;
  oss.imbue(std::locale(oss.getloc(), new MyFacet<char>));
  oss << n;
  return oss.str();
}

int main() {
  std::cout << number_fmt(123456789) << "\n";
}

РЕДАКТИРОВАТЬ : Конечно, если вашей конечной целью является печать значений на ostream, вы можете вообще пропустить их сохранение в string.

#include <iostream>
#include <locale>
#include <sstream>
#include <cwchar>

template <class Char>
class MyFacet : public std::numpunct<Char> {
public:
  std::string do_grouping() const { return "\3"; }
  Char do_thousands_sep() const { return ' '; }
};

int main(int ac, char **av) {
  using std::locale;
  using std::cout;

  // Show how it works to start with
  cout << 123456789 << "\n";

  // Switch it to spacey mode
  locale oldLoc =
    cout.imbue(locale(cout.getloc(), new MyFacet<char>));

  // How does it work now?
  cout << 456789123 << "\n";

  // You probably want to clean up after yourself
  cout.imbue(oldLoc);

  // Does it still work?
  cout << 789123456 << "\n";
}

Answer 2

Это уже сделано языковым стандартом.

Локальным по умолчанию является «C», который не выполняет форматирование. Но вы можете установить его на свой текущий локальный язык (в соответствии с настройками вашего компьютера, указав текущий локальный как первую строку main).

int main()
{
    std::locale::global(std::locale("")); // Set the default local of the machine
                                          // Will be used by all streams.
                                          // The "" will find the machine specific local
                                          // and use that instead of the "C" locale
                                          // Note: The C local should only be used for programmers.

    // Alternatively you can imbue particular stream with the local
    // To achieve a localized effect
    // std::cout.imbue(std::locale(""));

    // Now all you do is print the number.
    std::cout << "123456789\n";  // This will print the number according to your local
}                                // For me US-en this is   123,456,789
                                 // Your may very.

Если вы хотите сделать что-то явно, вы можете установить локальный фасет для печати чисел.

#include <iostream>
#include <locale>
#include <string>


template<typename CharT>
struct Sep : public std::numpunct<CharT>
{
        virtual std::string do_grouping()      const   {return "\003";}
        virtual CharT       do_thousands_sep() const   {return ':';}
};

int main()
{
        std::cout.imbue(std::locale(std::cout.getloc(), new Sep <char>()));

        std::cout << 123456789 << "\n";   // this prints 123:456:789
}

Answer 3

Этот отличается, но лучше субъективен. Я думаю, что это очень кратко и ясно, что он делает, хотя:

string number_fmt(unsigned long long n, char sep = ',') {
    stringstream fmt;
    fmt << n;
    string s = fmt.str();
    s.reserve(s.length() + s.length() / 3);

    // loop until the end of the string and use j to keep track of every
    // third loop starting taking into account the leading x digits (this probably
    // can be rewritten in terms of just i, but it seems more clear when you use
    // a seperate variable)
    for (int i = 0, j = 3 - s.length() % 3; i < s.length(); ++i, ++j)
        if (i != 0 && j % 3 == 0)
            s.insert(i++, 1, sep);

    return s;
}

Используя это как

cout << number_fmt(43615091387465) << endl;

печать

43,615,091,387,465

Answer 4

Конечно, если кто-то хотел иметь максимально возможную эффективную версию и не возражал специализировать ее для рассматриваемого случая, использование локального буфера символов может очень помочь.

#include <iostream>
#include <string>

std::string format(unsigned long long i) {
  char buffer[128]; // can be adapted more tightly with std::numeric_limits

  char* p = buffer + 128;
  *(--p) = '\0';

  unsigned char count = 0;
  while (i != 0) {
    *(--p) = '0' + (i % 10);
    i /= 10;

    if (++count == 3) { count = 0; *(--p) = ' '; }
  }

  return p;
}

int main() {
  std::cout << format(1234567890) << '\n';
}

В действии на ideone :

1 234 567 890

(ключевой момент: для печати цифр перейти назад )

Answer 5

Если «лучше» означает более эффективный, вы должны:

1. используйте reserve в выходной строке (вы знаете ее размер ...)

2. избегайте insert в середине строки, потому что вы должны копировать большую часть строки каждый раз, когда вы делаете это.

Я бы сказал что-то вроде этого (не проверено):

std::string number_fmt (ulong n)
{
  std::ostringstream buff;
  buff << n;
  std::string without_spaces = buff.str ();
  std::string with_spaces;
  with_spaces.reserve ((without_spaces.size () * 4) / 3);
  std::size_t nb_inserted = 0;

  for (auto it = without_spaces.rbegin (); it != without_spaces.rend (); ++it)
  {
     if (nb_inserted % 3  ==  0  &&  nb_inserted != 0)
     {
         with_spaces.push_back (' ');
     }
     ++ nb_inserted;

     with_spaces.push_back (*it);   
  }
  std::reverse (with_spaces.begin (), with_spaces.end ());
  return with_spaces;
}