преобразуйте астрономически большие количества в человекочитаемую форму в C/C++

Вы можете использовать humanize_number (), который использует суффиксы, такие как k, m и т. Д., Чтобы опустить младшие цифры. Это не стандартная процедура, поэтому вам следует удалить источник, на который я ссылаюсь. (Лицензия BSD с двумя пунктами, разрешает любое использование.)

Справочная страница Humanize_number .

Исходный код Humanize_number из NetBSD .

HUMANIZE_NUMBER(3)      NetBSD Library Functions Manual     HUMANIZE_NUMBER(3)

NAME
     dehumanize_number, humanize_number -- format a number into a human read-
     able form and viceversa

SYNOPSIS
     #include <stdlib.h>

     int
     dehumanize_number(const char *str, int64_t *result);

     int
     humanize_number(char *buf, size_t len, int64_t number,
         const char *suffix, int scale, int flags);

Это работает путем добавления суффиксов следующим образом:

       Suffix    Description    Multiplier
       k         kilo           1024
       M         mega           1048576
       G         giga           1073741824
       T         tera           1099511627776
       P         peta           1125899906842624
       E         exa            1152921504606846976

Простым способом может быть преобразование в double непосредственно перед выводом и использование% e, которое распечатает их в экспоненциальной экспоненциальной нотации. Попробуйте следующее:

double n = (double)number;
printf("%10.0e", n);

Вот пример, который я написал на прямом C без использования локали. Работает только на позитив. (Большая помощь от "DiscoVlad")

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <strings.h>


void my_reverse ( char* s ) {
    int c, i, j;
    for (i=0, j= strlen(s)-1;i<j;i++,j--) {
        c = s[i];
        s[i] = s[j];
        s[j] = c;
    }
}


char* insert_commas(unsigned long long input ) {
    int i, intlen;
    char* buffer;
    char* formatted;

    intlen = (int) ceil(log10(input * 1.0));
    buffer = (char *) malloc((intlen + 1) * sizeof(char));

    sprintf(buffer, "%llu", input);  // build buffer
    formatted = (char *) malloc((intlen + (int) ceil(intlen/3.0)) * sizeof(char));  // malloc output buffer
    my_reverse(buffer);

    for(i=intlen; i>=0; i--) {
        formatted[strlen(formatted)] = buffer[i];
        if (i%3 == 0 && i<intlen && i > 0) {
            formatted[strlen(formatted)] = ',';
        }
    }
    free(buffer);

    return formatted;
}


int main() {
    char* formatted;

    // don't forget to free(formatted) after each call.
    formatted = insert_commas(123);
    printf("output %s\n", formatted);
    // output 123

    formatted = insert_commas(1234);
    printf("output %s\n", formatted);
    // output 1,234

    formatted = insert_commas(123456);
    printf("output %s\n", formatted);
    // output 123,456

    formatted = insert_commas(1234567);
    printf("output %s\n", formatted);
    // output 1,234,567

    formatted = insert_commas(123456789);
    printf("output %s\n", formatted);
    // output 123,456,789

    formatted = insert_commas(12345678901234567890ull);
    printf("output %s\n", formatted);
    // output 12,345,678,901,234,567,890

}

Помните о локализации (особенно если вы пишете библиотека).
В Европе (кроме Великобритании) это будет 1.000.000, а не 1.000.000

std::cout << std::setprecision(5) << std::scientific << 100363443.0;

обратите внимание, что это число с плавающей запятой

РЕДАКТИРОВАТЬ: или, если вам не нравится наука, я нашел это в сети:

struct comma : public std::numpunct<char>
{ 
    protected: std::string do_grouping() const { return "\003" ; } 
};

std::cout.imbue( std::locale( std::cout.getloc(), new comma ) );
std::cout << 100363443 << std::endl;

РЕДАКТИРОВАТЬ 2: Как указал Джерри, вы не используете 'не нужен класс запятой, как указано выше, этого кажется достаточно само по себе (хотя есть предположительно локали, которые вообще не форматируют большие числа?):

std::cout.imbue( std::locale( "" ) );
std::cout << 100363443 << std::endl;