En este post te mostraré cómo agregar relleno o padding izquierdo y derecho a la función printf (de C principalmente).

De este modo podremos tener relleno de cadenas o números, así como alineación que permitirá darle una mejor presentación al texto impreso, por ejemplo, al imprimir una tabla o datos con distinta longitud.

El problema de la alineación

Veamos un ejemplo. Supongamos que queremos imprimir algunos números en una tabla, y que queden alineados. Normalmente lo haríamos así:

for(int x = 0; x < 300; x+=9){
    printf("|%d|\n", x);
}

Lo único que hacemos es imprimir el número encerrado en dos barras |, debido a que el número de dígitos cambiará, la alineación no será correcta, provocando que se vea así:

|0|
|9|
|18|
|27|
|36|
|45|
|54|
|63|
|72|
|81|
|90|
|99|
|108|
|117|
|126|
|135|
|144|
|153|
|162|
|171|
|180|
|189|
|198|
|207|
|216|
|225|
|234|
|243|
|252|
|261|
|270|
|279|
|288|
|297|

Lo correcto sería dejar un relleno para los números que no tienen los 3 dígitos, de modo que queden alineados y justificados.

Agregando relleno

Para esto, podemos especificar el padding o relleno entre % y d para el caso de números. Normalmente usamos:

printf("%d", numero);

Pero podemos indicarle que agregue un relleno así:

printf("%[RELLENO]d", numero);

Por ejemplo, darle un relleno de 10 y quedaría así:

for (int x = 0; x < 300; x += 9) {
  printf("|%10d|\n", x);
}

Con la siguiente salida:

|         0|
|         9|
|        18|
|        27|
|        36|
|        45|
|        54|
|        63|
|        72|
|        81|
|        90|
|        99|
|       108|
|       117|
|       126|
|       135|
|       144|
|       153|
|       162|
|       171|
|       180|
|       189|
|       198|
|       207|
|       216|
|       225|
|       234|
|       243|
|       252|
|       261|
|       270|
|       279|
|       288|
|       297|

De este modo todos los elementos estarán alineados, sin cambiar el ancho, pues el ancho será fijo. En este caso lo hicimos con 10 pero la longitud fija puede ser mayor o menor.

Alineando a la izquierda

Con el especificador anterior podemos igualmente agregar el relleno a la derecha, logrando que los elementos se alineen a la izquierda.

Para ello, el relleno debe ser negativo. Por ejemplo podría ser -10:

for (int x = 0; x < 300; x += 9) {
  printf("|%-10d|\n", x);
}

Y de este modo la longitud igual será fija, rellenando el espacio necesario:

|0         |
|9         |
|18        |
|27        |
|36        |
|45        |
|54        |
|63        |
|72        |
|81        |
|90        |
|99        |
|108       |
|117       |
|126       |
|135       |
|144       |
|153       |
|162       |
|171       |
|180       |
|189       |
|198       |
|207       |
|216       |
|225       |
|234       |
|243       |
|252       |
|261       |
|270       |
|279       |
|288       |
|297       |

Ahora los elementos son alineados a la izquierda.

Especificando relleno con variable

No siempre vamos a querer especificar el relleno directamente en el formato; ya que puede ser definido en tiempo de ejecución.

Por ejemplo, podríamos necesitar imprimir una tabla dinámica de datos y entonces la máxima longitud vendría dada por la máxima longitud de la cadena.

En fin, para especificar usamos el formato %*d en donde el asterisco tomará el número (ya sea positivo o negativo) de relleno.

Al invocar a printf con el formato anterior, debemos indicar en primer lugar el número de relleno (longitud fija) y después el dato en sí. Así:

int longitudFija = 5;
for (int x = 0; x < 300; x += 9) {
  // Primero la longitud, luego el valor
  printf("|%*d|\n", longitudFija, x);
}

Nota: recuerda que usamos las barras | para mostrar en dónde inicia y termina la cadena. Obviamente esto no es necesario, solo es para mostrar el delimitador.

La salida sería:

|    0|
|    9|
|   18|
|   27|
|   36|
|   45|
|   54|
|   63|
|   72|
|   81|
|   90|
|   99|
|  108|
|  117|
|  126|
|  135|
|  144|
|  153|
|  162|
|  171|
|  180|
|  189|
|  198|
|  207|
|  216|
|  225|
|  234|
|  243|
|  252|
|  261|
|  270|
|  279|
|  288|
|  297|

Ahora especificamos una longitud de 5 y los elementos se alinean a la derecha, lo interesante es que el ancho es especificado por una variable. Recuerda que esta variable igualmente podría ser negativa para alinear los elementos a la izquierda.

Alineando cadenas

Obviamente podemos alinear cadenas al igual que números. Vamos a mostrar un ejemplo. Definimos un arreglo de cadenas que tendrá varios nombres y los imprimimos:

#define MAXIMA_LONGITUD 50

// Un arreglo de cadenas. Más:
// https://parzibyte.me/blog/2018/11/08/arreglos-de-cadenas-en-c/
char nombres[][MAXIMA_LONGITUD] = {"Bill",
                                   "Luis",
                                   "Pedro",
                                   "Francisco",
                                   "Richard",
                                   "Steve",
                                   "Leon Scott Kennedy",
                                   "Claire Redfield"};
int longitud = sizeof(nombres) / sizeof(nombres[0]);
printf("Nombres alineados a la derecha:\n\n");
for (int x = 0; x < longitud; x++) {
  printf("|%20s|\n", nombres[x]);
}

Igualmente indicamos el ancho fijo, pero ahora en lugar de %d es %s pues estamos imprimiendo una cadena. Todo funcionará perfectamente:

Nombres alineados a la derecha:

|                Bill|
|                Luis|
|               Pedro|
|           Francisco|
|             Richard|
|               Steve|
|  Leon Scott Kennedy|
|     Claire Redfield|

Del mismo modo podemos justificar a la izquierda:

printf("Nombres alineados a la derecha:\n\n");
for (int x = 0; x < longitud; x++) {
  printf("|%-20s|\n", nombres[x]);
}

Y también podemos especificar la longitud con una variable. En este caso mostraré cómo hacerlo con un número negativo.

int longitud = sizeof(nombres) / sizeof(nombres[0]);
int longitudFija = -25;
printf("Nombres alineados con variable\n\n");
for (int x = 0; x < longitud; x++) {
  printf("|%*s|\n", longitudFija, nombres[x]);
}

La salida es:

Nombres alineados con variable

|Bill                     |
|Luis                     |
|Pedro                    |
|Francisco                |
|Richard                  |
|Steve                    |
|Leon Scott Kennedy       |
|Claire Redfield          |

Ejemplo final: tabla de nombres con promedio de calificaciones

Para terminar este ejemplo veamos cómo imprimir una tabla que indica por un lado el nombre del estudiante y por otro lado su promedio, todo esto alineado correctamente:

/*

    https://parzibyte.me/blog

*/#include <stdio.h>

#define MAXIMA_LONGITUD 50

int main() {
  // Un arreglo de cadenas. Más:
  // https://parzibyte.me/blog/2018/11/08/arreglos-de-cadenas-en-c/
  char nombres[][MAXIMA_LONGITUD] = {"Bill",
                                     "Luis",
                                     "Pedro",
                                     "Francisco",
                                     "Richard",
                                     "Steve",
                                     "Leon Scott Kennedy",
                                     "Claire Redfield"};
  float promedios[] = {95.1,  99.99998, 41.25, 47.65,
                       80.25, 70.21,    98.21, 90.33};

  // Nota: se supone que promedios y nombres tienen la misma longitud
  int longitud = sizeof(nombres) / sizeof(nombres[0]);
  int anchoColumnaNombres = -20;
  int anchoColumnaPromedio = -15;

  // Un encabezado
  printf("+--------------------+---------------+\n");
  printf("|%*s|%*s|\n", anchoColumnaNombres, " Nombre", anchoColumnaPromedio,
         " Promedio");
  printf("+--------------------+---------------+\n");

  for (int x = 0; x < longitud; x++) {
    printf("|%*s|%*f|\n", anchoColumnaNombres, nombres[x], anchoColumnaPromedio,
           promedios[x]);
  }

  printf("+--------------------+---------------+\n");
}

La salida es:

En este caso solo el encabezado fue hecho “a mano” pero los datos de la tabla fueron alineados con printf especificando el ancho en variables.

Conclusión

En este caso usamos printf en C, pero esta función también existe en PHP y es compatible con C++. Además, me parece que existe en otros lenguajes de programación.

Te dejo una lectura adicional.