如何在Arduino上格式化長添加千位分隔符

Question

我正在Arduino上開發一個項目，它解析來自遠程Web API的一些JSON數據，並在16x2 LCD上顯示它。

我想格式化一個長解析TextFinder添加千位分隔符（逗號分隔符將罰款）。

簡而言之，我該如何編寫formatLong函數？

long longToBeFormatted = 32432423; 

formattedLong = formatLong(longToBeFormatted); //How to implement this? 

lcd.print(formattedLong) // formattedLong is a string 

Answer 1

我不確定在Arduino上使用了哪些工具集。有時候庫將支持非標準的「千人分組」標誌 - 單引號字符是典型的擴展：

printf("%'ld",long_val); 

如果你的庫不支持這一點，像下面這樣可能會做：

#include <stddef.h> 
#include <string.h> 
#include <limits.h> 
#include <stdio.h> 
#include <assert.h> 

size_t strlcpy(char* dest, char const* src, size_t dest_size); 

size_t format_long(long x, char* buf, size_t bufsize) 
{ 
    // This code assumes 32-bit long, is that the 
    // case on Arduino? Modifying it to be able to 
    // handle 64-bit longs (or to not care) should be 
    // pretty straightforward if that's necessary. 

    char scratch[sizeof("-2,147,483,648")]; 
    char* p = scratch + sizeof(scratch); // Work from end of buffer 
    int neg = (x < 0); 

    // Handle a couple special cases 
    if (x == 0) { 
     return strlcpy(buf, "0", bufsize); 
    } 
    if (x == INT_MIN) { 
     // Lazy way of handling this special case 
     return strlcpy(buf, "-2,147,483,648", bufsize); 
    } 

    // Work with positive values from here on 
    if (x < 0) x = -x; 

    int group_counter = 3; 
    *(--p) = 0; // Null terminate the scratch buffer 

    while (x != 0) { 
     int digit = x % 10; 
     x = x/10; 

     assert(p != &scratch[0]); 
     *(--p) = ""[digit]; 

     if ((x != 0) && (--group_counter == 0)) { 
      assert(p != &scratch[0]); 
      *(--p) = ','; 
      group_counter = 3; 
     } 
    } 

    if (neg) { 
     assert(p != &scratch[0]); 
     *(--p) = '-'; 
    } 
    return strlcpy(buf, p, bufsize); 
} 


/* 
    A non-optimal strlcpy() implementation that helps copying string 
    without danger of buffer overflow. 

    This is provided just in case you don't have an implementation 
    so the code above will actually compile and run. 
*/ 
size_t strlcpy(char* dest, char const* src, size_t dest_size) 
{ 
    size_t len = strlen(src); 

    if (dest_size == 0) { 
     // nothing to copy - just return how long the buffer should be 
     // (note that the return value doens't include the null terminator) 
     return len; 
    } 

    size_t tocopy = (dest_size <= len) ? dest_size-1 : len; 

    memmove(dest, src, tocopy); 
    dest[tocopy] = 0; 

    return len; 
} 

Answer 2

也許不是最好的算法，但這裏的一個實例（標準C）：

char* formatLong(long toBeFormatted) 
{ 
    // Get the string representation as is 
    char* buffer = (char*) malloc(sizeof(long)); 
    ltoa(toBeFormatted, buffer, 10); 

    // Calculate how much commas there will be 
    unsigned int buff_length = strlen(buffer); 
    unsigned int num_commas = buff_length/3; 
    unsigned int digits_left = buff_length % 3; 
    if (digits_left == 0) 
    { 
     num_commas--; 
    } 

    // Allocate space for final string representation 
    unsigned int final_length = buff_length + num_commas + 1; 
    char* final = (char*) malloc(final_length); 
    memset(final, 0, final_length); 

    // Parse strings from last to first to count positions 
    int final_pos = final_length - 2; 
    int buff_pos = buff_length - 1; 
    int i = 0; 
    while(final_pos >= 0) 
    { 
     final[final_pos--] = buffer[buff_pos--]; 
     i++; 
     if (i % 3 == 0) 
     { 
      final[final_pos--] = ','; 
     } 
    } 

    // Free obsolete memory and return buffer 
    free(buffer); 
    return final; 
} 

Answer 3

你可以嘗試以下方法：

std::string formatLong(long l) { 
    int power = 0; 
    while (l/(pow(1000, power)) { power += 1; } 

    power -= 1; 

    std::stringstream s; 
    while (power) { 
     s << l/pow(1000, power); 
     s << ","; 
     l % (pow(1000, power)); 
     power -= 1; 
    } 
    return s->str(); 
} 

的代碼是從臀部射擊，但這個想法應該起作用。