发新话题
打印

[转载]C语言编程宝点之XXXX

[转载]C语言编程宝点之XXXX

main()主函数

   每一C 程序都必须有一main()函数, 可以根据自己的爱好把它放在程序的某
个地方。有些程序员把它放在最前面, 而另一些程序员把它放在最后面, 无论放
在哪个地方, 以下几点说明都是适合的。
   1. main() 参数
   在Turbo C2.0启动过程中, 传递main()函数三个参数: argc, argv和env。
    * argc:  整数, 为传给main()的命令行参数个数。
    * argv:  字符串数组。
          在DOS 3.X 版本中, argv[0] 为程序运行的全路径名; 对DOS 3.0
          以下的版本, argv[0]为空串("") 。
          argv[1] 为在DOS命令行中执行程序名后的第一个字符串;
          argv[2] 为执行程序名后的第二个字符串;
          ...
          argv[argc]为NULL。
    *env:  安符串数组。env[] 的每一个元素都包含ENVVAR=value形式的字符
串。其中ENVVAR为环境变量如PATH或87。value 为ENVVAR的对应值如C:\DOS, C:
\TURBOC(对于PATH) 或YES(对于87)。
   Turbo C2.0启动时总是把这三个参数传递给main()函数, 可以在用户程序中
说明(或不说明)它们, 如果说明了部分(或全部)参数, 它们就成为main()子程序
的局部变量。
   请注意: 一旦想说明这些参数, 则必须按argc, argv, env 的顺序, 如以下
的例子:
    main()
    main(int argc)
    main(int argc, char *argv[])
    main(int argc, char *argv[], char *env[])
   其中第二种情况是合法的, 但不常见, 因为在程序中很少有只用argc, 而不
用argv[]的情况。
   以下提供一样例程序EXAMPLE.EXE,  演示如何在main()函数中使用三个参数:
    /*program name EXAMPLE.EXE*/
    #include <stdio.h>
    #include <stdlib.h>
    main(int argc, char *argv[], char *env[])
    {
       int i;
       printf("These are the %d  command- line  arguments passed  to
            main:\n\n", argc);
       for(i=0; i<=argc; i++)
        printf("argv[%d]:%s\n", i, argv);
       printf("\nThe environment string(s)on this system are:\n\n");
       for(i=0; env!=NULL; i++)
          printf(" env[%d]:%s\n", i, env);
    }
   如果在DOS 提示符下, 按以下方式运行EXAMPLE.EXE:
   C:\example first_argument "argument with blanks"  3  4  "last  but
one" stop!
   注意: 可以用双引号括起内含空格的参数, 如本例中的:  "  argument
with blanks"和"Last but one")。
   结果是这样的:
    The value of argc is 7
    These are the 7 command-linearguments passed to main:
    argv[0]:C:\TURBO\EXAMPLE.EXE
    argv[1]:first_argument
    argv[2]:argument with blanks
    argv[3]:3
    argv[4]:4
    argv[5]:last but one
    argv[6]:stop!
    argv[7]:(NULL)
    The environment string(s) on this system are:
    env[0]: COMSPEC=C:\COMMAND.COM
    env[1]: PROMPT=$P$G        /*视具体设置而定*/
    env[2]: PATH=C:\DOS;C:\TC    /*视具体设置而定*/

    应该提醒的是: 传送main() 函数的命令行参数的最大长度为128 个字符 (包
括参数间的空格),  这是由DOS 限制的。


函数名: matherr
功  能: 用户可修改的数学错误处理程序
用  法: int matherr(struct exception *e);
程序例:

/* This is a user-defined matherr function that prevents
  any error messages from being printed. */

#include<math.h>

int matherr(struct exception *a)
{
  return 1;
}




函数名: memccpy
功  能: 从源source中拷贝n个字节到目标destin中
用  法: void *memccpy(void *destin, void *source, unsigned char ch,
     unsigned n);
程序例:

#include <string.h>
#include <stdio.h>

int main(void)
{
  char *src = "This is the source string";
  char dest[50];
  char *ptr;

  ptr = memccpy(dest, src, &#39;c&#39;, strlen(src));

  if (ptr)
  {
    *ptr = &#39;\0&#39;;
    printf("The character was found:  %s\n", dest);
  }
  else
    printf("The character wasn&#39;t found\n");
  return 0;
}



函数名: malloc
功  能: 内存分配函数
用  法: void *malloc(unsigned size);
程序例:

#include <stdio.h>
#include <string.h>
#include <alloc.h>
#include <process.h>

int main(void)
{
  char *str;

  /* allocate memory for string */
  /* This will generate an error when compiling */
  /* with C++, use the new operator instead. */
  if ((str = malloc(10)) == NULL)
  {
    printf("Not enough memory to allocate buffer\n");
    exit(1);  /* terminate program if out of memory */
  }

  /* copy "Hello" into string */
  strcpy(str, "Hello");

  /* display string */
  printf("String is %s\n", str);

  /* free memory */
  free(str);

  return 0;
}




函数名: memchr
功  能: 在数组的前n个字节中搜索字符
用  法: void *memchr(void *s, char ch, unsigned n);
程序例:

#include <string.h>
#include <stdio.h>

int main(void)
{
  char str[17];
  char *ptr;

  strcpy(str, "This is a string");
  ptr = memchr(str, &#39;r&#39;, strlen(str));
  if (ptr)
    printf("The character &#39;r&#39; is at position: %d\n", ptr - str);
  else
    printf("The character was not found\n");
  return 0;
}


函数名: memcpy
功  能: 从源source中拷贝n个字节到目标destin中
用  法: void *memcpy(void *destin, void *source, unsigned n);
程序例:

#include <stdio.h>
#include <string.h>
int main(void)
{
  char src[] = "******************************";
  char dest[] = "abcdefghijlkmnopqrstuvwxyz0123456709";
  char *ptr;
  printf("destination before memcpy: %s\n", dest);
  ptr = memcpy(dest, src, strlen(src));
  if (ptr)
    printf("destination after memcpy:  %s\n", dest);
  else
    printf("memcpy failed\n");
  return 0;
}



函数名: memicmp
功  能: 比较两个串s1和s2的前n个字节, 忽略大小写
用  法: int memicmp(void *s1, void *s2, unsigned n);
程序例:

#include <stdio.h>
#include <string.h>

int main(void)
{
  char *buf1 = "ABCDE123";
  char *buf2 = "abcde456";
  int stat;
  stat = memicmp(buf1, buf2, 5);
  printf("The strings to position 5 are ");
  if (stat)
    printf("not ");
  printf("the same\n");
  return 0;
}



函数名: memmove
功  能: 移动一块字节
用  法: void *memmove(void *destin, void *source, unsigned n);
程序例:

#include <string.h>
#include <stdio.h>

int main(void)
{
  char *dest = "abcdefghijklmnopqrstuvwxyz0123456789";
  char *src = "******************************";
  printf("destination prior to memmove: %s\n", dest);
  memmove(dest, src, 26);
  printf("destination after memmove:   %s\n", dest);
  return 0;
}




函数名: memset
功  能: 设置s中的所有字节为ch, s数组的大小由n给定
用  法: void *memset(void *s, char ch, unsigned n);
程序例:

#include <string.h>
#include <stdio.h>
#include <mem.h>

int main(void)
{
  char buffer[] = "Hello world\n";

  printf("Buffer before memset: %s\n", buffer);
  memset(buffer, &#39;*&#39;, strlen(buffer) - 1);
  printf("Buffer after memset:  %s\n", buffer);
  return 0;
}



函数名: mkdir
功  能: 建立一个目录
用  法: int mkdir(char *pathname);
程序例:

#include <stdio.h>
#include <conio.h>
#include <process.h>
#include <dir.h>

int main(void)
{
  int status;

  clrscr();
  status = mkdir("asdfjklm");
  (!status) ? (printf("Directory created\n")) :
          (printf("Unable to create directory\n"));

  getch();
  system("dir");
  getch();

  status = rmdir("asdfjklm");
  (!status) ? (printf("Directory deleted\n")) :
  (perror("Unable to delete directory"));

  return 0;
}




函数名: mktemp
功  能: 建立唯一的文件名
用  法: char *mktemp(char *template);
程序例:

#include <dir.h>
#include <stdio.h>

int main(void)
{
  /* fname defines the template for the
    temporary file.  */

  char *fname = "TXXXXXX", *ptr;

  ptr = mktemp(fname);
  printf("%s\n",ptr);
  return 0;
}



函数名: MK_FP
功  能: 设置一个远指针
用  法: void far *MK_FP(unsigned seg, unsigned off);
程序例:

#include <dos.h>
#include <graphics.h>

int main(void)
{
  int gd, gm, i;
  unsigned int far *screen;

  detectgraph(&gd, &gm);
  if (gd == HERCMONO)
     screen = MK_FP(0xB000, 0);
  else
     screen = MK_FP(0xB800, 0);
  for (i=0; i<26; i++)
    screen = 0x0700 + (&#39;a&#39; + i);
  return 0;
}



函数名: modf
功  能: 把数分为指数和尾数
用  法: double modf(double value, double *iptr);
程序例:

#include <math.h>
#include <stdio.h>

int main(void)
{
  double fraction, integer;
  double number = 100000.567;

  fraction = modf(number, &integer);
  printf("The whole and fractional parts of %lf are %lf and %lf\n",
       number, integer, fraction);
  return 0;
}



函数名: movedata
功  能: 拷贝字节
用  法: void movedata(int segsrc, int offsrc, int segdest,
  int offdest, unsigned numbytes);
程序例:

#include <mem.h>

#define MONO_BASE 0xB000

/* saves the contents of the monochrome screen in buffer */
void save_mono_screen(char near *buffer)
{
  movedata(MONO_BASE, 0, _DS, (unsigned)buffer, 80*25*2);
}

int main(void)
{
  char buf[80*25*2];
  save_mono_screen(buf);
}



函数名: moverel
功  能: 将当前位置(CP)移动一相对距离
用  法: void far moverel(int dx, int dy);
程序例:

#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>

int main(void)
{
  /* request auto detection */
  int gdriver = DETECT, gmode, errorcode;
  char msg[80];

  /* initialize graphics and local variables */
  initgraph(&gdriver, &gmode, "");

  /* read result of initialization */
  errorcode = graphresult();
  if (errorcode != grOk)  /* an error occurred */
  {
    printf("Graphics error: %s\n", grapherrormsg(errorcode));
    printf("Press any key to halt:");
    getch();
    exit(1); /* terminate with an error code */
  }

  /* move the C.P. to location (20, 30) */
  moveto(20, 30);

  /* plot a pixel at the C.P. */
  putpixel(getx(), gety(), getmaxcolor());

  /* create and output a message at (20, 30) */
  sprintf(msg, " (%d, %d)", getx(), gety());
  outtextxy(20, 30, msg);

  /* move to a point a relative distance */
  /* away from the current value of C.P. */
  moverel(100, 100);

  /* plot a pixel at the C.P. */
  putpixel(getx(), gety(), getmaxcolor());

  /* create and output a message at C.P. */
  sprintf(msg, " (%d, %d)", getx(), gety());
  outtext(msg);

  /* clean up */
  getch();
  closegraph();
  return 0;
}



函数名: movetext
功  能: 将屏幕文本从一个矩形区域拷贝到另一个矩形区域
用  法: int movetext(int left, int top, int right, int bottom,
  int newleft, int newtop);
程序例:
#include <conio.h>
#include <string.h>

int main(void)
{
  char *str = "This is a test string";

  clrscr();
  cputs(str);
  getch();

  movetext(1, 1, strlen(str), 2, 10, 10);
  getch();

  return 0;
}



函数名: moveto
功  能: 将CP移到(x, y)
用  法: void far moveto(int x, int y);
程序例:

#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>

int main(void)
{
  /* request auto detection */
  int gdriver = DETECT, gmode, errorcode;
  char msg[80];

  /* initialize graphics and local variables */
  initgraph(&gdriver, &gmode, "");

  /* read result of initialization */
  errorcode = graphresult();
  if (errorcode != grOk)  /* an error occurred */
  {
    printf("Graphics error: %s\n", grapherrormsg(errorcode));
    printf("Press any key to halt:");
    getch();
    exit(1); /* terminate with an error code */
  }

  /* move the C.P. to location (20, 30) */
  moveto(20, 30);

  /* plot a pixel at the C.P. */
  putpixel(getx(), gety(), getmaxcolor());

  /* create and output a message at (20, 30) */
  sprintf(msg, " (%d, %d)", getx(), gety());
  outtextxy(20, 30, msg);

  /* move to (100, 100) */
  moveto(100, 100);

  /* plot a pixel at the C.P. */
  putpixel(getx(), gety(), getmaxcolor());

  /* create and output a message at C.P. */
  sprintf(msg, " (%d, %d)", getx(), gety());
  outtext(msg);

  /* clean up */
  getch();
  closegraph();
  return 0;
}



函数名: movemem
功  能: 移动一块字节
用  法: void movemem(void *source, void *destin, unsigned len);
程序例:

#include <mem.h>
#include <alloc.h>
#include <stdio.h>
#include <string.h>

int main(void)
{
  char *source = "Borland International";
  char *destination;
  int length;

  length = strlen(source);
  destination = malloc(length + 1);
  movmem(source,destination,length);
  printf("%s\n",destination);

  return 0;
}



函数名: normvideo
功  能: 选择正常亮度字符
用  法: void normvideo(void);
程序例:

#include <conio.h>

int main(void)
{
  normvideo();
  cprintf("NORMAL Intensity Text\r\n");
  return 0;
}



函数名: nosound
功  能: 关闭PC扬声器
用  法: void nosound(void);
程序例:

/* Emits a 7-Hz tone for 10 seconds.

    True story: 7 Hz is the resonant frequency of a chicken&#39;s skull cavity.
    This was determined empirically in Australia, where a new factory
    generating 7-Hz tones was located too close to a chicken ranch:
    When the factory started up, all the chickens died.

    Your PC may not be able to emit a 7-Hz tone.
*/

int main(void)
{
  sound(7);
  delay(10000);
  nosound();
}
垃圾一个,00...

TOP

bcmp(比较内存内容)
相关函数
    bcmp,strcasecmp,strcmp,strcoll,strncmp,strncasecmp
表头文件
    #include<string.h>
定义函数
    int bcmp ( const void *s1,const void * s2,int n);
函数说明
    bcmp()用来比较s1和s2所指的内存区间前n个字节,若参数n为0,则返回0。
返回值
    若参数s1 和s2 所指的内存内容都完全相同则返回0 值,否则返回非零值。
附加说明
    建议使用memcmp()取代。
范例
    参考memcmp()。
 


   
bcopy(拷贝内存内容)
相关函数
    memccpy,memcpy,memmove,strcpy,ctrncpy
表头文件
    #include <string.h>
定义函数
    void bcopy ( const void *src,void *dest ,int n);
函数说明
    bcopy()与memcpy()一样都是用来拷贝src所指的内存内容前n个字节到dest所指的地址,不过参数src与dest在传给函数时是相反的位置。
返回值
   
附加说明
    建议使用memcpy()取代
范例
    #include<string.h>
main()
{
char dest[30]=”string(a)”;
char src[30]=”string\0string”;
int i;
bcopy(src,dest,30);/* src指针放在前*/
printf(bcopy(): “)
for(i=0;i<30;i++)
printf(“%c”,dest);
memcpy(dest src,30); /*dest指针放在钱*/
printf(‘\nmemcpy() : “);
for(i=0;i<30;i++)
printf(“%c”,dest);
执行
    bcopy() : string string
memcpy() :string sring
 


   
bzero(将一段内存内容全清为零)
相关函数
    memset,swab
表头文件
    #include<string.h>
定义函数
    void bzero(void *s,int n);
函数说明
    bzero()会将参数s所指的内存区域前n个字节,全部设为零值。相当于调用memset((void*)s,0,size_tn);
返回值
   
附加说明
    建议使用memset取代
范例
    参考memset()。
 


   
index(查找字符串中第一个出现的指定字符)
相关函数
    rindex,srechr,strrchr
表头文件
    #include<string.h>
定义函数
    char * index( const char *s, int c);
函数说明
    index()用来找出参数s字符串中第一个出现的参数c地址,然后将该字符出现的地址返回。字符串结束字符(NULL)也视为字符串一部分。
返回值
    如果找到指定的字符则返回该字符所在地址,否则返回0。
范例
    #include<string.h>
main()
{
char *s =”0123456789012345678901234567890”;
char *p;
p =index(s,’5’);
printf(%s\n”,p);
}
执行
    5.68E+25
 


   
memccpy(拷贝内存内容)
相关函数
    bcopy,memcpy,memmove,strcpy,strncpy
表头文件
    #include<string.h>
定义函数
    void * memccpy(void *dest, const void * src, int c,size_t n);
函数说明
    memccpy()用来拷贝src所指的内存内容前n个字节到dest所指的地址上。与memcpy()不同的是,memccpy()会在复制时检查参数c是否出现,若是则返回dest中值为c的下一个字节地址。
返回值
    返回指向dest中值为c的下一个字节指针。返回值为0表示在src所指内存前n个字节中没有值为c的字节。
范例
    #include<string.h>
main()
{
char a[]="string[a]";
char b[]="string(b)";
memccpy(a,b,&#39;B&#39;,sizeof(b));
printf("memccpy():%s\n",a);
}
执行
    memccpy():string(b)
 


   
memchr(在某一内存范围中查找一特定字符)
相关函数
    index,rindex,strchr,strpbrk,strrchr,strsep,strspn,strstr
表头文件
    #include<string.h>
定义函数
    void * memchr(const void *s,int c,size_t n);
函数说明
    memchr()从头开始搜寻s所指的内存内容前n个字节,直到发现第一个值为c的字节,则返回指向该字节的指针。
返回值
    如果找到指定的字节则返回该字节的指针,否则返回0。
范例
    #include <string.h>
main()
{
char *s="0123456789012345678901234567890";
char *p;
p=memchr(s,&#39;5&#39;,10);
printf("%s\n",p);
}
执行
    5.68E+25
 


   
memcmp(比较内存内容)
相关函数
    bcmp,strcasecmp,strcmp,strcoll,strncmp,strncasecmp
表头文件
    #include<string.h>
定义函数
    int memcmp (const void *s1,const void *s2,size_t n);
函数说明
    memcmp()用来比较s1和s2所指的内存区间前n个字符。字符串大小的比较是以ASCII码表上的顺序来决定,次顺序亦为字符的值。memcmp ()首先将s1第一个字符值减去s2第一个字符的值,若差为0则再继续比较下个字符,若差值不为0则将差值返回。例如,字符串"Ac"和"ba"比较则会返回字符&#39;A&#39;(65)和&#39;b&#39;(98)的差值(-33)。
返回值
    若参数s1和s2所指的内存内容都完全相同则返回0值。s1若大于s2则返回大于0的值。s1若小于s2则返回小于0的值。
范例
    #include<string.h>
main()
{
char *a ="aBcDeF";
char *b="AbCdEf";
char *c="aacdef";
char *d="aBcDeF";
printf("memcmp(a,b):%d\n",memcmp((void*)a,(void*) b,6));
printf("memcmp(a,c):%d\n",memcmp((void*)a,(void*) c,6));
printf("memcmp(a,d):%d\n",memcmp((void*)a,(void*) d,6));
执行
    memcmp(a,b):1 /*字符串a>字符串b,返回1*/
memcmp(a,c):-1 /* 字符串a<字符串c,返回-1*/
memcmp(a,d):0 /*字符串a=字符串d,返回0*/
 


   
memcpy(拷贝内存内容)
相关函数
    bcopy,memccpy,memcpy,memmove,strcpy,strncpy
表头文件
    #include<string.h>
定义函数
    void * memcpy (void * dest ,const void *src, size_t n);
函数说明
    memcpy()用来拷贝src所指的内存内容前n个字节到dest所指的内存地址上。与strcpy()不同的是,memcpy()会完整的复制n个字节,不会因为遇到字符串结束&#39;\0&#39;而结束。
返回值
    返回指向dest的指针。
附加说明
    指针src和dest所指的内存区域不可重叠。
范例
    #include<string.h>
main()
{
char a[30]="string (a)";
char b[30]="string\0string";
int i;
strcpy(a,b);
printf("strcpy():");
for(i=0;i<30;i++)
printf("%c",a);
memcpy(a,b,30);
printf("\nmemcpy() :");
for(i=0;i<30;i++)
printf("%c",a);
}
执行
    strcpy() : string a )
memcpy() : string string
 


   
memmove(拷贝内存内容)
相关函数
    bcopy,memccpy,memcpy,strcpy,strncpy
表头文件
    #include<string.h>
定义函数
    void * memmove(void *dest,const void *src,size_t n);
函数说明
    memmove()与memcpy()一样都是用来拷贝src所指的内存内容前n个字节到dest所指的地址上。不同的是,当src和dest所指的内存区域重叠时,memmove()仍然可以正确的处理,不过执行效率上会比使用memcpy()略慢些。
返回值
    返回指向dest的指针。
附加说明
    指针src和dest所指的内存区域可以重叠。
范例
    参考memcpy()。
 


   
memset(将一段内存空间填入某值)
相关函数
    bzero,swab
表头文件
    #include<string.h>
定义函数
    void * memset (void *s ,int c, size_t n);
函数说明
    memset()会将参数s所指的内存区域前n个字节以参数c填入,然后返回指向s的指针。在编写程序时,若需要将某一数组作初始化,memset()会相当方便。
返回值
    返回指向s的指针。
附加说明
    参数c虽声明为int, 但必须是unsigned char ,所以范围在0到255之间。
范例
    #include <string.h>
main()
{
char s[30];
memset (s,&#39;A&#39;,sizeof(s));
s[30]=&#39;\0&#39;;
printf("%s\n",s);
}
执行
    AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
 


   
rindex(查找字符串中最后一个出现的指定字符)
相关函数
    index,memchr,strchr,strrchr
表头文件
    #include<string.h>
定义函数
    char * rindex( const char *s,int c);
函数说明
    rindex()用来找出参数s字符串中最后一个出现的参数c地址,然后将该字符出现的地址返回。字符串结束字符(NULL)也视为字符串一部分。
返回值
    如果找到指定的字符则返回该字符所在的地址,否则返回0。
范例
    #include <string.h>
mian()
{
char *s ="0123456789012345678901234567890";
char *p;
p=rindex(s,&#39;5&#39;);
printf("%s\n",p);
}
执行
    567890
 


   
strcasecmp(忽略大小写比较字符串)
相关函数
    bcmp,memcmp,strcmp,strcoll,strncmp
表头文件
    #include<string.h>
定义函数
    int strcasecmp (const char *s1, const char *s2);
函数说明
    strcasecmp()用来比较参数s1和s2字符串,比较时会自动忽略大小写的差异。
返回值
    若参数s1和s2字符串相同则返回0。s1长度大于s2长度则返回大于0 的值,s1 长度若小于s2 长度则返回小于0的值。
范例
    #include <string.h>
main()
{
char *a="aBcDeF";
char *b="AbCdEf";
if(!strcasecmp(a,b))
printf("%s=%s\n",a,b);
}
执行
    aBcDeF=AbCdEf
 


   
strcat(连接两字符串)
相关函数
    bcopy,memccpy,memcpy,strcpy,strncpy
表头文件
    #include <string.h>
定义函数
    char *strcat (char *dest,const char *src);
函数说明
    strcat()会将参数src字符串拷贝到参数dest所指的字符串尾。第一个参数dest要有足够的空间来容纳要拷贝的字符串。
返回值
    返回参数dest的字符串起始地址
范例
    #include <string.h.>
main()
{
char a[30]="string(1)";
char b[]="string(2)";
printf("before strcat() : %s\n",a);
printf("after strcat() : %s\n",strcat(a,b));
}
执行
    before strcat () : string(1)
after strcat () : string(1)string(2)
 


   
strchr(查找字符串中第一个出现的指定字符)
相关函数
    index,memchr,rinex,strbrk,strsep,strspn,strstr,strtok
表头文件
    #include<string.h>
定义函数
    char * strchr (const char *s,int c);
函数说明
    strchr()用来找出参数s字符串中第一个出现的参数c地址,然后将该字符出现的地址返回。
返回值
    如果找到指定的字符则返回该字符所在地址,否则返回0。
范例
    #include<string.h>
main()
{
char *s=0123456789012345678901234567890”;
char *p;
p=strchr(s,&#39;5&#39;);
printf("%s\n",p);
}
执行
    5.68E+25
 


   
strcmp(比较字符串)
相关函数
    bcmp,memcmp,strcasecmp,strncasecmp,strcoll
表头文件
    #include<string.h>
定义函数
    int strcmp(const char *s1,const char *s2);
函数说明
    strcmp()用来比较参数s1和s2字符串。字符串大小的比较是以ASCII 码表上的顺序来决定,此顺序亦为字符的值。strcmp()首先将s1第一个字符值减去s2第一个字符值,若差值为0则再继续比较下个字符,若差值不为0 则将差值返回。例如字符串"Ac"和"ba"比较则会返回字符"A"(65)和&#39;b&#39;(98)的差值(-33)。
返回值
    若参数s1和s2字符串相同则返回0。s1若大于s2则返回大于0的值。s1若小于s2则返回小于0 的值。
范例
    #include<string.h>
main()
{
char *a="aBcDeF";
char *b="AbCdEf";
char *c="aacdef";
char *d="aBcDeF";
printf("strcmp(a,b) : %d\n",strcmp(a,b));
printf("strcmp(a,c) : %d\n",strcmp(a,c));
printf("strcmp(a,d) : %d\n",strcmp(a,d));
}
执行
    strcmp(a,b) : 32
strcmp(a,c) :-31
strcmp(a,d) : 0
 


   
strcoll(采用目前区域的字符排列次序来比较字符串)
相关函数
    strcmp,bcmp,memcmp,strcasecmp,strncasecmp
表头文件
    #include<string.h>
定义函数
    int strcoll( const char *s1, const char *s2);
函数说明
    strcoll()会依环境变量LC_COLLATE所指定的文字排列次序来比较s1和s2 字符串。
返回值
    若参数s1和s2字符串相同则返回0。s1若大于s2则返回大于0的值。s1若小于s2则返回小于0 的值。
附加说明
    若LC_COLLATE为"POSIX"或"C",则strcoll()与strcmp()作用完全相同。
范例
    参考strcmp()。
 


   
strcpy(拷贝字符串)
相关函数
    bcopy,memcpy,memccpy,memmove
表头文件
    #include<string.h>
定义函数
    char *strcpy(char *dest,const char *src);
函数说明
    strcpy()会将参数src字符串拷贝至参数dest所指的地址。
返回值
    返回参数dest的字符串起始地址。
附加说明
    如果参数dest所指的内存空间不够大,可能会造成缓冲溢出(buffer Overflow)的错误情况,在编写程序时请特别留意,或者用strncpy()来取代。
范例
    #include<string.h>
main()
{
char a[30]="string(1)";
char b[]="string(2)";
printf("before strcpy() :%s\n",a);
printf("after strcpy() :%s\n",strcpy(a,b));
}
执行
    before strcpy() :string(1)
after strcpy() :string(2)
 


   
strcspn(返回字符串中连续不含指定字符串内容的字符数)
相关函数
    strspn
表头文件
    #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”出现前的长度*/
 


   
strdup(复制字符串)
相关函数
    calloc,malloc,realloc,free
表头文件
    #include<string.h>
定义函数
    char * strdup( const char *s);
函数说明
    strdup()会先用maolloc()配置与参数s字符串相同的空间大小,然后将参数s字符串的内容复制到该内存地址,然后把该地址返回。该地址最后可以利用free()来释放。
返回值
    返回一字符串指针,该指针指向复制后的新字符串地址。若返回NULL表示内存不足。
范例
    #include<string.h>
main()
{
char a[]="strdup";
char *b;
b=strdup(a);
printf("b[ ]=\"%s\"\n",b);
}
执行
    b[ ]="strdup"
 


   
strlen(返回字符串长度)
相关函数
   
表头文件
    #include<string.h>
定义函数
    size_t strlen (const char *s);
函数说明
    strlen()用来计算指定的字符串s的长度,不包括结束字符"\0"。
返回值
    返回字符串s的字符数。
范例
    /*取得字符串str的长度*/
#include<string.h>
main()
{
char *str = "12345678";
printf("str length = %d\n", strlen(str));
}
执行
    str length = 8
 


   
strncasecmp(忽略大小写比较字符串)
相关函数
    bcmp,memcmp,strcmp,strcoll,strncmp
表头文件
    #include<string.h>
定义函数
    int strncasecmp(const char *s1,const char *s2,size_t n);
函数说明
    strncasecmp()用来比较参数s1和s2字符串前n个字符,比较时会自动忽略大小写的差异。
返回值
    若参数s1和s2 字符串相同则返回0。s1 若大于s2则返回大于0的值,s1若小于s2则返回小于0 的值。
范例
    #include<string.h>
main()
{
char *a="aBcDeF";
char *b="AbCdEf";
if(!strncasecmp(a,b))
printf("%s =%s\n",a,b);
}
执行
    aBcDef=AbCdEf
 


   
strncat(连接两字符串)
相关函数
    bcopy,memccpy,memecpy,strcpy,strncpy
表头文件
    #inclue <string.h>
定义函数
    char * strncat(char *dest,const char *src,size_t n);
函数说明
    strncat()会将参数src字符串拷贝n个字符到参数dest所指的字符串尾。第一个参数dest要有足够的空间来容纳要拷贝的字符串。
返回值
    返回参数dest的字符串起始地址。
范例
    #include <string.h>
main()
{
char a[30]="string(1)";
char b[]="string(2)";
printf("before strnact() :%s\n", a);
printf("after strncat() :%s\n", strncat(a,b,6));
}
执行
    before strnact() : string(1)
after strncat() : string(1) string
 


   
strncpy(拷贝字符串)
相关函数
    bcopy,memccpy,memcpy,memmove
表头文件
    #include<string.h>
定义函数
    char * strncpy(char *dest,const char *src,size_t n);
函数说明
    strncpy()会将参数src字符串拷贝前n个字符至参数dest所指的地址。
返回值
    返回参数dest的字符串起始地址。
范例
    #inclue <string.h>
main()
{
char a[30]="string(1)";
char b[]="string(2)";
printf("before strncpy() : %s\n",a);
printf("after strncpy() : %s\n",strncpy(a,b,6));
}
执行
    before strncpy() : string(1)
after strncpy() : string(1)
 


   
strpbrk(查找字符串中第一个出现的指定字符)
相关函数
    index,memchr,rindex,strpbrk,strsep,strspn,strstr,strtok
表头文件
    #include <include.h>
定义函数
    char *strpbrk(const char *s,const char *accept);
函数说明
    strpbrk()用来找出参数s 字符串中最先出现存在参数accept 字符串中的任意字符。
返回值
    如果找到指定的字符则返回该字符所在地址,否则返回0。
范例
    #include <string.h>
main()
{
char *s="0123456789012345678901234567890";
char *p;
p=strpbrk(s,"a1 839"); /*1会最先在s字符串中找到*/
printf("%s\n",p);
p=strprk(s,"4398");/*3 会最先在s 字符串中找到*/
printf("%s\n",p);
执行
    1.23E+29
 


   
strrchr(查找字符串中最后出现的指定字符)
相关函数
    index,memchr,rindex,strpbrk,strsep,strspn,strstr,strtok
表头文件
    #include<string.h>
定义函数
    char * strrchr(const char *s, int c);
函数说明
    strrchr()用来找出参数s字符串中最后一个出现的参数c地址,然后将该字符出现的地址返回。
返回值
    如果找到指定的字符则返回该字符所在地址,否则返回0。
范例
    #include<string.h>
main()
{
char *s="0123456789012345678901234567890";
char *p;
p=strrchr(s,&#39;5&#39;);
printf("%s\n",p);
}
执行
    567890
 


   
strspn(返回字符串中连续不含指定字符串内容的字符数)
相关函数
    strcspn,strchr,strpbrk,strsep,strstr
表头文件
    #include<string.h>
定义函数
    size_t strspn (const char *s,const char * accept);
函数说明
    strspn()从参数s 字符串的开头计算连续的字符,而这些字符都完全是accept 所指字符串中的字符。简单的说,若strspn()返回的数值为n,则代表字符串s 开头连续有n 个字符都是属于字符串accept内的字符。
返回值
    返回字符串s开头连续包含字符串accept内的字符数目。
范例
    #include<string.h>
main()
{
char *str="Linux was first developed for 386/486-based PCs.";
char *t1="abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
printf("%d\n",strspn(str,t1));
}
执行
    5 /*计算大小写字母。不包含“ ”,所以返回Linux的长度。*/
 


   
strstr(在一字符串中查找指定的字符串)
相关函数
    index,memchr,rindex,strchr,strpbrk,strsep,strspn,strtok
表头文件
    #include<string.h>
定义函数
    char *strstr(const char *haystack,const char *needle);
函数说明
    strstr()会从字符串haystack 中搜寻字符串needle,并将第一次出现的地址返回。
返回值
    返回指定字符串第一次出现的地址,否则返回0。
范例
    #include<string.h>
main()
{
char * s="012345678901234567890123456789";
char *p;
p= strstr(s,"901");
printf("%s\n",p);
}
执行
    9.01E+21
 


   
strtok(分割字符串)
相关函数
    index,memchr,rindex,strpbrk,strsep,strspn,strstr
表头文件
    #include<string.h>
定义函数
    char * strtok(char *s,const char *delim);
函数说明
    strtok()用来将字符串分割成一个个片段。参数s指向欲分割的字符串,参数delim则为分割字符串,当strtok()在参数s的字符串中发现到参数delim的分割字符时则会将该字符改为\0 字符。在第一次调用时,strtok()必需给予参数s字符串,往后的调用则将参数s设置成NULL。每次调用成功则返回下一个分割后的字符串指针。
返回值
    返回下一个分割后的字符串指针,如果已无从分割则返回NULL。
范例
    #include<string.h>
main()
{
char s[]="ab-cd : ef;gh :i-jkl;mnop;qrs-tu: vwx-y;z";
char *delim="-: ";
char *p;
printf("%s ";strtok(s,delim));
while((p=strtok(NULL,delim)))printf("%s ",p);
printf("\n");
}
执行
    ab cd ef;gh i jkl;mnop;qrs tu vwx y;z /*-与:字符已经被\0 字符取代*/
垃圾一个,00...

TOP

发新话题