C'è qualche setfill () alternativa per il C?

Question

In C ++:

int main()
{
    cout << setfill('#') << setw(10) << 5 << endl;

    return 0;
}

Uscite:

#########5

C'è qualche alternativa setfill() per C? O il modo di fare questo in C senza creare manualmente la stringa?

Answer 1

No, non c'è alternativa diretta.

Ma se si dispone di un snprintf ben educati (uno che si comporta come descritto dal C99 standard), questo funziona senza creare una nuova stringa; la creazione di soli 2 ints temporanei

#include <stdio.h>

int main(void) {
  int filler = '#'; /* setfill('#') */
  int width = 10;   /* setw(10)     */
  int target = 5;   /* 5            */

  /* ******** */
  int s = snprintf(NULL, 0, "%d", target);
  for (int i = 0; i < width - s; i++) {
    putchar(filler);
  }
  printf("%d\n", target);
  /* ******** */

  return 0;
}

---

EDIT:. In esecuzione la versione a Ideone

---

EDIT2: Differenze tra snprintf del C99 standard e Windows _snprintf ( grazie per il link, Ben ):

• prototipo: int snprintf(char *restrict buffer, size_t n, const char *restrict format, ...);
• prototipo: int _snprintf(char *buffer, size_t n, const char *format, ...);
• snprintf non più scrive di (n-1) byte e un NUL
• _snprintf non più scrive che (n) byte, l'ultimo dei quali può essere NUL o un altro carattere
• snprintf restituisce il numero di caratteri necessari per il formato (può essere più grande di n) o -1 in caso di errore di codifica
• _snprintf restituisce un valore negativo se n non è grande per la stringa; o n se un byte NUL non è stato scritto al buffer.

È possibile eseguire il _snprintf mis-comportandosi in un ciclo, aumentando n fino a trovare il giusto valore

/* absolutely not tested, written directly on SO text editor */
int i;
size_t rightvalue = 0;
char buffer[SOME_DEFAULT_VALUE];
do {
    if (sizeof buffer < rightvalue) /* OOPS, BIG BIG OOPS */;
    i = _snprintf(buffer, rightvalue, "%d", 42);
} while (i != rightvalue++);
/* rightvalue already has space for the terminating NUL */

Answer 2

 int x= 5; 
 printf("%010d",x);

uscita volontà:      0000000005

Ora, se si vuole veramente '#' invece di '0' dovrete sostituirli manualmente nella stringa.

Forse:

char buf[11], *sp = buf; 
snprintf(buf, 11, "%10d", x); 
while( (sp = strchr(sp, ' ')) != '\0'){ *sp = '#'; }
puts(buf); 

Answer 3

Tutti vogliono chiamare printf due volte ... printf è una delle funzioni più costosi intorno.

Qui:

char buffer[18] = "##########";
puts(buffer + snprintf(buffer+strlen(buffer), 8, "%d", 5));

Answer 4

Non integrato di serie

Io probabilmente sprintf () il numero in una stringa e ottenere il conteggio dei caratteri, allora l'uscita del numero corretto di '#' prima di stampare la stringa.

Answer 5

Quanto segue farà utilizzando memset in C ipotizzando un char 1 byte. Si crea ancora un 'stringa', anche se non sono sicuro di come manuale non si vuole che sia.

int main(void)
{

   char buf[MAX_LENGTH];

   memset(buf, '#', 10);
   buf[10]='\0';
   printf("%s5\n", buf);
}

A seconda che cosa si vuole fare in realtà con esso, è possibile creare in modo dinamico il buffer di essere la dimensione appropriata e restituirlo a partire una funzione di supporto, se lo desiderano.