C string.h 常用函数

参考：http://womendu.iteye.com/blog/1218155

　　　http://blog.csdn.net/zccst/article/details/4294565

还有一些，忘记了！！

 总览：

stpcpy

strncpy

memset

memcpy

memmove

strcat

strncat

strchr

strrchr

strdup

stricmp

strnicmp,strncmpi

strncmpi

strnicmp

strncmp

strcmp

strerror

strnset

strpbrk

strrev

strcspn

strspn

strstr

strtod

strtok

strtol

strupr

swab

常用函数源码

strlen(),计算字符串长度

strcpy(), 字符串拷贝.

strcat(), 字符串的连接.

streql(), 判断两个字符串是否相等.

strchr(), 在字符串中查找某个字符.

chrcnt(), 计算某个字符在字符串中出现的次数.

strcmp(), 判断两个字符串是否相等.

strcmp函数：

strcat函数：

strcpy函数

streql函数

strchr函数

chrcnt函数

strcpy

strcat

strcmp

memset

strlen

malloc

strcat

strncat

=====================================================

stpcpy

功 能: 拷贝一个字符串到另一个

用 法: char *stpcpy(char *destin, char *source);

程序例:

#include <stdio.h>

#include <string.h>

int main(void)

{

char string[10];

char *str1 = "abcdefghi";

stpcpy(string, str1);

printf("%s/n", string);

return 0;

}

strncpy

功 能: 串拷贝

用 法: char *strncpy(char *destin, char *source, int maxlen);

程序例:

#include <stdio.h>

#include <string.h>

int main(void)

{

char string[10];

char *str1 = "abcdefghi";

strncpy(string, str1, 3);

string[3] = '/0';

printf("%s/n", string);

return 0;

}

memset

原型：extern void *memset(void *buffer, int c, int count);

用法：#include <string.h>

功能：把buffer所指内存区域的前count个字节设置成字符c。

说明：返回指向buffer的指针。用来对一段内存空间全部设置为某个字符。

举例：char a[100];memset(a, '/0', sizeof(a));

memset可以方便的清空一个结构类型的变量或数组。

memcpy

原型：extern void *memcpy(void *dest, void *src, unsigned int count);

用法：#include <string.h>

功能：由src所指内存区域复制count个字节到dest所指内存区域。

说明：src和dest所指内存区域不能重叠，函数返回指向dest的指针。可以拿它拷贝任何数据类型的对象。

举例：char a[100],b[50]; memcpy(b, a, sizeof(b));注意如用sizeof(a)，会造成b的内存地址溢出。

函数说明: memcpy()用来拷贝src所指的内存内容前n个字节到dest所指的内存地址上。与strcpy()不同的是,memcpy()会完整的复制n个字节,不会因为遇到字符串结束'/0'而结束

memccpy

表头文件: #include <string.h>

定义函数: void *memccpy(void *dest, const void *src, int c, size_t n);

函数说明: memccpy()用来拷贝src所指的内存内容前n个字节到dest所指的地址上。与memcpy()不同的是,memccpy()如果在src中遇到某个特定值(int c)立即停止复制。

返回值:   返回指向dest中值为c的下一个字节指针。返回值为0表示在src所指内存前n个字节中没有值为c的字节。

memmove

表头文件: #include <string.h>

定义函数: void *memmove(void *dest, const void *src, size_t n);

函数说明:memmove()是从一个缓冲区移动到另一个缓冲区中。

返回值:   返回指向dest指针。

注意：当dest <= src-count 或dest >= src+count时，三个函数(memmove, memccpy, memcpy)均不会产生覆盖问题，即源数据不会被更改。

若不在以上范围内，则源数据会被更改。

strcat

原型：char *strcat(char *dest,char *src);

功能：把src所指字符串添加到dest结尾处(覆盖dest结尾处的'\0')并添加'\0'。

说明：src和dest所指内存区域不可以重叠且dest必须有足够的空间来容纳src的字符串。返回指向dest的指针。

用 法: char *strcat(char *destin, char *source);

程序例:

#include <string.h>

#include <stdio.h>

int main(void)

{

char destination[25];

char *blank = " ", *c = "C++", *Borland = "Borland";

strcpy(destination, Borland);

strcat(destination, blank);

strcat(destination, c);

printf("%s/n", destination);

return 0;

}

strncat

原型：char *strncat(char *dest,char *src,int n);

功能：把src所指字符串的前n个字符添加到dest结尾处(覆盖dest结尾处的'\0')并添加'\0'。

说明：src和dest所指内存区域不可以重叠且dest必须有足够的空间来容纳src的字符串。

返回指向dest的指针。

strchr

功 能: 在一个串中查找给定字符的第一个匹配之处/

用 法: char *strchr(char *str, char c);

程序例:

#include <string.h>

#include <stdio.h>

int main(void)

{

char string[15];

char *ptr, c = 'r';

strcpy(string, "This is a string");

ptr = strchr(string, c);

if (ptr)

printf("The character %c is at position: %d/n", c, ptr-string);

else

printf("The character was not found/n");

return 0;

}

strrchr

功 能: 在串中查找指定字符的最后一个出现

用 法: char *strrchr(char *str, char c);

程序例:

#include <string.h>

#include <stdio.h>

int main(void)

{

char string[15];

char *ptr, c = 'r';

strcpy(string, "This is a string");

ptr = strrchr(string, c);

if (ptr)

printf("The character %c is at position: %d/n", c, ptr-string);

else

printf("The character was not found/n");

return 0;

}

strdup

功 能: 将串拷贝到新建的位置处

用 法: char *strdup(char *str);

程序例:

#include <stdio.h>

#include <string.h>

#include <malloc.h>

int main(void)

{

char *dup_str, *string = "abcde";

dup_str = strdup(string);

printf("%s/n", dup_str);

free(dup_str);

return 0;

}

stricmp

功 能: 以大小写不敏感方式比较两个串

用 法: int stricmp(char *str1, char *str2);

程序例:

#include <string.h>

#include <stdio.h>

int main(void)

{

char *buf1 = "BBB", *buf2 = "bbb";

int ptr;

ptr = stricmp(buf2, buf1);

if (ptr > 0)

printf("buffer 2 is greater than buffer 1/n");

if (ptr < 0)

printf("buffer 2 is less than buffer 1/n");

if (ptr == 0)

printf("buffer 2 equals buffer 1/n");

return 0;

}

strnicmp,strncmpi

原型：int strnicmp(char *s1,char * s2，int n);

功能：比较字符串s1和s2的前n个字符但不区分大小写。

说明：strncmpi是到strnicmp的宏定义

当s1<s2时，返回值<0

当s1=s2时，返回值=0

当s1>s2时，返回值>0

———————————————–

strncmpi

功 能: 将一个串中的一部分与另一个串比较, 不管大小写

用 法: int strncmpi(char *str1, char *str2, unsigned maxlen);

程序例:

#include <string.h>

#include <stdio.h>

int main(void)

{

char *buf1 = "BBB", *buf2 = "bbb";

int ptr;

ptr = strcmpi(buf2, buf1);

if (ptr > 0)

printf("buffer 2 is greater than buffer 1/n");

if (ptr < 0)

printf("buffer 2 is less than buffer 1/n");

if (ptr == 0)

printf("buffer 2 equals buffer 1/n");

return 0;

}

strnicmp

功 能: 不注重大小写地比较两个串

用 法: int strnicmp(char *str1, char *str2, unsigned maxlen);

程序例:

#include <string.h>

#include <stdio.h>

int main(void)

{

char *buf1 = "BBBccc", *buf2 = "bbbccc";

int ptr;

ptr = strnicmp(buf2, buf1, 3);

if (ptr > 0)

printf("buffer 2 is greater than buffer 1/n");

if (ptr < 0)

printf("buffer 2 is less than buffer 1/n");

if (ptr == 0)

printf("buffer 2 equals buffer 1/n");

return 0;

}

strncmp

原型：int strcmp(char *s1,char * s2，int n);

功能：比较字符串s1和s2的前n个字符。

说明：

当s1<s2时，返回值<0

当s1=s2时，返回值=0

当s1>s2时，返回值>0

用 法: int strncmp(char *str1, char *str2, int maxlen);

程序例:

#include <string.h>

#include <stdio.h>

int main(void)

{

char *buf1 = "aaabbb", *buf2 = "bbbccc", *buf3 = "ccc";

int ptr;

ptr = strncmp(buf2,buf1,3);

if (ptr > 0)

printf("buffer 2 is greater than buffer 1/n");

else

printf("buffer 2 is less than buffer 1/n");

ptr = strncmp(buf2,buf3,3);

if (ptr > 0)

printf("buffer 2 is greater than buffer 3/n");

else

printf("buffer 2 is less than buffer 3/n");

return(0);

}

strcmp

原型：int strcmp(char *s1,char * s2);

功能：比较字符串s1和s2。

说明：

当s1<s2时，返回值<0

当s1=s2时，返回值=0

当s1>s2时，返回值>0

举例：

char *s1=”Hello, Programmers!”;

char *s2=”Hello, programmers!”;

r=strcmp(s1,s2); //r小于0, 参见ascii表

———————————————–

stricmp,strcmpi

原型：int stricmp(char *s1,char * s2);

功能：比较字符串s1和s2，但不区分字母的大小写。

说明：strcmpi是到stricmp的宏定义，实际未提供此函数。

当s1<s2时，返回值<0

当s1=s2时，返回值=0

当s1>s2时，返回值>0

strerror

功 能: 返回指向错误信息字符串的指针

用 法: char *strerror(int errnum);

程序例:

#include <stdio.h>

#include <errno.h>

int main(void)

{

char *buffer;

buffer = strerror(errno);

printf("Error: %s/n", buffer);

return 0;

}

strnset

功 能: 将一个串中的前n个字符都设为指定字符ch

用 法: char *strnset(char *str, char ch, unsigned n);

程序例:

#include <stdio.h>

#include <string.h>

int main(void)

{

char s[55] = "abcdefghijklmnopqrstuvwxyz";

char letter = 'x';

printf("s before strnset: %s/n", s);

strnset(s, letter, 13);

printf("s after strnset: %s/n", s);

return 0;

}

strpbrk

用 法: char *strpbrk(char *str1, char *str2);

函数原型：extern char *strpbrk(char *str1, char *str2)

参数说明：str1被搜索的字符串，str2为待比较的字符串。

所在库名：#include <string.h>

函数功能：依次搜索str1中的字符，如果在str2中呀包含，则返回该字符地址，搜索结束，否则返回NUll。

程序例:

#include <stdio.h>

#include <string.h>

int main(void)

{

char *string1 = "abcdefghijklmnopqrstuvwxyz";

char *string2 = "onm";

char *ptr;

ptr = strpbrk(string1, string2);

if (ptr)

printf("strpbrk found first character: %c/n", *ptr);

else

printf("strpbrk didn't find character in set/n");

return 0;

}

strrev

功 能: 串倒转

用 法: char *strrev(char *str);

程序例:

#include <string.h>

#include <stdio.h>

int main(void)

{

char *forward = "string";

printf("Before strrev(): %s/n", forward);

strrev(forward);

printf("After strrev(): %s/n", forward);

return 0;

}

函数名: strset

功 能: 将一个串中的所有字符都设为指定字符

用 法: char *strset(char *str, char c);

程序例:

#include <stdio.h>

#include <string.h>

int main(void)

{

char string[10] = "123456789";

char symbol = 'c';

printf("Before strset(): %s/n", string);

strset(string, symbol);

printf("After strset(): %s/n", string);

return 0;

}

strcspn

头文件：#inclued<string.h>

定义函数：size_t strcspn(const char *s, const char * reject);

函数说明：strcspn()从参数s 字符串的开头计算连续的字符, 而这些字符都完全不在参数reject 所指的字符串中. 简单地说, 若strcspn()返回的数值为n, 则代表字符串s 开头连续有n 个字符都不含字符串reject 内的字符.

返回值：返回字符串s 开头连续不含字符串reject 内的字符数目.

范例

#include <string.h>

main()

{

char *str = "Linux was first developed for 386/486-based pcs. ";

printf("%d\n", strcspn(str, " "));

printf("%d\n", strcspn(str, "/-"));

printf("%d\n", strcspn(str, "1234567890"));

}

执行结果：

5 //只计算到" "的出现, 所以返回"Linux"的长度

33 //计算到出现"/"或"－", 所以返回到"6"的长度

30 // 计算到出现数字字符为止, 所以返回"3"出现前的长度

strspn

表头文件 #include<string.h>

　　定义函数 size_t strspn (const char *s,const char * accept);

　　函数说明 strspn()从参数s 字符串的开头计算连续的字符，而这些字符都完全是accept 所指字符串中的字符。简单的说，若strspn()返回的数值为n，则代表字符串s 开头连续有n 个字符都是属于字符串accept内的字符。

　　返回值 返回字符串s开头连续包含字符串accept内的字符数目。

　　范例

　　1 #include <string.h>

　　2 #include <stdio.h>

　　3 main()

　　4 {

　　5 char *str="Linux was first developed for 386/486-based pcs.";

　　6 printf("%d\n",strspn(str,"Linux"));

　　7 printf("%d\n",strspn(str,"/-"));

　　8 printf("%d\n",strspn(str,"1234567890"));

　　9 }

　　运行结果：

　　5  //包含linux字符切

　　0  // 开始不包含

　　0   //开始不包含

strstr

功 能: 在串中查找指定字符串的第一次出现

用 法: char *strstr(char *str1, char *str2);

程序例:

#include <stdio.h>

#include <string.h>

int main(void)

{

char *str1 = "Borland International", *str2 = "nation", *ptr;

ptr = strstr(str1, str2);

printf("The substring is: %s/n", ptr);

return 0;

}

strtod

功 能: 将字符串转换为double型值

用 法: double strtod(char *str, char **endptr);

程序例:

#include <stdio.h>

#include <stdlib.h>

int main(void)

{

char input[80], *endptr;

double value;

printf("Enter a floating point number:");

gets(input);

value = strtod(input, &endptr);

printf("The string is %s the number is %lf/n", input, value);

return 0;

}

strtok

功 能: 查找由在第二个串中指定的分界符分隔开的单词

用 法: char *strtok(char *str1, char *str2);

程序例:

#include <string.h>

#include <stdio.h>

int main(void)

{

char input[16] = "abc,d";

char *p;

p = strtok(input, ",");

if (p) printf("%s/n", p);

p = strtok(NULL, ",");

if (p) printf("%s/n", p);

return 0;

}

strtol

功 能: 将串转换为长整数

用 法: long strtol(char *str, char **endptr, int base);

程序例:

#include <stdlib.h>

#include <stdio.h>

int main(void)

{

char *string = "87654321", *endptr;

long lnumber;

/* strtol converts string to long integer */

lnumber = strtol(string, &endptr, 10);

printf("string = %s long = %ld/n", string, lnumber);

return 0;

}

strupr

功 能: 将串中的小写字母转换为大写字母

用 法: char *strupr(char *str);

程序例:

#include <stdio.h>

#include <string.h>

int main(void)

{

char *string = "abcdefghijklmnopqrstuvwxyz", *ptr;

/* converts string to upper case characters */

ptr = strupr(string);

printf("%s/n", ptr);

return 0;

}

swab

功 能: 交换字节

用 法: void swab (char *from, char *to, int nbytes);

程序例:

#include <stdlib.h>

#include <stdio.h>

#include <string.h>

char source[15] = "rFna koBlrna d";

char target[15];

int main(void)

{

swab(source, target, strlen(source));

printf("This is target: %s/n", target);

return 0;

}

常用函数源码

很多人认为C语言中的难点是指针,对指针的理解直接关系到所编程序的好坏,所以,

在这里列举了一些C编译器通常都有的标准函数的源代码,看过它们,就能对指针和字符串

有所了解了.

strlen(),计算字符串长度

int strlen(const char string)

{

int i=0;

while(string[i]) i++;

return i;

}

strcpy(), 字符串拷贝.

char *strcpy(char *destination, const char *source)

{

while(*destinaton++=*source++);

return (destination-1);

}

strcat(), 字符串的连接.

char *strcat(char *target,const char *source)

{

char *original=target;

while(*target) target++; // Find the end of the string

while(*target++=*source++);

return(original);

}

streql(), 判断两个字符串是否相等.

int streql(char *str1,char *str2)

{

while((*str1==*str2)&&(*str1))

{

str1++;

str2++;

}

return((*str1==NULL)&&(*str2==NULL));

}

strchr(), 在字符串中查找某个字符.

char *strchr(const char *string,int letter)

{

while((*string!=letter)&(*string))

string++;

return (string);

}

chrcnt(), 计算某个字符在字符串中出现的次数.

int chrcnt(const char *string,int letter)

{

int count=0;

while(*string)

if(*string==letter)count++;

return count;

}

strcmp(), 判断两个字符串是否相等.

int strcmp(const char *str1,const char *str2)

{

while((*str1==*str2)&&(*str1))

{

str1++;

str2++;

}

if((*str1==*str2)&&(!*str1)) //Same strings

return o;

else if((*str1)&&(!*str2)) //Same but str1 longer

return -1;

else if((*str2)&&(!*str1)) //Same but str2 longer

else

return((*str1>*str2)?-1:1);

}

strcmp函数：

int mystrcmp(const char *str1,const char *str2)

{

while((*str1==*str2)&&(*str1))

{

str1++;

str2++;

}

if((*str1==*str2)&&(!*str1)) //Same strings

return 0;

else if((*str1)&&(!*str2)) //Same but str1 longer

return 1;

else if ((!*str1)&&(*str2))

return -1 ;

else

return ((*str1>*str2)?1:-1);

}

strcat函数：

char *mystrcat(char *target,const char *source)

{

char *original=target;

while(*target) target++; // Find the end of the string

while(*target++=*source++);

return(original);

}

int main(void)

{

char destination[25];

char * cc;

char *blank = " ", *c = "C++", *Borland = "Borland";

strcpy(destination, Borland);

mystrcat(destination, blank);

cc=mystrcat(destination, c);

printf("%s/n", cc);

}

strcpy函数

char *mystrcpy(char *destination, const char *source)

{

while(*destination++=*source++);

return (destination);

}

5、strlen函数

int mystrlen(const char *string)

{

int i=0;

while(*string++)

i++;

return i;

}

streql函数

int mystreql(char *str1,char *str2)

{

while((*str1==*str2)&&(*str1))

{

str1++;

str2++;

}

return((*str1==NULL)&&(*str2==NULL));

}

strchr函数

char * mystrchr(const char *string,char letter)

{

while((*string!=letter)&&(*string))

string++;

return (string);

}

int main(void)

{

char string[15];

char *ptr, c = 'r';

strcpy(string, "This is a string");

ptr = mystrchr(string, c);

if (ptr)

printf("The character %c is at position: %d/n", c,ptr-string);

else

printf("The character was not found/n");

return 0;

}

chrcnt函数

int mychrcnt(const char *string,char letter) /*指定计算字符串内的指定字符的个数*/

{

int count=0;

while(*string)

{

if(*string==letter)

count++;

string++;

}

return count;

}

strcpy

　　char *strcpy(char *strDest, const char *strSrc);

　　{

　　assert((strDest!=NULL) && (strSrc !=NULL));

　　char *address = strDest;

　　while( (*strDest++ = * strSrc++) != ‘/0’ )

　　NULL ;

　　return address ;

　　}

strcat

char * strcat(char * dest, const char * src)

{

char *tmp = dest;

while (*dest)

dest++;

while ((*dest++ = *src++) != '/0')

;

return tmp;

}

strcmp

int strcmp(const char *dest, const char *source) ;

返回值：返回整数值，如果dest > source,则返回值大于0，如果dest = source,则返回值等于0，如果dest < source ,则返回值小于0。字符大小是按照字符的字典序列进行排列的。

参数说明：都是以''/0''为结束符的字符串

函数strcmp的实现源代码

int strcmp(const char *dest, const char *source)

{

assert((NULL != dest) && (NULL != source));

while (*dest && *source && (*dest == *source))

{

dest ++;

source ++;

}

return *dest - *source;

/*如果dest > source,则返回值大于0，如果dest = source,则返回值等于0，如果dest < source ,则返回值小于0。*/

}

函数memset的实现源代码

void* memcpy( void* dest, const void* src, size_t count )

{

if (count<0)

{printf("Invalid count number !./n");

return (void*)0;}

if(src==NULL||dest==NULL)

return (void*)0 ;

if ((unsigned int)dest==(unsigned int)src)

{printf("The source is equal with the destanation!./n");

return dest;}

char* d = (char*)dest;

const char* s = (const char*)src;

while(count--)

*d++ = *s++;

return dest;

}

memset

void* memcpy( void* dest, const void* src, size_t count )

{

if (count<0)

{printf("Invalid count number !./n");

return (void*)0;}

if(src==NULL||dest==NULL)

return (void*)0 ;

if ((unsigned int)dest==(unsigned int)src)

{printf("The source is equal with the destanation!./n");

return dest;}

char* d = (char*)dest;

const char* s = (const char*)src;

while(count--)

*d++ = *s++;

return dest;

}

strlen

　　int strlen(const char *str)

　　{

　　assert(str != NULL);

　　int len = 0;

　　while((*str++) != '/0')

　　len++;

　　return len;

　　}

malloc

引用：http://topic.csdn.net/t/20051114/18/4392766.html

#ifndef CRAY

#define STACKMIN 512

#define MINBLK (2*sizeof(struct mem) + 16)

#define F _malloc_free_

#define SBGULP 8192

#include "string.h" /* for memcpy */

#ifdef KR_headers

#define Char char

#define Unsigned unsigned

#define Int /*int*/

#else

#define Char void

#define Unsigned size_t

#define Int int

#endif

typedef struct mem {

struct mem *next;

Unsigned len;

} mem;

mem *F;

Char *

#ifdef KR_headers

malloc(size)

register Unsigned size;

#else

malloc(register Unsigned size)

#endif

{

register mem *p, *q, *r, *s;

unsigned register k, m;

extern Char *sbrk(Int);

char *top, *top1;

size = (size+7) & ~7;

r = (mem *) &F;

for (p = F, q = 0; p; r = p, p = p->next) {

if ((k = p->len) >= size && (!q || m > k)) {

m = k;

q = p;

s = r;

}

}

if (q) {

if (q->len - size >= MINBLK) { /* split block */

p = (mem *) (((char *) (q+1)) + size);

p->next = q->next;

p->len = q->len - size - sizeof(mem);

s->next = p;

q->len = size;

}

else

s->next = q->next;

}

else {

top = (Char *)(((long)sbrk(0) + 7) & ~7);

if (F && (char *)(F+1) + F->len == top) {

q = F;

F = F->next;

}

else

q = (mem *) top;

top1 = (char *)(q+1) + size;

if (sbrk((int)(top1-top+SBGULP)) == (Char *) -1)

return 0;

r = (mem *)top1;

r->len = SBGULP - sizeof(mem);

r->next = F;

F = r;

q->len = size;

}

return (Char *) (q+1);

}

void

#ifdef KR_headers

free(f)

Char *f;

#else

free(Char *f)

#endif

{

mem *p, *q, *r;

char *pn, *qn;

if (!f) return;

q = (mem *) ((char *)f - sizeof(mem));

qn = (char *)f + q->len;

for (p = F, r = (mem *) &F; ; r = p, p = p->next) {

if (qn == (Char *) p) {

q->len += p->len + sizeof(mem);

p = p->next;

}

pn = p ? ((char *) (p+1)) + p->len : 0;

if (pn == (Char *) q) {

p->len += sizeof(mem) + q->len;

q->len = 0;

q->next = p;

r->next = p;

break;

}

if (pn < (char *) q) {

r->next = q;

q->next = p;

break;

}

}

}

Char *

#ifdef KR_headers

realloc(f, size)

Char *f;

Unsigned size;

#else

realloc(Char *f, Unsigned size)

#endif

{

mem *p;

Char *q, *f1;

Unsigned s1;

if (!f) return malloc(size);

p = (mem *) ((char *)f - sizeof(mem));

s1 = p->len;

free(f);

if (s1 > size)

s1 = size + 7 & ~7;

if (!p->len) {

f1 = (Char *)(p->next + 1);

memcpy(f1, f, s1);

f = f1;

}

q = malloc(size);

if (q && q != f)

memcpy(q, f, s1);

return q;

}

/* The following (calloc) should really be in a separate file, */

/* but defining it here sometimes avoids confusion on systems */

/* that do not provide calloc in its own file. */

Char *

#ifdef KR_headers

calloc(n, m) Unsigned m, n;

#else

calloc(Unsigned n, Unsigned m)

#endif

{

Char *rv;

rv = malloc(n *= m);

if (n && rv)

memset(rv, 0, n);

return rv;

}

#endif

**********************************************

http://liusir.name/strcmp-stricmp-strcmpi-strncmp-strnicmp-strncmpi-strcat-strncat.html

strcmp,stricmp,strncmp,strncmpi,strcat,strncat

strcat

原型：char *strcat(char *dest,char *src);

功能：把src所指字符串添加到dest结尾处(覆盖dest结尾处的’\0′)并添加’\0′。

说明：src和dest所指内存区域不可以重叠且dest必须有足够的空间来容纳src的字符串。

返回指向dest的指针。

举例：

char d[20]=”Golden Global”;

char *s=” View”;

strcat(d,s);

———————————————–

strncat

原型：char *strncat(char *dest,char *src,int n);

功能：把src所指字符串的前n个字符添加到dest结尾处(覆盖dest结尾处的’\0′)并添加’\0′。

说明：src和dest所指内存区域不可以重叠且dest必须有足够的空间来容纳src的字符串。

返回指向dest的指针。