The strcpy() function is designed to work exclusively with strings. It copies each byte of the source string to the destination string and stops when the terminating null character (\0) has been moved. On the other hand, the memcpy() function is designed to work with any type of data.
Because not all data ends with a null character, you must provide the memcpy() function with the number of bytes you want to copy from the source to the destination. The following program shows examples of both thestrcpy() and the memcpy() functions:
#include
#include
typedef struct cust_str {
int id;
char last_name[20];
char first_name[15];
} CUSTREC;
void main(void);
void main(void)
{
char* src_string = "This is the source string";
char dest_string[50];
CUSTREC src_cust;
CUSTREC dest_cust;
printf("Hello! I'm going to copy src_string into dest_string!\n");
/* Copy src_string into dest_string. Notice that the destination
string is the first argument. Notice also that the strcpy()
function returns a pointer to the destination string. */
printf("Done! dest_string is: %s\n",
strcpy(dest_string, src_string));
printf("Encore! Let's copy one CUSTREC to another.\n");
printf("I'll copy src_cust into dest_cust.\n");
/* First, initialize the src_cust data members. */
src_cust.id = 1;
strcpy(src_cust.last_name, "Strahan");
strcpy(src_cust.first_name, "Troy");
/* Now, use the memcpy() function to copy the src_cust structure to
the dest_cust structure. Notice that, just as with strcpy(), the
destination comes first. */
memcpy(&dest_cust, &src_cust, sizeof(CUSTREC));
printf("Done! I just copied customer number #%d (%s %s).",
dest_cust.id, dest_cust.first_name, dest_cust.last_name);
}
When dealing with strings, you generally should use the strcpy() function, because it is easier to use with strings. When dealing with abstract data other than strings (such as structures), you should use the memcpy()function.

The C language does not provide a standard function that removes trailing spaces from a string. It is easy, however, to build your own function to do just this. The following program uses a custom function namedrtrim() to remove the trailing spaces from a string. It carries out this action by iterating through the string backward, starting at the character before the terminating null character (\0) and ending when it finds the first nonspace character. When the program finds a nonspace character, it sets the next character in the string to the terminating null character (\0), thereby effectively eliminating all the trailing blanks. Here is how this task is performed:
#include
#include
void main(void);
char* rtrim(char*);
void main(void)
{
char* trail_str = "This string has trailing spaces in it. ";
/* Show the status of the string before calling the rtrim()
function. */
printf("Before calling rtrim(), trail_str is '%s'\n", trail_str);
printf("and has a length of %d.\n", strlen(trail_str));
/* Call the rtrim() function to remove the trailing blanks. */
rtrim(trail_str);
/* Show the status of the string
after calling the rtrim() function. */
printf("After calling rtrim(), trail_str is '%s'\n", trail_str);
printf("and has a length of %d.\n", strlen(trail_str));
}
/* 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. */
}
Notice that the rtrim() function works because in C, strings are terminated by the null character. With the insertion of a null character after the last nonspace character, the string is considered terminated at that point, and all characters beyond the null character are ignored.

The C language does not provide a standard function that removes leading spaces from a string. It is easy, however, to build your own function to do just this. you can easily construct a custom function that uses thertrim() function in conjunction with the standard C library function strrev() to remove the leading spaces from a string. Look at how this task is performed:
#include
#include
void main(void);
char* ltrim(char*);
char* rtrim(char*);
void main(void)
{
char* lead_str = " This string has leading spaces in it.";
/* Show the status of the string before calling the ltrim()
function. */
printf("Before calling ltrim(), lead_str is '%s'\n", lead_str);
printf("and has a length of %d.\n", strlen(lead_str));
/* Call the ltrim() function to remove the leading blanks. */
ltrim(lead_str);
/* Show the status of the string
after calling the ltrim() function. */
printf("After calling ltrim(), lead_str is '%s'\n", lead_str);
printf("and has a length of %d.\n", strlen(lead_str));
}
/* The ltrim() function removes leading spaces from a string. */
char* ltrim(char* str)
{
strrev(str); /* Call strrev() to reverse the string. */
rtrim(str); /* Call rtrim() to remove the "trailing" spaces. */
strrev(str); /* Restore the string's original order. */
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. */
}
Notice that the ltrim() function performs the following tasks: First, it calls the standard C library functionstrrev(), which reverses the string that is passed to it. This action puts the original string in reverse order, thereby creating "trailing spaces" rather than leading spaces. Now, the rtrim() function is used to remove the "trailing spaces" from the string. After this task is done, the strrev() function is called again to "reverse" the string, thereby putting it back in its original order.

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
#include
#include
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, thefree() function is called to free up the memory taken by the duplicate string.

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
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