Ʈ Լ ؼ Ͽϴ. ⿡  Լ ְų
߸  ִٸ  ֽñ ٶϴ.
				Written by LHC ( s1662543@kiscos.sarang.net)
 
	
			- Ʈ Լ v1.2-

1. 

     int strcasecmp(const char *s1, const char *s2);
     char *strcat(char *dest, const char *src);
     char *strchr(const char *s, int c);
     int strcmp(const char *s1, const char *s2);
	int strcoll(const char *s1, const char *s2);
	char *strcpy(char *dest, const char *src);
	size_t strcspn(const char *s, const char *reject);
	char *strdup(const char *s);
	char *strfry(char *string);
	size_t strlen(const char *s);
	char *strncat(char *dest, const char *src, size_t n);
	int strncmp(const char *s1, const char *s2, size_t n);
	char *strncpy(char *dest, const char *src, size_t n);
	int strncasecmp(const char *s1, const char *s2, size_t n);
	char *strpbrk(const char *s, const char *accept);
	char *strrchr(const char *s, int c);
	char *strsep(char **stringp, const char *delim);
	size_t strspn(const char *s, const char *accept);
	char *strstr(const char *haystack, const char *needle);
	char *strtok(char *s, const char *delim);
	size_t strxfrm(char *dest, const char *src, size_t n);
	char *index(const char *s, int c);
	char *rindex(const char *s, int c);
	
2. 
C string ܼ 0Ʈ  ڵ 迭̴.
string   Ÿ԰  string.h Ǿִ.
string ó  ʿ  str1 ù° ּҸ ˱ؼ &str1[0]
str1̶ ϸ ȴ. C 迭  迭 ù° ּҸ Ųٴ
 ̱  ̶  ˰  ̴. 迭 δ
ͷν óȴ. 
str1[i] ִٸ   ó   ȴ. *(str1 + i)
Լ ڷν 迭 ִ 찡 ִµ ̴  ڵ ƴϴ. ֳϸ
ڷ Ѱִ 迭 Ͱ ٽ ͷ ȯǴ  ľ ϱ⶧
ڵ ȿ ߸.
int func(char []) -> int func(char *) 
  ѴϿ 迭 Ͱ  ٰ ؼ ȵȴ.
char i[10]; ϸ char ޸𸮸 10ŭ Ҵϴ  char *i; ϸ 
޸𸮿 ִ ڸ Ű  Ҵȴ. ٽ  Լ ڸ Ѱ
°Ϳ  캸 ̿Ͱ ̿ ұϰ   ؾϴ ǹ
 Լ ڷ Ѱٶ 迭 簪 Ѱټ .
   Ѱ Ǵµ   Ŷ 迭 Ἥ ٽ ͷ
ȯǴ  ĥʿ䰡 ٴ ̴.
⿡   °    Ƿ  ڼ 
Ϳ 迭  å ϱ ٶ.(http://pw2.netcom.com/~tjensen/ptr/pointers.htm)
string  óҶ 帹 ϴ Լ strlen ִµ ̴  ϴ.
strlen ڿ ̸ ش(null ڴ ̿ ܵȴ). 
ٽøϸ null  offset ϴ ̴.   Ǵ  sizeof
 ̰ſ ȥ̴.

char a[1024] = " ȣȣȣ  ޷"; ִٰ ϸ
sizeof(a)  1024̰ strlen(a) 25̴.

 ֺ  size_t unsigned int̴.
Ʈ ó Կ ־  Ȯ ̸ ˰  찡 
 κ ش strlen() ȴ. װ ذ ȵǴ 
Լ ϰ ؼ   ִ 쵵 ִ.  read() write() 
쿡 ϰ аų  ̴. 

2.1  Լ

	 void *memcpy(void *dest, const void *src, size_t n);

̴ src Ű ޸   n Ʈ dest  Ѵ.
  ΰ   ȵȴ.  ׷찡 ʿϴٸ 
ؼ memmove ϶.
ϰ dest Ű  

	void *memmove(void *dest, const void *src, size_t n);

̴ src Ű ޸   n Ʈ dest ϴµ
 ޸  (overlap) ȴ.
ϰ dest Ű 

	void *memccpy(void *dest, const void *src, int c, size_t n);

n Ʈ ϴµ  c  Ѵ.
ϰ dest c ġ Ű . д NULL

	void *memset(void *s, int c, size_t n);
s Ű  cμ nƮ ŭ ä.
ϰ s Ű ̴.

	char *strcpy(char *dest, const char *src);
src ũ ޸  (ι ) dest Ű ޸ 
Ѵ.   dest Ǵ ڿ     ־Ѵ.
ϰ dest Ű ̴.

	char *strncpy(char *dest, const char *src, size_t n);
strcpy   n Ʈ Ѵ. ιڴ  ʴ´.
 src Ű  ڿ ̰ n ۴ٸ \0ν еǾ ȴ.
strncpy ϴ  strcpy
߻ ִ ׸ ϴ ̱   ̰ ӵ .
ֳϸ   src  ū ۿ ϴ  
 ιڷ ä Ǵµ ⿡  ð  ̴.

	char *strcat(char *dest, const char *src);
src Ű ޸  dest Ű   '\0' ġ ٿ 
ִ´(ιڱ). overlap   dest ο  string 
Ŀ ִ ޸𸮸 ־Ѵ.
ϰ dest Ű ̴.
strcat  .

     char *
     strcat (char *to, const char *from)
    {
	  strcpy (to + strlen (to), from);
	  return to;
    }
	
	char *strncat(char *dest, const char *src, size_t n);
strcat  src n byte Ѵ. 
׷  ιڱ Ǳ⶧  Ǵ ũ n + 1  
ؾ Ѵ.
src n ۴ٸ ιڷ еȴ. 
strncat ϰ a[0]  ̰ overlap  ʴ´.

       char *strdup(const char *s);
string duplicate. s ڿ ϰ  ڿ Ű ͸ 
Ѵ. ο ڿ malloc ؼ ޸𸮸 Ҵ ް
free ؼ  ִ.  Ҵ ޸𸮰 ٸ  ͸
Ѵ. 
	char *name;
	name = strdup("LHC");
	free (name);

       char * strndup (const char *s, size_t size) 
s size ŭ ڿ ϰ  ڿ Ű ͸ Ѵ.
size ڿ s ۴ٸ sizeŭ ϰ  ͸ ־ش.

2.2  Լ

	int memcmp(const void *s1, const void *s2, size_t n);
s1 s2 ó n Ʈ Ѵ. s1 s2 ũ 0 ū 
0   Ѵ.
 迭 ΰ  ʰ ׽Ʈϴµ ̸ ϴ°
 ϴ.  Ʈ  ٸ 迭 byte-wise ordering 񱳸
ϴ° ǹ̾ ̴.  Ǽ ͷ  ޸𸮻
1 byte-wise ordering Ǽ   迡  ͵
 ʴ´. Ǵٸ ؾ   holes ϴ ü
 ̴. holes еϿ  ޸  ϴµ е̶
 1byte ְ޴ Ȳ ִٰ Ҷ  Լ 5bit Ѵٸ
׸  ° ְ ޱ ؼ 8bit  Ѵ. ̶ ڶ 3Ʈ
η ä  ä簣 ̷ ä  ƴ ̴.
̷ е holes      ⶧ byte-wise 
  ų ִ.    Ȯ Ϸ component-wise
񱳸 ؾѴ.
struct foo
{
     unsigned char tag;
     union
     {
	       double f;
            long i;
	       char *p;
	 } value;
};
   foo  ͸ ϱ ؼ memcpy ϴ°ͺ 
ٸ Ư Լ ϴ°  .

	int strcmp(const char *s1, const char *s2);
s1 s2 ϰ ϰ memcmp .
strcmp   ̷ִ. 
int
strcmp(s1, s2)
register const char *s1, *s2;
{
        while (*s1 == *s2++)
               if (*s1++ == 0)
                        return (0);
 	       return (*(const unsigned char *)s1 - *(const unsigned char *)(s2 - 1));
								}
	int strncmp(const char *s1, const char *s2, size_t n);
s1 ó n Ʈ ϰ  strcmp .
 ƽŰ ڵ带  ϴ ýۿ ̴.
strcmp ("hello", "hello")
=> 0    /* Ƿ ϰ 0 */
strcmp ("hello", "Hello")
=> 32   /* h H ƽŰ ڵ  32 */
strcmp ("hello", "world")
=> -15  /* h w ƽŰ ڵ  15 */
strcmp ("hello", "hello, world")
=> -44  /* ιڿ ','  ƽŰڵ  44 */
strncmp ("hello", "hello, world", 5)
=> 0    /* ó 5Ʈ   ϰ 0*/
strncmp ("hello, world", "hello, stupid world!!!", 5)
=> 0    /* ó 5Ʈ   ϰ 0 */

       int strcasecmp(const char *s1, const char *s2);
strcmp .

       int strncasecmp(const char *s1, const char *s2, size_t n);
strncmp .

2.3   Լ ( collation function )
ڸ 񱳳 ϱ ؼ ϴ  ڵ尪 ˾ƾ Ѵ.  
ĺ  a 0x61 ƽŰ ڵ带 ´. ̸ Ͽ 츮
  ˼ִ. ׷  񿵾ǿ̴. ׵ ڿ 
ڵ尪 ʿѴ Ϲ α׷ ׿   ˼ ⶧
 ҼԵȴ. ׷ ʿ  ̶ ε ̰ ڰ
ϴ  ڿ   ִ. ׷ α׷  
Ͽ ̳ Ÿ   ڿ  ó Ҽִ ̴. 
̷  Ͽ °  ִ Լ strcoll strxfrm ִ.
̵ Լ  category LC_COLLATE Ѵ.
ǥ C strcoll   strcmp ϴ. 

	int strcoll(const char *s1, const char *s2);
 locale Ͽ  ڿ Ѵ. ϰ memcpy .
()
qsort ̿ strcoll 뿹.
int
compare_elements (char **p1, char **p2)
{
  return strcoll (*p1, *p2);
  }

/* This is the entry point---the function to sort
   strings using the locale's collating sequence. */

void
sort_strings (char **array, int nstrings)
{
  /* Sort temp_array by comparing the strings. */
    qsort (array, sizeof (char *),
             nstrings, compare_elements);
}

size_t strxfrm(char *dest, const char *src, size_t n);
strxfrm src Ʈ   ȯŰµ strxfrm ȯ ΰ
Ʈ strcmp ó ϸ ȯǱ ΰ Ʈ strcoll óѰͰ
   ȴ. ȯ n ŭ ڵ dest . ȯ
LC_COLLATE  ִ   . overlap  ʴ´.
ϰ ü ȯ  Ʈ ̰(\0 ) n   ʴ´.
 ȯ ڿ ̰ n ų ũٸ dest   Ȯ
 ؾ Ѵ. Ȯ dest  ٽѹ ū  strxfrm
ȣؾѴ.   n 0̸  ڵ dest  ʰ  ü
ȯ ڿ ̸ ϰ dest    ȱ 
ȯ  ̸ ˶ ϰ  ̴.   ϸ ȴ.
1 + strxfrm(NULL, "ȯ ڿ", 0) 
LC_COLLATE ԽĿ ˻̳ Ʈ   Ǵ  ̴.
 category ؼ  ڼ   man setlocale Ȯϱ
ٶ. setlocale α׷   ϴ Լ̴.
 ڽ ü   ȮϷ locale 
ָȴ. 
[root@LHC rc.d]# locale
LANG=ko_KR.eucKR
LC_CTYPE="ko_KR.eucKR"
LC_NUMERIC="ko_KR.eucKR"
LC_TIME="ko_KR.eucKR"
LC_COLLATE="ko_KR.eucKR"
LC_MONETARY="ko_KR.eucKR"
LC_MESSAGES="ko_KR.eucKR"
LC_ALL=ko_KR.eucKR
[]
 strcoll    ϴ ҽε Ʈ ȯ 1 ϱ
 ȿ̰ ξ .  񱳸 Ҷ  ̴.
struct sorter { char *input; char *transformed; };

/* This is the comparison function used with qsort
   to sort an array of struct sorter. */

   int
   compare_elements (struct sorter *p1, struct sorter *p2)
   {
     return strcmp (p1->transformed, p2->transformed);
   }

/* This is the entry point---the function to sort
   strings using the locale's collating sequence. */

   void
   sort_strings_fast (char **array, int nstrings)
   {
    	struct sorter temp_array[nstrings];
    	int i;

/* Set up temp_array.  Each element contains
   one input string and its transformed string. */
  	for (i = 0; i < nstrings; i++)
  	{
       		size_t length = strlen (array[i]) * 2;
       		char *transformed;
       		size_t transformed_lenght;

       		temp_array[i].input = array[i];

/* First try a buffer perhaps big enough.  */
       		transformed = (char *) xmalloc (length);

/* Transform array[i].  */
  		transformed_length = strxfrm (transformed, array[i], length);

/* If the buffer was not large enough, resize it
   and try again.  */
  		if (transformed_length >= length)
  		{
/* Allocate the needed space. +1 for terminating
   NUL character.  */
       			transformed = (char *) xrealloc (transformed, transformed_length + 1);

/* The return value is not interesting because we know
   how long the transformed string is.  */
       			(void) strxfrm (transformed, array[i], transformed_length + 1);
		}

     		temp_array[i].transformed = transformed;
     	}

/* Sort temp_array by comparing transformed strings. */
        qsort (temp_array, sizeof (struct sorter), nstrings, compare_elements);
/* Put the elements back in the permanent array
   in their sorted order. */
  	for (i = 0; i < nstrings; i++)
	      array[i] = temp_array[i].input;
/* Free the strings we allocated. */
  	for (i = 0; i < nstrings; i++)
        free (temp_array[i].transformed);
}

2.4 ˻Լ
       void *memchr(const void *s, int c, size_t n);
s Ű ִ ڿ n° ̳ ó  c ã´.
char ãµ int c   Ǿ  𸣰 c ã 
unsigned char ȯȴ. ϰ ãҴٸ ڰ ġ  ͸
ã ͸ Ѵ.

       char *strchr(const char *s, int c);
s Ű ִ ڿ c ã´. Ṯ ι  Ʈ
κν ֵȴ.  C ιڷ ν ڿ  
˾Ƴµ ̿ ִ. ϰ ãҴٸ ڰ ġ  ͸
ã ͸ Ѵ.
[] 
strchr ("hello, world", 'l')
     => "llo, world"
strchr ("hello, world", '?')
     => NULL
      
      char *strrchr(const char *s, int c);
s Ű ڿ  ߻ c ã´.
ϰ ã  ߻ c ּҸ ã  Ѵ. 
ι  Ʈ Ϻη ֵȴ.
[]
strrchr ("hello, world", 'l')
     => "ld"

       size_t strspn(const char *s, const char *accept);
 Լ s Ű ڿ accept  ڰ ȳö  
ڿ ̸ Ѵ. ϰ  ̴.
strspn string span̶ д´.
 
strspn ("hello, world", "abcdefghijklmnopqrstuvwxyz")
      => 5
accept  ڰ ȳö ̴ 5̴. ',' accept
ǵǾ  ʱ ̴.  accpet ", abcdefghijklmnopqrstuvwxyz"
ָ 13̶ ڿ ü ̸  ̴. accept   
ǵ  .

       size_t strcspn(const char *s, const char *reject);
string complement span ̶  strspn ݴ̴.   𸣰ڴµ
reject  ڰ ö ̸  ش.
strcspn ("hello, world", ",");
     => 5

       char *strpbrk(const char *s, const char *accept);
string point break  ϴ  strcspn ϴ. ٸ accept 
ǵ ڰ ó   ͸ Ѱشٴ ̴. 
[]
strpbrk ("hello, world", " \t\n,.;!?")
     => ", world"

       char *strstr(const char *haystack, const char *needle);
strchr ѵ ٸ ѹڰ ƴ ڿ ã´ٴ ̴.
ιڴ  ʴ´.
ϰ ã ó ߻  ͸ ã  Ѵ.
[]
strstr ("hello, world", "l")
     => "llo, world"
strstr ("hello, world", "wo")
     => "world"

       void *memmem(const void *haystack, size_t haystacklen,
                     const void *needle, size_t needlelen);
haystacklen ̸ŭ haystack needle needlelenŭ Ʈ ãƼ
ó ߻  Ѵ. 
Լ GNU Ȯ̴. libc 5.0.9  Լ ϴ  ϴ. ű⿡
needle haystack ڰ  ٲ ְ needle ó ߻   
Ѵ. libc 5.0.9   ǰ ֱ⶧  Լ  
ϹǷ  ؾ Ѵ. 
 libc glibcѴ   װ ִ.
 needle ̶ ϰ haystack ƴ϶ haystack - 1 ȴ.
glibc 2.0.5   Ȳ ϴµ ̴ haystack  Ʈ 
͸ Ѵ.   needle η ְ ؼ ȵǸ
 ʿ 찡 ƴϸ   ƾ  Լ̴.

       char *index(const char *s, int c);
strchr ٸ ̸ ϴ Ȱ

       char *rindex(const char *s, int c);
strrchr ٸ ̸ ϴ Ȱ.

		     
2.5 ū Լ
̵   м̳ Ľ Ҷ ȴ. 
       char *strtok(char *s, const char *delim);
 Լ ϴµ ణ  ϴ Լ Ǹ ￩ Ұ̴. 

char a[] = " ̰ ū  ";
char *p1, *p2, *p3, *p4, *p5;
p1 = strtok(a, " "); 
p2 = strtok(NULL, " ");
p3 = strtok(NULL, " ");
p4 = strtok(NULL, " ");
p5 = strtok(NULL, " ");
delim ó ߻  ڸ ã װ ιڷ üϰ ڿ
͸ Ѵ.  p1 '' Ű Ͱ ȴ. ׸ 
ܾ  Ű ͸  Ѵ. ׷  ù°
ڸ ̻ ʿ䰡 Ƿ NULL °̴. 
   Ȯ ذ ɰ̴. 
char string[] = "words separated by spaces -- and, punctuation!";
const char delimiters[] = " .,;:!-";
char *token;

...

token = strtok (string, delimiters);  /* token => "words" */
token = strtok (NULL, delimiters);    /* token => "separated" */
token = strtok (NULL, delimiters);    /* token => "by" */
token = strtok (NULL, delimiters);    /* token => "spaces" */
token = strtok (NULL, delimiters);    /* token => "and" */
token = strtok (NULL, delimiters);    /* token => "punctuation" */
token = strtok (NULL, delimiters);    /* token => NULL */

ؾ  strtok ϸ string Լ  ٲԵȴ.
 const string   .   Ǿ ϴ Ʈ
 Ϸ  縦 س ؾ Ѵ.

string  ѹھ  غ  . 
wordsseparatedbyspaces-- and punctuation 
delim ־ ڵ ͷ ٲ  Ⱑ ȵȰó δ.
"-- " κ   η ȯǰ delim ־   
a Ű  ׿  µǰ and  and ٷ  ','
ιڷ ġȯǰ delim ־  ùܾ  punc~ ⶧
׿  µǴ ̴. 

char * strtok_r (char *newstring, const char *delimiters, char **save_ptr)
strtok ϴ.  strtok ޸  ū  
 ʴ´ٴ ̴.  ȣҶ save_ptr    Ѵ.
2° ȣ newstring η ϰ save_ptr ״ ָ strtok 
۵ϰ ȴ.
 Լ POSIX.1b ȵǾ.

       char *strsep(char **stringp, const char *delim);
#include <string.h>
#include <stddef.h>

...

char string[] = "words separated by spaces -- and, punctuation!";
const char delimiters[] = " .,;:!-";
char *running;
char *token;

...

running = string;
token = strsep (&running, delimiters);    /* token => "words" */
token = strsep (&running, delimiters);    /* token => "separated" */
token = strsep (&running, delimiters);    /* token => "by" */
token = strsep (&running, delimiters);    /* token => "spaces" */
token = strsep (&running, delimiters);    /* token => "and" */
token = strsep (&running, delimiters);    /* token => "punctuation" */
token = strsep (&running, delimiters);    /* token => NULL */

ù° ڸ ΰ ν ߺ   ִ.
̴  ʱȭ ڰ Ҽִ. strsep ϸ 
delim  еǴ ū  ʹ ̰ ȴ.
ϰ  ū ó Ű ̴. delim ߰ߵ 
null Ѵ.
4.3BSD  Լ̴.
2.6 Ÿ Լ
       char *strerror(int errnum);
errnum Ѱ ڵ带 ϴ ڿ Ѵ.
 1  19 errnum  ̴. 
errornum 0 : 
errornum 1 :   
errornum 2 : ׷ ̳ 丮 
errornum 3 : ׷ μ 
errornum 4 : ߴܵ ý ȣ
errornum 5 : Է/ 
errornum 6 : ġ  ʾ
errornum 7 : μ  ʹ ϴ
errornum 8 : Exec  
errornum 9 : ߸  
errornum 10 : ڽ μ 
errornum 11 : ڿ Ͻ  Ұ
errornum 12 : ޸𸮸 Ҵ  ϴ
errornum 13 : 㰡 źε
errornum 14 : ߸ ּ
errornum 15 :  ġ ʿ
errornum 16 : ġ ڿ  
errornum 17 :  մϴ
errornum 18 :  ġ 
errornum 19 : ׷ ġ 

       char *strfry(char *string);
ڿ rand() Ͽ ȭ ϰ ȭ ڿ  ͸ 
Ѵ.

[ڷ]
  Linux man page
  Programming Language - C 
  love_C ( Cambridge University Engineering Department)
  The GNU C Library Reference Manual
