C Programming - Strings

Padding strings to a fixed length can be handy when you are printing fixed-length data such as tables or spreadsheets. You can easily perform this task using the printf() function. The following example program shows how to accomplish this task:

#include <stdio.h>
char *data[25] = {
     "REGION", "--Q1--",    "--Q2--",   "--Q3--", "  --Q4--",
     "North", "10090.50", "12200.10", "26653.12", "62634.32",
     "South", "21662.37", "95843.23", "23788.23", "48279.28",
     "East", "23889.38", "23789.05", "89432.84", "29874.48",
     "West", "85933.82", "74373.23", "78457.23", "28799.84" };
void main(void);
void main(void)
{
     int x;
     for (x=0; x<25; x++)
     {
          if ((x % 5) == 0 && (x != 0))
               printf("\n");
          printf("%-10.10s", data[x]);
     }
}

In this example, a character array (char* data[]) is filled with this year's sales data for four regions. Of course, you would want to print this data in an orderly fashion, not just print one figure after the other with no formatting. This being the case, the following statement is used to print the data:

printf("%-10.10s", data[x]);

The "%-10.10s" argument tells the printf() function that you are printing a string and you want to force it to be 10 characters long. By default, the string is right-justified, but by including the minus sign (-) before the first 10, you tell the printf() function to left-justify your string. This action forces the printf() function to pad the string with spaces to make it 10 characters long. The result is a clean, formatted spreadsheet-like

output:

REGION      --Q1--   --Q2--     --Q3--    --Q4--
North      10090.50  12200.10  26653.12  62634.32
South      21662.37  95843.23  23788.23  48279.28
East       23889.38  23789.05  89432.84  29874.48
West       85933.82  74373.23  78457.23  28799.84

You can use the standard C library function strncpy() to copy one portion of a string into another string. The strncpy() function takes three arguments: the first argument is the destination string, the second argument is the source string, and the third argument is an integer representing the number of characters you want to copy from the source string to the destination string. For example, consider the following program, which uses the strncpy() function to copy portions of one string to another:

#include <stdio.h>
#include <string.h>
void main(void);
void main(void)
{
     char* source_str = "THIS IS THE SOURCE STRING";
     char dest_str1[40] = {0}, dest_str2[40] = {0};
     /* Use strncpy() to copy only the first 11 characters. */
     strncpy(dest_str1, source_str, 11);
     printf("How about that! dest_str1 is now: '%s'!!!\n", dest_str1);
     /* Now, use strncpy() to copy only the last 13 characters. */
     strncpy(dest_str2, source_str + (strlen(source_str) - 13), 13);
     printf("Whoa! dest_str2 is now: '%s'!!!\n", dest_str2);
}

The first call to strncpy() in this example program copies the first 11 characters of the source string into dest_str1. This example is fairly straightforward, one you might use often. The second call is a bit more complicated and deserves some explanation. In the second argument to the strncpy() function call, the total length of the source_str string is calculated (using the strlen() function). Then, 13 (the number of characters you want to print) is subtracted from the total length of source_str. This gives the number of remaining characters in source_str. This number is then added to the address of source_str to give a pointer to an address in the source string that is 13 characters from the end of source_str.

Then, for the last argument, the number 13 is specified to denote that 13 characters are to be copied out of the string. The combination of these three arguments in the second call to strncpy() sets dest_str2 equal to the last 13 characters of source_str.

The example program prints the following output:

How about that! dest_str1 is now: 'THIS IS THE'!!!
Whoa! dest_str2 is now: 'SOURCE STRING'!!!

Notice that before source_str was copied to dest_str1 and dest_st2, dest_str1 and dest_str2 had to be initialized to null characters (\0). This is because the strncpy() function does not automatically append a null character to the string you are copying to. Therefore, you must ensure that you have put the null character after the string you have copied, or else you might wind up with garbage being printed.

The standard C library provides several functions for converting numbers of all formats (integers, longs, floats, and so on) to strings and vice versa. One of these functions, itoa(), is used here to illustrate how an integer is converted to a string:

#include <stdio.h>
#include <stdlib.h>
void main(void);
void main(void)
{
     int num = 100;
     char str[25];
     itoa(num, str, 10);
     printf("The number 'num' is %d and the string 'str' is %s.\n",
                 num, str);
}

Notice that the itoa() function takes three arguments: the first argument is the number you want to convert to the string, the second is the destination string to put the converted number into, and the third is the base, or radix, to be used when converting the number. The preceding example uses the common base 10 to convert the number to the string.

The following functions can be used to convert integers to strings:

Note that the itoa(), ltoa(), and ultoa() functions are not ANSI compatible. An alternative way to convert an integer to a string (that is ANSI compatible) is to use the sprintf() function, as in the following example:

#include <stdio.h>
#include <stdlib.h>
void main(void);
void main(void)
{
     int num = 100;
     char str[25];
     sprintf(str, "%d", num);
     printf("The number 'num' is %d and the string 'str' is %s.\n",
                 num, str);
}

When floating-point numbers are being converted, a different set of functions must be used. Here is an example of a program that uses the standard C library function fcvt() to convert a floating-point value to a string:

#include <stdio.h>
#include <stdlib.h>
void main(void);
void main(void)
{
     double num = 12345.678;
     char* str;
     int dec_pl, sign, ndigits = 3;    /* Keep 3 digits of precision. */
     str = fcvt(num, ndigits, &dec_pl, &sign);  /* Convert the float
                                                           to a string. */
     printf("Original number:  %f\n", num);     /* Print the original
                                                   floating-point
                                                   value. */
     printf("Converted string: %s\n", str);     /* Print the converted
                                                   string's value */
     printf("Decimal place:    %d\n", dec_pl);  /* Print the location of
                                                   the decimal point. */
     printf("Sign:             %d\n", sign);    /* Print the sign.
                                                   0 = positive,
                                                   1 = negative. */
}

Notice that the fcvt() function is quite different from the itoa() function used previously. The fcvt() function takes four arguments. The first argument is the floating-point value you want to convert. The second argument is the number of digits to be stored to the right of the decimal point. The third argument is a pointer to an integer that is used to return the position of the decimal point in the converted string. The fourth argument is a pointer to an integer that is used to return the sign of the converted number (0 is positive, 1 is negative).

Note that the converted string does not contain the actual decimal point. Instead, the fcvt() returns the position of the decimal point as it would have been if it were in the string. In the preceding example, the dec_pl integer variable contains the number 5 because the decimal point is located after the fifth digit in the resulting string. If you wanted the resulting string to include the decimal point, you could use the gcvt() function (described in the following table).

The following functions can be used to convert floating-point values to strings:

The standard C library provides several functions for converting strings to numbers of all formats (integers, longs, floats, and so on) and vice versa. One of these functions, atoi(), is used here to illustrate how a string is converted to an integer:

#include <stdio.h>
#include <stdlib.h>
void main(void);
{
     int num;
     char* str = "100";
     num = atoi(str);
     printf("The string 'str' is %s and the number 'num' is %d.\n",
                 str, num);
}

To use the atoi() function, you simply pass it the string containing the number you want to convert. The return value from the atoi() function is the converted integer value.

The following functions can be used to convert strings to numbers:

Sometimes, you might want to trap overflow errors that can occur when converting a string to a number that results in an overflow condition. The following program shows an example of the strtoul() function, which traps this overflow condition:

#include <stdio.h>
#include <stdlib.h>
#include <limits.h>
void main(void);
void main(void)
{
     char* str  = "1234567891011121314151617181920";
     unsigned long num;
     char* leftover;
     num = strtoul(str, &leftover, 10);
     printf("Original string:      %s\n", str);
     printf("Converted number:     %lu\n", num);
     printf("Leftover characters:  %s\n", leftover);
}

In this example, the string to be converted is much too large to fit into an unsigned long integer variable. The strtoul() function therefore returns ULONG_MAX (4294967295) and sets the char* leftover to point to the character in the string that caused it to overflow. It also sets the global variable errno to ERANGE to notify the caller of the function that an overflow condition has occurred. The strtod() and strtol() functions work exactly the same way as the strtoul() function shown above. Refer to your C compiler documentation for more information regarding the syntax of these functions.