Search     or:     and:
 LINUX 
 Language 
 Kernel 
 Package 
 Book 
 Test 
 OS 
 Forum 
 iakovlev.org 
 Languages
 С
 GNU С Library 
 Qt 
 STL 
 Threads 
 C++ 
 Samples 
 stanford.edu 
 ANSI C
 Libs
 LD
 Socket
 Pusher
 Pipes
 Encryption
 Plugin
 Inter-Process
 Errors
 Deep C Secrets
 C + UNIX
 Linked Lists / Trees
 Asm
 Perl
 Python
 Shell
 Erlang
 Go
 Rust
NEWS
Последние статьи :
  Rust 07.11   
  Go 25.12   
  EXT4 10.11   
  FS benchmark 15.09   
  Сетунь 23.07   
  Trees 25.06   
  Apache 03.02   
  SQL 30.07   
  JFS 10.06   
  B-trees 01.06   
 
TOP 20
 Go Web ...543 
 Steve Pate 3...439 
 Rodriguez 6...415 
 Trees...402 
 TCP 3...378 
 Rodriguez 2...368 
 Rubni-Corbet -> Глав...356 
 Daniel Bovet 3...338 
 UML 3...338 
 Стивенс 9...337 
 Robert Love 3...337 
 B.Blunden 1...337 
 Steve Pate 1...334 
 Robert Love 2...328 
 Максвелл 1...327 
 Максвелл 1...327 
 Daniel Bovet 4...327 
 Mod_perl 2...326 
 Robbins 1...325 
 Стивенс 5...323 
 
  01.04.2017 : 2166403 посещений 

iakovlev.org
GNU C library включает в себя множество функций работы с символами . Они продекларированы в `ctype.h'. Следующие функции определяют тип символа по его числовому идентификатору :
 
 int islower (int c)
 int isupper (int c)
 int isalpha (int c)
 int isdigit (int c)
 int isalnum (int c)
 int isxdigit (int c)
 int ispunct (int c)
 int isspace (int c)
 int isblank (int c)
 
Функции с приставкой -to- производят конверсию :
 int tolower (int c)
 int toupper (int c)
 int toascii (int c)
 int _toupper (int c)
 int _tolower (int c)
 
GNU C library определяет строку как массив символов . Строковая переменная - это обычно указатель типа char * . Нулевой символ - это '\0' - стоит в конце такой строки . Для того , чтобы определить , достиг ли указатель конца строки , нужно написать
!*p или *p == '\0'
. Длина строки :
size_t strlen (const char *s)
Например
strlen ("hello, world")    => 12  
Или
 char string[32] = "hello, world";
 sizeof (string)=> 32
 strlen (string)=> 12
 char *ptr = string;
 sizeof (ptr) => 4
 
Следующая функция полезна тогда,когда строка не заканчивается на '\0'.
size_t strnlen (const char *s, size_t maxlen)
Следующая функция копирует определенное количество байт из одного места в другое и возвращает адрес пункта назначения копирования :
void * memcpy (void *restrict to, const void *restrict from, size_t size)
Следующая функция копирует определенное количество символов из одного места в другое
wchar_t * wmemcpy (wchar_t *restrict wto, const wchar_t *restruct wfrom, size_t size)
 
Следующая функция аналогична memcpy с той лишь разницей , что возвращает адрес назначения плюс длина скопированной строки :
void * mempcpy (void *restrict to, const void *restrict from, size_t size)
Аналогичная функция :
wchar_t * wmempcpy (wchar_t *restrict wto, const wchar_t *restrict wfrom, size_t size)
Копирует массив байт одного значения с :
void * memset (void *block, int c, size_t size)
Копирует массив символов
wchar_t * wmemset (wchar_t *block, wchar_t wc, size_t size)
Функция , аналогичная memcpy
char * strcpy (char *restrict to, const char *restrict from)
Следующий пример делает конкатенацию `foo' и `bar' в `foobar' с помощью stpcpy :

 #include < string.h>
 #include < stdio.h>
 int main (void)
 {
   char buffer[10];
   char *to = buffer;
   to = stpcpy (to, "foo");
   to = stpcpy (to, "bar");
   puts (buffer);
   return 0;
 }
 
Следующий пример на произвольную конкатенацию :
 char *
 concat (const char *str, ...)
 {
   va_list ap, ap2;
   size_t total = 1;
   const char *s;
   char *result;
   va_start (ap, str);
 /* Actually va_copy, but this is the name more gcc versions   understand.  */
   __va_copy (ap2, ap);
 /* Determine how much space we need.  */
   for (s = str; s != NULL; s = va_arg (ap, const char *))
    total += strlen (s);
    va_end (ap);
    result = (char *) malloc (total);
    if (result != NULL)
    {
     result[0] = '\0';
     /* Copy the strings.  */
    for (s = str; s != NULL; s = va_arg (ap2, const char *))
    strcat (result, s);
    }
    va_end (ap2);
    return result;
   }
 
А теперь сравните более эффективный вариант этого же кода :
 char *concat (const char *str, ...)
 {
   va_list ap;
   size_t allocated = 100;
   char *result = (char *) malloc (allocated);
   char *wp;
   if (allocated != NULL)
   {
     char *newp;
     va_start (ap, atr);
     wp = result;
     for (s = str; s != NULL; s = va_arg (ap, const char *))
   {
     size_t len = strlen (s);
   /* Resize the allocated memory if necessary.  */
    if (wp + len + 1 > result + allocated)
     {
       allocated = (allocated + len) * 2;
       newp = (char *) realloc (result, allocated);
       if (newp == NULL)
       {
       free (result);
       return NULL;
       }
     wp = newp + (wp - result);
     result = newp;
     }
     wp = mempcpy (wp, s, len);
     }
   /* Terminate the result string.  */
   *wp++ = '\0';
   /* Resize memory to the optimal size.  */
     newp = realloc (result, wp - result);
     if (newp != NULL)
           result = newp;
     va_end (ap);
     }
   return result;
  }
 
Следующий пример показывает применение strncpy и strncat
 #include < string.h>
 #include < stdio.h>
 #define SIZE 10
 static char buffer[SIZE];
 main ()
 {
   strncpy (buffer, "hello", SIZE);
   puts (buffer);
   strncat (buffer, ", world", SIZE - strlen (buffer) - 1);
   puts (buffer);
 }
 
Программа выводит
  hello
  hello, wo
Функции сравнения :
  strcmp ("hello", "hello")     => 0    /* These two strings are the same. */
  strcmp ("hello", "Hello")     => 32   /* Comparisons are case-sensitive. */
  strcmp ("hello", "world")     => -15  /* The character 'h' comes before 'w'. */
  strcmp ("hello", "hello, world")        => -44  
  strncmp ("hello", "hello, world", 5)    => 0    
  strncmp ("hello, world", "hello, stupid world!!!", 5)  => 0 
     
  strverscmp ("no digit", "no digit")  => 0    /* same behavior as strcmp. */
  strverscmp ("item#99", "item#100")   => <0   /* same prefix, but 99 < 100. */
  strverscmp ("alpha1", "alpha001")    => >0   
  strverscmp ("part1_f012", "part1_f01")  => >0   /* two fractional parts. */
  strverscmp ("foo.009", "foo.0")         => <0 
 
Поисковые функции :
  strchr ("hello, world", 'l')     => "llo, world"
  strchr ("hello, world", '?')     => NULL
  strrchr ("hello, world", 'l')    => "ld"
  
  strstr ("hello, world", "l")     => "llo, world"
  strstr ("hello, world", "wo")    => "world"
  strspn ("hello, world", "abcdefghijklmnopqrstuvwxyz")   => 5
  strcspn ("hello, world", " \t\n,.;!?")    => 5
  strpbrk ("hello, world", " \t\n,.;!?")    => ", world"
  
Пример с разбиением строк с использованием strtok:
 #include < string.h>
 #include < stddef.h>
 const char string[] = "words separated by spaces -- and, punctuation!";
 const char delimiters[] = " .,;:!-";
 char *token, *cp;
 cp = strdupa (string);                /* Make writable copy.  */
 token = strtok (cp, 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 */
 
Аалогичный пример с использованием strsep
  #include < string.h>
  #include < stddef.h>
  const char string[] = "words separated by spaces -- and, punctuation!";
  const char delimiters[] = " .,;:!-";
  char *running;
  char *token;
   running = strdupa (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 => "" */
  token = strsep (&running, delimiters);    /* token => "" */
  token = strsep (&running, delimiters);    /* token => "" */
  token = strsep (&running, delimiters);    /* token => "and" */
  token = strsep (&running, delimiters);    /* token => "" */
  token = strsep (&running, delimiters);    /* token => "punctuation" */
  token = strsep (&running, delimiters);    /* token => "" */
  token = strsep (&running, delimiters);    /* token => NULL */
  
Конвертация бинарных данных в символьные :
  char * l64a (long int n)
Пример ее использования :
  char * encode (const void *buf, size_t len)
  {
    /* We know in advance how long the buffer has to be. */
    unsigned char *in = (unsigned char *) buf;
    char *out = malloc (6 + ((len + 3) / 4) * 6 + 1);
    char *cp = out;
   /* Encode the length. */
   /* Using `htonl' is necessary so that the data can be
   decoded even on machines with different byte order. */
    cp = mempcpy (cp, l64a (htonl (len)), 6);
     while (len > 3)
     {
        unsigned long int n = *in++;
        n = (n << 8) | *in++;
        n = (n << 8) | *in++;
        n = (n << 8) | *in++;
       len -= 4;
       if (n)
       cp = mempcpy (cp, l64a (htonl (n)), 6);
       else
       /* `l64a' returns the empty string for n==0, so we 
       must generate its encoding ("......") by hand. */
       cp = stpcpy (cp, "......");
       }
      if (len > 0)
      {
       unsigned long int n = *in++;
       if (--len > 0)
       {
        n = (n << 8) | *in++;
        if (--len > 0)
        n = (n << 8) | *in;
       }
       memcpy (cp, l64a (htonl (n)), 6);
       cp += 6;
      }
    *cp = '\0';
    return out;
 	 } 
Следующая программа демонстрирует работу библиотеки < string.h >. Хочется сказать несколько слов о ней : к ее написанию приложили руки несколько людей , и теперь нам приходится это расхлебывать . Большинство функций возвращают либо NULL , либо указатель на строку . Если функция может вернуть NULL , нужно проверять возвращаемое значение и делать соответствующую обработку в этом случае .
 #include < string.h >
 #include < stdio.h >
 /* 	Written by James M. Rogers 	02 Feb 2002 */
 
 #define  MAX_STRING_LENGTH  17
 #define STATIC_STRING "This is a long string "
 
 main (){
 
     char  aa[10];
     char  ab[100];
     char  ac[1000];
     char  ad[10000];
 
     char *ba;
     char *bb;
     char *bc;
     char *bd;
     char *be;
 
     char string_a[17];
     char string_b[MAX_STRING_LENGTH];
     char *string_c;
     int string_length;
 
     int    x;
     size_t y;
 
 /* Examples */
 
     /* This reserves room for 16 characters and an end of string marker. */
 
 
     strcpy ( string_a, "This is a string" );
 printf("\n strcpy (string_a, \"This is a string\" ); \n string_a=%s \n",string_a);
 
   /* the following copies a string in that is too large. */
   /* it shouldn't work, but often does.  */
     strcpy ( string_a, "This is a long string" );
 printf("\n strcpy(string_a,\"This is a string\" );\n string_a = %s\n",string_a);
 
 
     strncpy ( string_b, "This is a long string", MAX_STRING_LENGTH );
     string_b[MAX_STRING_LENGTH-1] = '\000';
 printf("\n strcpy(string_b, \"This is a string\");\n string_b=%s \n",string_b);
     
 
 
     string_length = strlen(STATIC_STRING);
     
     if (!(string_c = (char *) malloc ( string_length ))){
        /* no memory left, die */
        exit (1);
     }
 
     strncpy( string_c,  STATIC_STRING, string_length);
     string_c[string_length] = '\000';
     printf("\n string_c = %s \n", string_c);
 
     /* do something with the string */
     free(string_c);
 
 
 /* Copy */
 
     printf ("\n* Copy \n");
 
   /* void  *memcpy(void *dest, const void *src, size_t n); */
 
     memcpy (aa, "test", 5);
     printf ("\n memcpy (aa, \"test\", 5) \n aa = \"%s\"\n", aa);
 
   /* void *memmove(void *dest, const void *src, size_t n); */
 
     memmove (ab, aa, 10);
     printf ("\n memmove (ab, aa, 10) \n ab = \"%s\"\n", ab);
 
   /* char *strncpy(char *dest, const char *src, size_t n); */
 
     strncpy (aa, "ghij", 5);
     printf ("\n strncpy (aa, \"ghij\", 5) \n aa = \"%s\"\n", aa);
 
   /* char  *strcpy(char *dest, const char *src); */
 
     strcpy (ab, "abcdef");
     printf ("\n strcpy (ab, \"abcdefg\") \n ab = \"%s\"\n", ab);
 
 
 /* Concat */
 
     printf ("\n* Concat \n");
 
   /* char *strcat(char *dest, const char *src); */
 
     strcat (ab, aa);
     printf ("\n strcat (ab, aa) \n ab = \"%s\"\n", ab);
 
   /* char *strncat(char *dest, const char *src, size_t n); */
 
     strncat (ab, aa, 3);
     printf ("\n strncat (ab, aa, 3) \n ab = \"%s\"\n", ab);
 
 
 /* Compare */
 
     printf ("\n* Compare \n");
 
   /* int memcmp(const void *s1, const void *s2, size_t n); */
 
     x = memcmp("b", "abc", 1);
     printf ("\n x = memcmp(\"b\", \"abc\", 1) \n x = %d \n", x);
     
     x = memcmp("b", "bcd", 1);
     printf ("\n x = memcmp(\"b\", \"bcd\", 1) \n x = %d \n", x);
     
     x = memcmp("b", "cde", 1);
     printf ("\n x = memcmp(\"b\", \"cde\", 1) \n x = %d \n", x);
     
     x = memcmp("b", "b\0cd", 100);
     printf ("\n x = memcmp(\"b\", \"b\\0cd\", 100) \n x = %d \n", x);
     
   /* int strncmp(const char *s1, const char *s2, size_t n); */
 
     x = strncmp("b", "abc", 1);
     printf ("\n\n x = strncmp(\"b\", \"abc\", 1) \n x = %d \n", x);
     
     x = strncmp("b", "bcd", 1);
     printf ("\n x = strncmp(\"b\", \"bcd\", 1) \n x = %d \n", x);
     
     x = strncmp("b", "cde", 1);
     printf ("\n x = strncmp(\"b\", \"cde\", 1) \n x = %d \n", x);
     
     x = strncmp("b", "b\0cd", 100);
     printf ("\n x = strncmp(\"b\", \"b\\0cd\", 100) \n x = %d \n", x);
     
   /* int strcmp(const char *s1, const char *s2); */
 
     x = strcmp("b", "abc");
     printf ("\n\n x = strcmp(\"b\", \"abc\") \n x = %d \n", x);
     
     x = strcmp("b", "a");
     printf ("\n x = strcmp(\"b\", \"a\") \n x = %d \n", x);
     
     x = strcmp("b", "bcd");
     printf ("\n x = strcmp(\"b\", \"bcd\") \n x = %d \n", x);
     
     x = strcmp("b", "b");
     printf ("\n x = strcmp(\"b\", \"b\") \n x = %d \n", x);
     
     x = strcmp("b", "cde");
     printf ("\n x = strcmp(\"b\", \"cde\") \n x = %d \n", x);
     
     x = strcmp("b", "c");
     printf ("\n x = strcmp(\"b\", \"c\") \n x = %d \n", x);
     
     x = strcmp("b", "b\0cd");
     printf ("\n x = strcmp(\"b\", \"b\\0cd\") \n x = %d \n", x);
     
   /* int strcoll(const char *s1, const char *s2); */
 
     x = strcoll("b", "a");
     printf ("\n\n x = strcoll(\"b\", \"abc\") \n x = %d \n", x);
     
     x = strcoll("b", "b");
     printf ("\n x = strcoll(\"b\", \"b\") \n x = %d \n", x);
     
     x = strcoll("b", "c");
     printf ("\n x = strcoll(\"b\", \"cde\") \n x = %d \n", x);
     
     x = strcoll("b", "b\0cd");
     printf ("\n x = strcoll(\"b\", \"b\\0cd\") \n x = %d \n", x);
     
   /* size_t strxfrm(const char *s1, const char *s2, size_t n); */
 
     strncpy (ac, "abcdefghijklmnopqrstuvwxyz", 27);
     strncpy (aa, "efghijklmonp", 13);
 
     printf ("\n ac = %s \n", ac);
     printf ("\n aa = %s \n", aa);
     
     y = strxfrm(ac, aa, 27);
     printf ("\n y = strxfrm(ac, aa, 27) \n y = %d \n ac = \"%s\"\n", y, ac);
 
 
 /* Search */
 
     printf ("\n* Search \n");
 
   /* void *memchr(const void *s, int c, size_t n); */
 
     ba = memchr (ab, 'd', 10);
     printf ("\n ba = memchr(%s, 'd', 10) \n ba = \"%s\" \n ", ab, ba);
 
   /* size_t *strcspn(const char *s, const char *reject); */
 
     y = strcspn (ab, "dgh");
 printf("\n strcspn (\"%s\",\"dgh\")\n y = %d \n ab[%d] = %s \n",ab,y,y,&ab[y]);
     
   /* size_t *strspn(const char *s, const char *accept); */
 
  y = strspn (ab, "abcdef");
  printf("\n strspn(\"%s\",\"abcdef\")\n y=%d\n ab[%d]=%s \n",ab,y,y,&ab[y]);
     
   /* char *strpbrk(const char *s, const char *accept); */
 
     ba = strpbrk(ab, "cde");
     printf ("\n strpspn (\"%s\", \"cde\")  \n ba=%s \n",ab,ba);
 
   /* char *strchr(const char *s, int c); */
 
     ba = strchr (ab, 'h');
     printf ("\n ba = strchr(%s, 'h') \n ba = \"%s\" \n ", ab, ba);
 
   /* char *strrchr(const char *s, int c); */
 
     ba = strrchr (ab, 'h');
     printf ("\n ba = strrchr(%s, 'h') \n ba = \"%s\" \n ", ab, ba);
 
   /* char *strstr(const char *s, const char *substring); */
 
     ba = strstr (ab, "hij");
     printf ("\n ba = strchr(%s, 'hij') \n ba = \"%s\" \n ", ab, ba);
 
     ba = strstr (ab, "ghig");
     printf ("\n ba = strchr(%s, 'ghij') \n ba = \"%s\" \n ", ab, ba);
 
   /* char *strtok(char *s, const char *delim); */
 
     strcpy(ad, "This is an example sentence.");
     printf("\n strcpy(ad, \"This is an example sentence.\") \n"); 
 
     bb = strtok(ad, " ");
     while (bb) {
         printf ("  bb = \"%s\"\n", bb);
         bb = strtok(NULL, " ");
     }
         
 
 /* Misc */
 
     printf ("\n* Misc \n");
 
   /* void *memset(void *s, int c, size_t n); */
 
     memset(ac, 'a', 1000);
     ac[999] = '\0';
     printf ("\n memset(ac, 'a', 1000); \n ac[999] = '\\0'; \n ac = \"%s\" \n", ac);
 
   /* char *strerror(int errnum); */
 
     printf ("\n strerror(5) = %s \n", strerror (5));
 
   /* size_t *strlen(const char *s); */
 
     y = strlen(ac);
     printf("\n y = strlen(ac); \n y = %d \n", y);
 
 /* Non Portable */
 
     printf ("\n* Non Portable \n");
 
   /* int strcasecmp(const char *s1, const char *s2); */
 
     x = strcasecmp("b", "ABC");
     printf ("\n\n x = strcasecmp(\"b\", \"ABC\") \n x = %d \n", x);
 
     x = strcasecmp("b", "A");
     printf ("\n x = strcasecmp(\"b\", \"A\") \n x = %d \n", x);
 
     x = strcasecmp("b", "BCD");
     printf ("\n x = strcasecmp(\"b\", \"BCD\") \n x = %d \n", x);
 
     x = strcasecmp("b", "B");
     printf ("\n x = strcasecmp(\"b\", \"B\") \n x = %d \n", x);
 
     x = strcasecmp("b", "CDE");
     printf ("\n x = strcasecmp(\"b\", \"CDE\") \n x = %d \n", x);
 
     x = strcasecmp("b", "C");
     printf ("\n x = strcasecmp(\"b\", \"C\") \n x = %d \n", x);
 
     x = strcasecmp("b", "B\0CD");
     printf ("\n x = strcasecmp(\"b\", \"B\\0CD\") \n x = %d \n", x);
 
   /* int strncasecmp(const char *s1, const char *s2, size_t n); */
 
     x = strncasecmp("b", "ABC", 1);
     printf ("\n\n x = strncasecmp(\"b\", \"ABC\", 1) \n x = %d \n", x);
 
     x = strncasecmp("b", "BCD", 1);
     printf ("\n x = strncasecmp(\"b\", \"BCD\", 1) \n x = %d \n", x);
 
     x = strncasecmp("b", "CDE", 1);
     printf ("\n x = strncasecmp(\"b\", \"CDE\", 1) \n x = %d \n", x);
 
     x = strncasecmp("b", "B\0CD", 100);
     printf ("\n x = strncasecmp(\"b\", \"B\\0CD\", 100) \n x = %d \n", x);
 
   /* char *strdup(const char *s); */
 
     ba = strdup ("Test of strdup");
     printf("\n ba = strdup (\"Test of strdup\"); \n ba = %s \n", ba);
 
   /* char *strfry(char *string); */
 
     strfry(ba);
     printf("\n strfry (ba); \n ba = %s \n", ba);
     free (ba);
 
   /* char *strsep(char **stringp, const char *delim); */
 
     strcpy(ad, "This is a second example sentence.");
     printf("\n strcpy(ad, \"%s\") \n", ad); 
 
     ba = ad;
 
     bb = strsep(&ba, " ");
     while (bb) {
         printf ("  bb = \"%s\"\n", bb);
         bb = strsep(&ba, " ");
     }
     
     printf ("\n ad == %s\n", ad);
     printf ("\n");
 
   /* char *index(const char *s, int c); */
   /* use strchr instead, it is the same function, only portable */
 
   /* char *rindex(const char *s, int c); */
   /* use strrchr instead, it is the same function, only portable */
 
 }
Оставьте свой комментарий !

Ваше имя:
Комментарий:
Оба поля являются обязательными

 Автор  Комментарий к данной статье