Do you know that? Research your client’s target audience before designing. next

How can I right-justify a string?

Even though the C language does not provide a standard function that right-justifies a string, you can easily
build your own function to perform this action. Using the rtrim() function, you can create your own function to take a string and right-justify it. Here is how this task is accomplished:

#include <stdio.h>
#include <string.h>
#include <malloc.h>
void main(void);
char* rjust(char*);
char* rtrim(char*);
void main(void)
{
     char* rjust_str = "This string is not right-justified.                  ";
     /* Show the status of the string before calling the rjust()
        function. */
     printf("Before calling rjust(), rjust_str is '%s'\n.", rjust_str);
     /* Call the rjust() function to right-justify this string. */
     rjust(rjust_str);
     /* Show the status of the string
        after calling the rjust() function. */
     printf("After calling rjust(), rjust_str is '%s'\n.", rjust_str);
}
/* The rjust() function right-justifies a string. */
char* rjust(char* str)
{
     int n = strlen(str);   /* Save the original length of the string. */
     char* dup_str;
     dup_str = strdup(str);  /* Make an exact duplicate of the string. */
     rtrim(dup_str);         /* Trim off the trailing spaces. */
     /* Call sprintf() to do a virtual "printf" back into the original
        string. By passing sprintf() the length of the original string,
        we force the output to be the same size as the original, and by
        default the sprintf() right-justifies the output. The sprintf()
        function fills the beginning of the string with spaces to make
        it the same size as the original string. */
     sprintf(str, "%*.*s", n, n, dup_str);
     free(dup_str);    /* Free the memory taken by
                          the duplicated string. */
     return str;       /* Return a pointer to the string. */
}
/* The rtrim() function removes trailing spaces from a string. */
char* rtrim(char* str)
{
     int n = strlen(str) - 1;  /* Start at the character BEFORE the null
                                  character (\0). */
     while (n>0)            /* Make sure we don't go out of bounds... */
     {
          if (*(str+n) != ' ')    /* If we find a nonspace character: */
          {
               *(str+n+1) = '\0'; /* Put the null character at one
                                     character past our current
                                     position. */
               break;             /* Break out of the loop. */
          }
          else      /* Otherwise, keep moving backward in the string. */
               n--;
     }
     return str;                   /* Return a pointer to the string. */
}

The rjust() function first saves the length of the original string in a variable named n. This step is needed
because the output string must be the same length as the input string. Next, the rjust() function calls the
standard C library function named strdup() to create a duplicate of the original string. A duplicate of the
string is required because the original version of the string is going to be overwritten with a right-justified
version. After the duplicate string is created, a call to the rtrim() function is invoked (using the duplicate
string, not the original), which eliminates all trailing spaces from the duplicate string.

Next, the standard C library function sprintf() is called to rewrite the new string to its original place in
memory. The sprintf() function is passed the original length of the string (stored in n), thereby forcing the
output string to be the same length as the original. Because sprintf() by default right-justifies string output, the output string is filled with leading spaces to make it the same size as the original string. This has the effect of right-justifying the input string. Finally, because the strdup() function dynamically allocates memory, the free() function is called to free up the memory taken by the duplicate string.