C庫提供了多個處理字符串的函數，ANSI-C把這些函數的原型放在string.h頭文件中。其中最常用的函數有strlen()、strcat()、strcmp()、strncmp()、strcpy()和strncpy()。另外，還有sprintf()函數，其原型在stdio.h頭文件中。
1 strlen()函數
strlen()函數用于統計字符串的長度。下面的函數可以縮短字符串的長度，其中用到了strlen()：
void fit(char *string, unsigned int size)
{
if (strlen(string) > size)
string[size] = '0';
}
該函數要改變字符串，所以函數頭在聲明形式參數string時沒有使用const限定符。程序test_fit.c中的程序測試了fit()函數。注意代碼中使用了C字符串常量的串聯特性。
/* test_fit.c -- try the string-shrinking function */
#include <stdio.h>
#include <string.h> /* contains string function prototypes */
void fit(char *, unsigned int);
int main(void)
{
char mesg[] = "Things should be as simple as possible,"
" but not simpler.";
puts(mesg);
fit(mesg,38);
puts(mesg);
puts("Let's look at some more of the string.");
puts(mesg + 39);
return 0;
}
void fit(char *string, unsigned int size)
{
if (strlen(string) > size)
string[size] = '0';
}
下面是該程序的輸出：
Things should be as simple as possible, but not simpler.
Things should be as simple as possible
Let's look at some more of the string.
but not simpler.
fit()函數把第39個元素的逗號替換成''字符。puts()函數在空字符處停止輸出，并忽略其余字符。然而，這些字符還在緩沖區中，下面的函數調用把這些字符打印了出來：
puts(mesg + 39);
表達式mesg + 39是mesg[39]的地址，該地址上存儲的是空格字符。所以puts()顯示該字符并繼續輸出直至遇到原來字符串中的空字符。下圖演示了這一過程。
The puts() function and the null character.
注意
一些ANSI之前的系統使用strings.h頭文件，而有些系統可能根本沒有字符串頭文件。
string.h頭文件中包含了C字符串函數系列的原型，因此程序test_fit.c要包含該頭文件。
2 strcat()函數
strcat()（用于拼接字符串）函數接受兩個字符串作為參數。該函數把第2個字符串的備份附加在第1個字符串末尾，并把拼接后形成的新字符串作為第1個字符串，第2個字符串不變。strcat()函數的類型是char *（即，指向char的指針）。strcat()函數返回第1個參數，即拼接第2個字符串后的第1個字符串的地址。
程序str_cat.c演示了strcat()的用法。該程序還使用了程序清單11.10的s_gets()函數。回憶一下，該函數使用fgets()讀取一整行，如果有換行符，將其替換成空字符。
/* str_cat.c -- joins two strings */
#include <stdio.h>
#include <string.h> /* declares the strcat() function */
#define SIZE 80
char * s_gets(char * st, int n);
int main(void)
{
char flower[SIZE];
char addon[] = "s smell like old shoes.";
puts("What is your favorite flower?");
if (s_gets(flower, SIZE))
{
strcat(flower, addon);
puts(flower);
puts(addon);
}
else
puts("End of file encountered!");
puts("bye");
return 0;
}
char * s_gets(char * st, int n)
{
char * ret_val;
int i = 0;
ret_val = fgets(st, n, stdin);
if (ret_val)
{
while (st[i] != 'n' && st[i] != '0')
i++;
if (st[i] == 'n')
st[i] = '0';
else // must have words[i] == '0'
while (getchar() != 'n')
continue;
}
return ret_val;
}
該程序的輸出示例如下：
What is your favorite flower?
wonderflower
wonderflowers smell like old shoes.
s smell like old shoes.
bye
從以上輸出可以看出，flower改變了，而addon保持不變。
3 strncat()函數
strcat()函數無法檢查第1個數組是否能容納第2個字符串。如果分配給第1個數組的空間不夠大，多出來的字符溢出到相鄰存儲單元時就會出問題。當然，可以用strlen()查看第1個數組的長度。注意，要給拼接后的字符串長度加1才夠空間存放末尾的空字符。或者，用strncat()，該函數的第3個參數指定了最大添加字符數。例如，strncat(bugs, addon, 13)將把addon字符串的內容附加給bugs，在加到第13個字符或遇到空字符時停止。因此，算上空字符（無論哪種情況都要添加空字符），bugs數組應該足夠大，以容納原始字符串（不包含空字符）、添加原始字符串在后面的13個字符和末尾的空字符。程序join_chk.c 使用這種方法，計算avaiable變量的值，用于表示允許添加的最大字符數。
/* join_chk.c -- joins two strings, check size first */
#include <stdio.h>
#include <string.h>
#define SIZE 30
#define BUGSIZE 13
char * s_gets(char * st, int n);
int main(void)
{
char flower[SIZE];
char addon[] = "s smell like old shoes.";
char bug[BUGSIZE];
int available;
puts("What is your favorite flower?");
s_gets(flower, SIZE);
if ((strlen(addon) + strlen(flower) + 1) <= SIZE)
strcat(flower, addon);
puts(flower);
puts("What is your favorite bug?");
s_gets(bug, BUGSIZE);
available = BUGSIZE - strlen(bug) - 1;
strncat(bug, addon, available);
puts(bug);
return 0;
}
char * s_gets(char * st, int n)
{
char * ret_val;
int i = 0;
ret_val = fgets(st, n, stdin);
if (ret_val)
{
while (st[i] != 'n' && st[i] != '0')
i++;
if (st[i] == 'n')
st[i] = '0';
else // must have words[i] == '0'
while (getchar() != 'n')
continue;
}
return ret_val;
}
下面是該程序的運行示例：
What is your favorite flower?
Rose
Roses smell like old shoes.
What is your favorite bug?
Aphid
Aphids smell
讀者可能已經注意到，strcat()和gets()類似，也會導致緩沖區溢出。為什么C11標準不廢棄strcat()，只留下strncat()？為何對gets()那么殘忍？這也許是因為gets()造成的安全隱患來自于使用該程序的人，而strcat()暴露的問題是那些粗心的程序員造成的。無法控制用戶會進行什么操作，但是，可以控制你的程序做什么。C語言相信程序員，因此程序員有責任確保strcat()的使用安全。
4 strcmp()函數
假設要把用戶的響應與已存儲的字符串作比較，如程序nogo.c所示。
/* nogo.c -- will this work? */
#include <stdio.h>
#define ANSWER "Grant"
#define SIZE 40
char * s_gets(char * st, int n);
int main(void)
{
char try[SIZE];
puts("Who is buried in Grant's tomb?");
s_gets(try, SIZE);
while (try != ANSWER)
{
puts("No, that's wrong. Try again.");
s_gets(try, SIZE);
}
puts("That's right!");
return 0;
}
char * s_gets(char * st, int n)
{
char * ret_val;
int i = 0;
ret_val = fgets(st, n, stdin);
if (ret_val)
{
while (st[i] != 'n' && st[i] != '0')
i++;
if (st[i] == 'n')
st[i] = '0';
else // must have words[i] == '0'
while (getchar() != 'n')
continue;
}
return ret_val;
}
這個程序看上去沒問題，但是運行后卻不對勁。ANSWER和try都是指針，所以try !=ANSWER檢查的不是兩個字符串是否相等，而是這兩個字符串的地址是否相同。因為ANSWE和try存儲在不同的位置，所以這兩個地址不可能相同，因此，無論用戶輸入什么，程序都提示輸入不正確。這真讓人沮喪。
該函數要比較的是字符串的內容，不是字符串的地址。讀者可以自己設計一個函數，也可以使用C標準庫中的strcmp()函數（用于字符串比較）。該函數通過比較運算符來比較字符串，就像比較數字一樣。如果兩個字符串參數相同，該函數就返回0，否則返回非零值。修改后的版本如程序compare.c 所示。
/* compare.c -- this will work */
#include <stdio.h>
#include <string.h> // declares strcmp()
#define ANSWER "Grant"
#define SIZE 40
char * s_gets(char * st, int n);
int main(void)
{
char try[SIZE];
puts("Who is buried in Grant's tomb?");
s_gets(try, SIZE);
while (strcmp(try,ANSWER) != 0)
{
puts("No, that's wrong. Try again.");
s_gets(try, SIZE);
}
puts("That's right!");
return 0;
}
char * s_gets(char * st, int n)
{
char * ret_val;
int i = 0;
ret_val = fgets(st, n, stdin);
if (ret_val)
{
while (st[i] != 'n' && st[i] != '0')
i++;
if (st[i] == 'n')
st[i] = '0';
else // must have words[i] == '0'
while (getchar() != 'n')
continue;
}
return ret_val;
}
注意
由于非零值都為“真”，所以許多經驗豐富的C程序員會把該例main()中的while循環頭寫成：while (strcmp(try, ANSWER))
strcmp()函數比較的是字符串，不是整個數組，這是非常好的功能。雖然數組try占用了40字節，而存儲在其中的"Grant"只占用了6字節（還有一個用來放空字符），strcmp()函數只會比較try中第1個空字符前面的部分。所以，可以用strcmp()比較存儲在不同大小數組中的字符串。
如果用戶輸入GRANT、grant或Ulysses S. Grant會怎樣？程序會告知用戶輸入錯誤。希望程序更友好，必須把所有正確答案的可能性包含其中。這里可以使用一些小技巧。例如，可以使用#define定義類似GRANT這樣的答案，并編寫一個函數把輸入的內容都轉換成大寫，就解決了大小寫的問題。但是，還要考慮一些其他錯誤的形式，這些留給讀者完成。
1．strcmp()的返回值
如果strcmp()比較的字符串不同，它會返回什么值？請看程序compback.c的程序示例。
/* compback.c -- strcmp returns */
#include <stdio.h>
#include <string.h>
int main(void)
{
printf("strcmp("A", "A") is ");
printf("%dn", strcmp("A", "A"));
printf("strcmp("A", "B") is ");
printf("%dn", strcmp("A", "B"));
printf("strcmp("B", "A") is ");
printf("%dn", strcmp("B", "A"));
printf("strcmp("C", "A") is ");
printf("%dn", strcmp("C", "A"));
printf("strcmp("Z", "a") is ");
printf("%dn", strcmp("Z", "a"));
printf("strcmp("Apples", "apple") is ");
printf("%dn", strcmp("apples", "apple"));
return 0;
}
在我們的系統中運行該程序，輸出如下：
strcmp("A", "A") is 0
strcmp("A", "B") is -1
strcmp("B", "A") is 1
strcmp("C", "A") is 1
strcmp("Z", "a") is -1
strcmp("apples", "apple") is 1
strcmp()比較"A"和本身，返回0；比較"A"和"B"，返回-1；比較"B"和"A"，返回1。這說明，如果在字母表中第1個字符串位于第2個字符串前面，strcmp()中就返回負數；反之，strcmp()則返回正數。所以，strcmp()比較"C"和"A"，返回1。其他系統可能返回2，即兩者的ASCII碼之差。ASCII標準規定，在字母表中，如果第1個字符串在第2個字符串前面，strcmp()返回一個負數；如果兩個字符串相同，strcmp()返回0；如果第1個字符串在第2個字符串后面，strcmp()返回正數。然而，返回的具體值取決于實現。例如，下面給出在不同實現中的輸出，該實現返回兩個字符的差值：
strcmp("A", "A") is 0
strcmp("A", "B") is -1
strcmp("B", "A") is 1
strcmp("C", "A") is 2
strcmp("Z", "a") is -7
strcmp("apples", "apple") is 115
如果兩個字符串開始的幾個字符都相同會怎樣？一般而言，strcmp()會依次比較每個字符，直到發現第1對不同的字符為止。然后，返回相應的值。例如，在上面的最后一個例子中，"apples"和"apple"只有最后一對字符不同（"apples"的s和"apple"的空字符）。由于空字符在ASCII中排第1。字符s一定在它后面，所以strcmp()返回一個正數。
最后一個例子表明，strcmp()比較所有的字符，不只是字母。所以，與其說該函數按字母順序進行比較，不如說是按機器排序序列（machine collating sequence）進行比較，即根據字符的數值進行比較（通常都使用ASCII值）。在ASCII中，大寫字母在小寫字母前面，所以strcmp("Z", "a")返回的是負值。
大多數情況下，strcmp()返回的具體值并不重要，我們只在意該值是0還是非0（即，比較的兩個字符串是否相等）。或者按字母排序字符串，在這種情況下，需要知道比較的結果是為正、為負還是為0。
--------------
注意
strcmp()函數比較的是字符串，不是字符，所以其參數應該是字符串（如"apples"和"A"），而不是字符（如'A'）。但是，char類型實際上是整數類型，所以可以使用關系運算符來比較字符。假設word是存儲在char類型數組中的字符串，ch是char類型的變量，下面的語句都有效：
if (strcmp(word, "quit") == 0) // use strcmp() for strings
puts("Bye!");
if (ch == 'q') // use == for chars
puts("Bye!");
盡管如此，不要使用ch或'q'作為strcmp()的參數。
--------------
程序quit_chk.c用strcmp()函數檢查程序是否要停止讀取輸入。
/* quit_chk.c -- beginning of some program */
#include <stdio.h>
#include <string.h>
#define SIZE 80
#define LIM 10
#define STOP "quit"
char * s_gets(char * st, int n);
int main(void)
{
char input[LIM][SIZE];
int ct = 0;
printf("Enter up to %d lines (type quit to quit):n", LIM);
while (ct < LIM && s_gets(input[ct], SIZE) != NULL &&
strcmp(input[ct],STOP) != 0)
{
ct++;
}
printf("%d strings enteredn", ct);
return 0;
}
char * s_gets(char * st, int n)
{
char * ret_val;
int i = 0;
ret_val = fgets(st, n, stdin);
if (ret_val)
{
while (st[i] != 'n' && st[i] != '0')
i++;
if (st[i] == 'n')
st[i] = '0';
else // must have words[i] == '0'
while (getchar() != 'n')
continue;
}
return ret_val;
}
該程序在讀到EOF字符（這種情況下s_gets()返回NULL）、用戶輸入quit或輸入項達到LIM時退出。
順帶一提，有時輸入空行（即，只按下Enter鍵或Return鍵）表示結束輸入更方便。為實現這一功能，只需修改一下while循環的條件即可：
while (ct < LIM && s_gets(input[ct], SIZE) != NULL
&& input[ct][0] != '0')
這里，input[ct]是剛輸入的字符串，input[ct][0]是該字符串的第1個字符。如果用戶輸入空行，s_gets()便會把該行第1個字符（換行符）替換成空字符。所以，下面的表達式用于檢測空行：
input[ct][0] != '0'
2．strncmp()函數
strcmp()函數比較字符串中的字符，直到發現不同的字符為止，這一過程可能會持續到字符串的末尾。而strncmp()函數在比較兩個字符串時，可以比較到字符不同的地方，也可以只比較第3個參數指定的字符數。例如，要查找以"astro"開頭的字符串，可以限定函數只查找這5個字符。程序starsrch.c演示了該函數的用法。
/* starsrch.c -- use strncmp() */
#include <stdio.h>
#include <string.h>
#define LISTSIZE 6
int main()
{
const char * list[LISTSIZE] =
{
"astronomy", "astounding",
"astrophysics", "ostracize",
"asterism", "astrophobia"
};
int count = 0;
int i;
for (i = 0; i < LISTSIZE; i++)
if (strncmp(list[i],"astro", 5) == 0)
{
printf("Found: %sn", list[i]);
count++;
}
printf("The list contained %d words beginning"
" with astro.n", count);
下面是該程序的輸出：
Found: astronomy
Found: astrophysics
Found: astrophobia
The list contained 3 words beginning with astro.
5 strcpy()和strncpy()函數
前面提到過，如果pts1和pts2都是指向字符串的指針，那么下面語句拷貝的是字符串的地址而不是字符串本身：
pts2 = pts1;
如果希望拷貝整個字符串，要使用strcpy()函數。程序copy1.c要求用戶輸入以q開頭的單詞。該程序把輸入拷貝至一個臨時數組中，如果第1個字母是q，程序調用strcpy()把整個字符串從臨時數組拷貝至目標數組中。strcpy()函數相當于字符串賦值運算符。
/* copy1.c -- strcpy() demo */
#include <stdio.h>
#include <string.h> // declares strcpy()
#define SIZE 40
#define LIM 5
char * s_gets(char * st, int n);
int main(void)
{
char qwords[LIM][SIZE];
char temp[SIZE];
int i = 0;
printf("Enter %d words beginning with q:n", LIM);
while (i < LIM && s_gets(temp, SIZE))
{
if (temp[0] != 'q')
printf("%s doesn't begin with q!n", temp);
else
{
strcpy(qwords[i], temp);
i++;
}
}
puts("Here are the words accepted:");
for (i = 0; i < LIM; i++)
puts(qwords[i]);
return 0;
}
char * s_gets(char * st, int n)
{
char * ret_val;
int i = 0;
ret_val = fgets(st, n, stdin);
if (ret_val)
{
while (st[i] != 'n' && st[i] != '0')
i++;
if (st[i] == 'n')
st[i] = '0';
else // must have words[i] == '0'
while (getchar() != 'n')
continue;
}
return ret_val;
}
下面是該程序的運行示例：
Enter 5 words beginning with q:
quackery
quasar
quilt
quotient
no more
no more doesn't begin with q!
quiz
Here are the words accepted:
quackery
quasar
quilt
quotient
quiz
注意，只有在輸入以q開頭的單詞后才會遞增計數器i，而且該程序通過比較字符進行判斷：
if (temp[0] != 'q')
這行代碼的意思是：temp中的第1個字符是否是q？當然，也可以通過比較字符串進行判斷：
if (strncmp(temp, "q", 1) != 0)
這行代碼的意思是：temp字符串和"q"的第1個元素是否相等？
請注意，strcpy()第2個參數（temp）指向的字符串被拷貝至第1個參數（qword[i]）指向的數組中。拷貝出來的字符串被稱為目標字符串，最初的字符串被稱為源字符串。參考賦值表達式語句，很容易記住strcpy()參數的順序，即第1個是目標字符串，第2個是源字符串。
char target[20];
int x;
x = 50; /* assignment for numbers */
strcpy(target, "Hi ho!"); /* assignment for strings */
target = "So long"; /* syntax error */
程序員有責任確保目標數組有足夠的空間容納源字符串的副本。下面的代碼有點問題：
char * str;
strcpy(str, "The C of Tranquility"); // a problem
strcpy()把"The C of Tranquility"拷貝至str指向的地址上，但是str未被初始化，所以該字符串可能被拷貝到任意的地方！總之，strcpy()接受兩個字符串指針作為參數，可以把指向源字符串的第2個指針聲明為指針、數組名或字符串常量；而指向源字符串副本的第1個指針應指向一個數據對象（如，數組），且該對象有足夠的空間存儲源字符串的副本。記住，聲明數組將分配存儲數據的空間，而聲明指針只分配存儲一個地址的空間。
strcpy()的更多屬性
strcpy()函數還有兩個有用的屬性。第一，strcpy()的返回類型是char *，該函數返回的是第1個參數的值，即一個字符的地址。第二，第1個參數不必指向數組的開始。這個屬性可用于拷貝數組的一部分。程序清單11.26演示了該函數的這兩個屬性。
/* copy2.c -- strcpy() demo */
#include <stdio.h>
#include <string.h> // declares strcpy()
#define WORDS "beast"
#define SIZE 40
int main(void)
{
const char * orig = WORDS;
char copy[SIZE] = "Be the best that you can be.";
char * ps;
puts(orig);
puts(copy);
ps = strcpy(copy + 7, orig);
puts(copy);
puts(ps);
return 0;
}
下面是該程序的輸出：
beast
Be the best that you can be.
Be the beast
beast
注意，strcpy()把源字符串中的空字符也拷貝在內。在該例中，空字符覆蓋了copy數組中that的第1個t。注意，由于第1個參數是copy + 7，所以ps指向copy中的第8個元素（下標為7）。因此puts(ps)從該處開始打印字符串。
The strcpy() function uses pointers.
更謹慎的選擇：strncpy()
strcpy()和strcat()都有同樣的問題，它們都不能檢查目標空間是否能容納源字符串的副本。拷貝字符串用strncpy()更安全，該函數的第3個參數指明可拷貝的最大字符數。程序copy3.c用strncpy()代替程序copy1.c中的strcpy()。為了演示目標空間裝不下源字符串的副本會發生什么情況，該程序使用了一個相當小的目標字符串（共7個元素，包含6個字符）。
/* copy3.c -- strncpy() demo */
#include <stdio.h>
#include <string.h> /* declares strncpy() */
#define SIZE 40
#define TARGSIZE 7
#define LIM 5
char * s_gets(char * st, int n);
int main(void)
{
char qwords[LIM][TARGSIZE];
char temp[SIZE];
int i = 0;
printf("Enter %d words beginning with q:n", LIM);
while (i < LIM && s_gets(temp, SIZE))
{
if (temp[0] != 'q')
printf("%s doesn't begin with q!n", temp);
else
{
strncpy(qwords[i], temp, TARGSIZE - 1);
qwords[i][TARGSIZE - 1] = '0';
i++;
}
}
puts("Here are the words accepted:");
for (i = 0; i < LIM; i++)
puts(qwords[i]);
return 0;
}
char * s_gets(char * st, int n)
{
char * ret_val;
int i = 0;
ret_val = fgets(st, n, stdin);
if (ret_val)
{
while (st[i] != 'n' && st[i] != '0')
i++;
if (st[i] == 'n')
st[i] = '0';
else // must have words[i] == '0'
while (getchar() != 'n')
continue;
}
return ret_val;
}
下面是該程序的運行示例：
Enter 5 words beginning with q:
quack
quadratic
quisling
quota
quagga
Here are the words accepted:
quack
quadra
quisli
quota
quagga
strncpy(target, source, n)把source中的n個字符或空字符之前的字符（先滿足哪個條件就拷貝到何處）拷貝至target中。因此，如果source中的字符數小于n，則拷貝整個字符串，包括空字符。但是，strncpy()拷貝字符串的長度不會超過n，如果拷貝到第n個字符時還未拷貝完整個源字符串，就不會拷貝空字符。所以，拷貝的副本中不一定有空字符。鑒于此，該程序把n設置為比目標數組大小少1（TARGSIZE-1），然后把數組最后一個元素設置為空字符：
/* compare.c -- this will work */
#include <stdio.h>
#include <string.h> // declares strcmp()
#define ANSWER "Grant"
#define SIZE 40
char * s_gets(char * st, int n);
int main(void)
{
char try[SIZE];
puts("Who is buried in Grant's tomb?");
s_gets(try, SIZE);
while (strcmp(try,ANSWER) != 0)
{
puts("No, that's wrong. Try again.");
s_gets(try, SIZE);
}
puts("That's right!");
return 0;
}
char * s_gets(char * st, int n)
{
char * ret_val;
int i = 0;
ret_val = fgets(st, n, stdin);
if (ret_val)
{
while (st[i] != 'n' && st[i] != '0')
i++;
if (st[i] == 'n')
st[i] = '0';
else // must have words[i] == '0'
while (getchar() != 'n')
continue;
}
return ret_val;
}
這樣做確保存儲的是一個字符串。如果目標空間能容納源字符串的副本，那么從源字符串拷貝的空字符便是該副本的結尾；如果目標空間裝不下副本，則把副本最后一個元素設置為空字符。
6 sprintf()函數
sprintf()函數聲明在stdio.h中，而不是在string.h中。該函數和printf()類似，但是它是把數據寫入字符串，而不是打印在顯示器上。因此，該函數可以把多個元素組合成一個字符串。sprintf()的第1個參數是目標字符串的地址。其余參數和printf()相同，即格式字符串和待寫入項的列表。
程序format.c中的程序用sprintf()把3個項（兩個字符串和一個數字）組合成一個字符串。注意，sprintf()的用法和printf()相同，只不過sprintf()把組合后的字符串存儲在數組formal中而不是顯示在屏幕上。
/* format.c -- format a string */
#include <stdio.h>
#define MAX 20
char * s_gets(char * st, int n);
int main(void)
{
char first[MAX];
char last[MAX];
char formal[2 * MAX + 10];
double prize;
puts("Enter your first name:");
s_gets(first, MAX);
puts("Enter your last name:");
s_gets(last, MAX);
puts("Enter your prize money:");
scanf("%lf", &prize);
sprintf(formal, "%s, %-19s: $%6.2fn", last, first, prize);
puts(formal);
return 0;
}
char * s_gets(char * st, int n)
{
char * ret_val;
int i = 0;
ret_val = fgets(st, n, stdin);
if (ret_val)
{
while (st[i] != 'n' && st[i] != '0')
i++;
if (st[i] == 'n')
st[i] = '0';
else // must have words[i] == '0'
while (getchar() != 'n')
continue;
}
return ret_val;
}
下面是該程序的運行示例：
Enter your first name:
Annie
Enter your last name:
von Wurstkasse
Enter your prize money:
25000
von Wurstkasse, Annie : $25000.00
sprintf()函數獲取輸入，并將其格式化為標準形式，然后把格式化后的字符串存儲在formal中。
7 其他字符串函數
ANSI C庫有20多個用于處理字符串的函數，下面總結了一些常用的函數。
char *strcpy(char * restrict s1, const char * restrict s2);
該函數把s2指向的字符串（包括空字符）拷貝至s1指向的位置，返回值是s1。
char *strncpy(char * restrict s1, const char * restrict s2, size_t n);
該函數把s2指向的字符串拷貝至s1指向的位置，拷貝的字符數不超過n，其返回值是s1。該函數不會拷貝空字符后面的字符，如果源字符串的字符少于n個，目標字符串就以拷貝的空字符結尾；如果源字符串有n個或超過n個字符，就不拷貝空字符。
/* compback.c -- strcmp returns */
#include <stdio.h>
#include <string.h>
int main(void)
{
printf("strcmp("A", "A") is ");
printf("%dn", strcmp("A", "A"));
printf("strcmp("A", "B") is ");
printf("%dn", strcmp("A", "B"));
printf("strcmp("B", "A") is ");
printf("%dn", strcmp("B", "A"));
printf("strcmp("C", "A") is ");
printf("%dn", strcmp("C", "A"));
printf("strcmp("Z", "a") is ");
printf("%dn", strcmp("Z", "a"));
printf("strcmp("apples", "apple") is ");
printf("%dn", strcmp("apples", "apple"));
return 0;
}
該函數把s2指向的字符串拷貝至s1指向的字符串末尾。s2字符串的第1個字符將覆蓋s1字符串末尾的空字符。該函數返回s1。
char *strncat(char * restrict s1, const char * restrict s2, size_t n);
該函數把s2字符串中的n個字符拷貝至s1字符串末尾。s2字符串的第1個字符將覆蓋s1字符串末尾的空字符。不會拷貝s2字符串中空字符和其后的字符，并在拷貝字符的末尾添加一個空字符。該函數返回s1。
int strcmp(const char * s1, const char * s2);
如果s1字符串在機器排序序列中位于s2字符串的后面，該函數返回一個正數；如果兩個字符串相等，則返回0；如果s1字符串在機器排序序列中位于s2字符串的前面，則返回一個負數。
int strncmp(const char * s1, const char * s2, size_t n);
該函數的作用和strcmp()類似，不同的是，該函數在比較n個字符后或遇到第1個空字符時停止比較。
char *strchr(const char * s, int c);
如果s字符串中包含c字符，該函數返回指向s字符串首次出現的c字符的指針（末尾的空字符也是字符串的一部分，所以在查找范圍內）；如果在字符串s中未找到c字符，該函數則返回空指針。
char *strpbrk(const char * s1, const char * s2);
如果s1字符中包含s2字符串中的任意字符，該函數返回指向s1字符串首位置的指針；如果在s1字符串中未找到任何s2字符串中的字符，則返回空字符。
char *strrchr(const char * s, int c);
該函數返回s字符串中c字符的最后一次出現的位置（末尾的空字符也是字符串的一部分，所以在查找范圍內）。如果未找到c字符，則返回空指針。
char *strstr(const char * s1, const char * s2);
該函數返回指向s1字符串中s2字符串出現的首位置。如果在s1中沒有找到s2，則返回空指針。
size_t strlen(const char * s);
該函數返回s字符串中的字符數，不包括末尾的空字符。請注意，那些使用const關鍵字的函數原型表明，函數不會更改字符串。例如，下面的函數原型：
char *strcpy(char * restrict s1, const char * restrict s2);
表明不能更改s2指向的字符串，至少不能在strcpy()函數中更改。但是可以更改s1指向的字符串。這樣做很合理，因為s1是目標字符串，要改變，而s2是源字符串，不能更改。
關鍵字restrict 限制了函數參數的用法。例如，不能把字符串拷貝給本身。
size_t類型是sizeof運算符返回的類型。C規定sizeof運算符返回一個整數類型，但是并未指定是哪種整數類型，所以size_t在一個系統中可以是unsignedint，而在另一個系統中可以是unsigned long。string.h頭文件針對特定系統定義了size_t，或者參考其他有size_t定義的頭文件。
我們來看一下其中一個函數的簡單用法。前面學過的fgets()讀入一行輸入時，在目標字符串的末尾添加換行符。我們自定義的s_gets()函數通過while循環檢測換行符。其實，這里可以用strchr()代替s_gets()。首先，使用strchr()查找換行符（如果有的話）。如果該函數發現了換行符，將返回該換行符的地址，然后便可用空字符替換該位置上的換行符：
char line[80];
char * find;
fgets(line, 80, stdin);
find = strchr(line, 'n'); // look for newline
if (find) // if the address is not NULL,
*find = '0'; // place a null character there
如果strchr()未找到換行符，fgets()在達到行末尾之前就達到了它能讀取的最大字符數。可以像在s_gets()中那樣，給if添加一個else來處理這種情況。
接下來，我們看一個處理字符串的完整程序。
