跳转到内容

C++ 编程/代码/标准 C 库/字符串和字符

Add links
维基教科书，自由的教科书

标准 C 字符串和字符

[编辑 | 编辑源代码]

标准 C 库还包括处理字符和字符串的例程。您必须记住，在 C 中，一个字符序列存储在一个字符数组的连续元素中，并以 **NULL** 字符结束。

/* "Hello" is stored in a character array */
char note[SIZE];
note[0] = 'H'; note[1] = 'e'; note[2] = 'l'; note[3] = 'l'; note[4] = 'o'; note[5] = '\0';

即使过时了，这些 C 字符串和字符函数仍然出现在旧代码中，并且比之前的 I/O 函数更多。

atof

[编辑 | 编辑源代码]
语法 
#include <cstdlib>
double atof( const char *str );

atof() 函数将 str 转换为双精度浮点数，然后返回该值。str 必须以有效数字开头，但可以用任何非数字字符终止，除了“E”或“e”。例如，

x = atof( "42.0is_the_answer" );

会导致 x 被设置为 42.0。

相关主题
atoi - atol - strtod
(标准 C I/O) sprintf

atoi

[编辑 | 编辑源代码]
语法 
#include <cstdlib>
int atoi( const char *str );

atoi() 函数将 str 转换为整数，然后返回该整数。str 应该以空格或某种数字开头，atoi() 会在读取到非数字字符时停止从str 读取。例如

int i;
i = atoi( "512" );
i = atoi( "512.035" );
i = atoi( "   512.035" );
i = atoi( "   512+34" );
i = atoi( "   512 bottles on the wall" );

以上对变量i 的所有五个赋值都会导致它被设置为 512。

如果无法执行转换，则 atoi() 将返回零

int i = atoi( " does not work: 512" );  // results in i == 0

atoi 的完整 C++ 实现。

/*
    Description:
    Program to convert a c-style string into decimal, octal and hex integers. 
    Copyright (C) <2015>  <AM>

    This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or 
    (at your option) any later version.

    This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

// Standard IOSTREAM
#include "iostream"

// Convert a string of Numbers to integer 
long int atoifunc(const char* str);

// Function to convert a string of Numbers into an integer 
long int atoioct(const char* str);

// Function to convert a string of Numbers into a hexadecimal integer 
long long int atoiHex(const char* str);

// Find length of a string 
static int strlength(const char *str);

// Get digit from character in input string 
static int getDecDigit(const char str);

// Get a digit from corresponding character in input string
static int getOctDigit(const char str);

// Get a hexadecimal digit from corresponding character in input string
static int getHexDigit(const char str);

using namespace std;

// Application program 
int main(void)
{
    char decstr[8] = "";
    char octstr[8] = "";
    char Hexstr[8] = "";
    long int IntNumber=0;
    long int OctNumber=0;
    long long int HexNumber=0;

    cout << "Enter a string of 8 characters in decimal digit form: ";
    cin >> decstr;

    cout << "Enter a string of 8 characters is octal form: ";
    cin >> octstr;

    IntNumber = atoifunc(decstr);
    cout <<"\nYou entered decimal number: " << IntNumber;

    cout << oct;
    OctNumber= atoioct(octstr);

    // Displaying octal number should be done in digits 0-7
    cout <<"\nYou entered octal number: " << OctNumber;

    cout << dec;
    // Displaying octal number should be done in digits 0-7
    cout <<"\nYou entered an oct which is decimal number: " << OctNumber;

    cout << "\nEnter a string of 7 characters in Hex form: ";
    cin >> Hexstr;

    HexNumber=atoiHex(Hexstr);
    cout << hex;
    // Displaying octal number should be done in digits 0-9, A-F
    cout <<"\nYou entered a Hexadecimal number: " << HexNumber;

    cout << dec;

    // Displaying octal number should be done in digits 0-9, A-F
    cout <<"\nYou entered a Hexadecimal which is decimal number: " << HexNumber;

    return 0;
}

/* Function to convert a string of Numbers into an integer */

/* Get the Number of digits entered as a string.

For each digit, place it in appropriate place of an integer such as digit x 1000 or digit x10000 depending on integer size and input range. The multiple of the first and subsequent digits would be selected depending on the number of digits.

For example, 123 would be calculated as an integer in the following steps:

1* 100
2* 10
3* 1

The calculated value is then returned by the function.

For example, if the digits entered are 12345
Then,the multipliers are:
str[0] * 10000
str[1] * 1000
str[2] * 100
str[3] * 10
str[4] * 1
Check your machine endianness for correct order of bytes.
*/

long int atoifunc(const char* str)
{

  int declength =strlength(str);
  long int Number =0;
   switch(declength)
    {
          case 0:
          Number += getDecDigit(str[0])*0;
          break;

          // Convert characters to digits with another function.
          case 1:
          Number += getDecDigit(str[0])*1;
          break;

          case 2:

          Number+=getDecDigit(str[0])*10;
          Number+=getDecDigit(str[1])*1;
          break;

          case 3:
          Number+=getDecDigit(str[0])*100;
          Number+=getDecDigit(str[1])*10;
          Number+=getDecDigit(str[2])*1;
          break;

          case 4:
          Number+=getDecDigit(str[0])*1000;
          Number+=getDecDigit(str[1])*100;
          Number+=getDecDigit(str[2])*10;
          Number+=getDecDigit(str[3])*1;
          break;

          case 5:
          Number+=getDecDigit(str[0])*10000;
          Number+=getDecDigit(str[1])*1000;
          Number+=getDecDigit(str[2])*100;
          Number+=getDecDigit(str[3])*10;
          Number+=getDecDigit(str[4])*1;
          break;

          case 6:
          Number+=getDecDigit(str[0])*100000;
          Number+=getDecDigit(str[1])*10000;
          Number+=getDecDigit(str[2])*1000;
          Number+=getDecDigit(str[3])*100;
          Number+=getDecDigit(str[4])*10;
          Number+=getDecDigit(str[5])*1;
          break;

          case 7:
          Number+=getDecDigit(str[0])*1000000;
          Number+=getDecDigit(str[1])*100000;
          Number+=getDecDigit(str[2])*10000;
          Number+=getDecDigit(str[3])*1000;
          Number+=getDecDigit(str[4])*100;
          Number+=getDecDigit(str[5])*10;
          Number+=getDecDigit(str[6])*1;
          break;

          case 8:
          Number+=getDecDigit(str[0])*10000000;
          Number+=getDecDigit(str[1])*1000000;
          Number+=getDecDigit(str[2])*100000;
          Number+=getDecDigit(str[3])*10000;
          Number+=getDecDigit(str[4])*1000;
          Number+=getDecDigit(str[5])*100;
          Number+=getDecDigit(str[6])*10;
          Number+=getDecDigit(str[7])*1;
          break;

          default:
          Number =0;
          break;
  }

  return Number;
}

// Find length of a string
static int strlength(const char *str)
{
    int count=0;
    while(str[count]!='\0')
    {
        count++;
    }
    return count;
}

// get a digit from corresponding character in input string
static int getDecDigit(const char str)
{
    int digit =0;
    switch (str)
    {
        case '0':
        digit = 0;
        break;

        case '1':
        digit = 1;
        break;

        case '2':
        digit = 2;
        break;

        case '3':
        digit = 3;
        break;

        case '4':
        digit = 4;
        break;

        case '5':
        digit = 5;
        break;

        case '6':
        digit = 6;
        break;

        case '7':
        digit = 7;
        break;

        case '8':
        digit = 8;
        break;

        case '9':
        digit = 9;
        break;

        default:
        digit =0;
        break;
    }
    return digit;
}

/* Function to convert a string of Numbers into an integer */

long int atoioct(const char* str)
{
  long int Number =0;
  int stroctlength =strlength(str);
   switch(stroctlength)
    {
          case 0:
          Number += getOctDigit(str[0])*0;
          break;

          // Convert characters to digits with another function.
          case 1:
          Number += getOctDigit(str[0])*1;
          break;

          case 2:

          Number+=getOctDigit(str[0])*8;
          Number+=getOctDigit(str[1])*1;
          break;

          case 3:

          Number+=getOctDigit(str[0])*64;
          Number+=getOctDigit(str[1])*8;
          Number+=getOctDigit(str[2])*1;

          break;

          case 4:
          Number+=getOctDigit(str[0])*512;
          Number+=getOctDigit(str[1])*64;
          Number+=getOctDigit(str[2])*8;
          Number+=getOctDigit(str[3])*1;

          break;

          case 5:
          Number+=getOctDigit(str[0])*4096;
          Number+=getOctDigit(str[1])*512;
          Number+=getOctDigit(str[2])*64;
          Number+=getOctDigit(str[3])*8;
          Number+=getOctDigit(str[4])*1;
          break;

          case 6:
          Number+=getOctDigit(str[0])*32768;
          Number+=getOctDigit(str[1])*4096;
          Number+=getOctDigit(str[2])*512;
          Number+=getOctDigit(str[3])*64;
          Number+=getOctDigit(str[4])*8;
          Number+=getOctDigit(str[5])*1;
          break;

          case 7:
          Number+=getOctDigit(str[0])*262144;
          Number+=getOctDigit(str[1])*32768;
          Number+=getOctDigit(str[2])*4096;
          Number+=getOctDigit(str[3])*512;
          Number+=getOctDigit(str[4])*64;
          Number+=getOctDigit(str[5])*8;
          Number+=getOctDigit(str[6])*1;
          break;

          default:
          Number =0;
          break;
  }

  return Number;

}

// Get a digit from character input in input string
static int getOctDigit(const char str)
{
    int digit =0;
    switch (str)
    {
        case '0':
        digit = 0;
        break;

        case '1':
        digit = 1;
        break;

        case '2':
        digit = 2;
        break;

        case '3':
        digit = 3;
        break;

        case '4':
        digit = 4;
        break;

        case '5':
        digit = 5;
        break;

        case '6':
        digit = 6;
        break;

        case '7':
        digit = 7;
        break;

        default:
        digit =0;
        break;
    }
    return digit;
}

// Get a hexadecimal digit from corresponding character in input string
static int getHexDigit(const char str)
{
    int digit =0;
    switch (str)
    {
        case '0':
        digit = 0;
        break;

        case '1':
        digit = 1;
        break;

        case '2':
        digit = 2;
        break;

        case '3':
        digit = 3;
        break;

        case '4':
        digit = 4;
        break;

        case '5':
        digit = 5;
        break;

        case '6':
        digit = 6;
        break;

        case '7':
        digit = 7;
        break;

        case '8':
        digit = 8;
        break;

        case '9':
        digit = 9;
        break;

        case 'A' :
        case 'a':
        digit =10;
        break;

        case 'B' :
        case 'b':
        digit = 11;
        break;

        case 'C' :
        case 'c':
        digit =12;
        break;

        case 'D' :
        case 'd':
        digit =13;
        break;

        case 'E' :
        case 'e':
        digit = 14;
        break;

        case 'F' :
        case 'f':
        digit = 15;
        break;

        default:
        digit =0;
        break;
    }
    return digit;
}

// Function to convert a string of Numbers into a hexadecimal integer
long long int atoiHex(const char* str)
{
  long long int Number =0;
  int strHexlength =strlength(str);
  switch(strHexlength)
    {
          case 0:
          Number += getHexDigit(str[0])*0;
          break;

          // Convert characters to digits with another function.
          // Implicit type conversion from int to long int.
          case 1:
          Number += getHexDigit(str[0])*1;
          break;

          case 2:
          Number+=getHexDigit(str[0])*16;
          Number+=getHexDigit(str[1])*1;
          break;

          case 3:
          Number+=getHexDigit(str[0])*256;
          Number+=getHexDigit(str[1])*16;
          Number+=getHexDigit(str[2])*1;
          break;

          case 4:
          Number+=getHexDigit(str[0])*4096;
          Number+=getHexDigit(str[1])*256;
          Number+=getHexDigit(str[2])*16;
          Number+=getHexDigit(str[3])*1;
          break;

          case 5:
          Number+=getHexDigit(str[0])*65536;
          Number+=getHexDigit(str[1])*4096;
          Number+=getHexDigit(str[2])*256;
          Number+=getHexDigit(str[3])*16;
          Number+=getHexDigit(str[4])*1;
          break;

          case 6:
          Number+=getHexDigit(str[0])*1048576;
          Number+=getHexDigit(str[1])*65536;
          Number+=getHexDigit(str[2])*4096;
          Number+=getHexDigit(str[3])*256;
          Number+=getHexDigit(str[4])*16;
          Number+=getHexDigit(str[5])*1;
          break;

          case 7:
          Number+=getHexDigit(str[0])*16777216;
          Number+=getHexDigit(str[1])*1048576;
          Number+=getHexDigit(str[2])*65536;
          Number+=getHexDigit(str[3])*4096;
          Number+=getHexDigit(str[4])*256;
          Number+=getHexDigit(str[5])*16;
          Number+=getHexDigit(str[6])*1;
          break;

          default:
          Number =0;
          break;
  }

  return Number;

}
相关主题
atof - atol
(标准 C I/O) sprintf

atol

[编辑 | 编辑源代码]
语法 
#include <cstdlib>
long atol( const char *str );

atol() 函数将str 转换为长整数，然后返回该值。atol() 会从str 读取，直到找到长整数中不应该出现的任何字符。然后，将生成的截断值进行转换并返回。例如，

x = atol( "1024.0001" );

会导致 x 被设置为 1024L。

相关主题
atof - atoi - strtod
(标准 C I/O) sprintf

isalnum

[编辑 | 编辑源代码]
语法 
#include <cctype>
int isalnum( int ch );

如果其参数是数字或字母，则 isalnum() 函数返回非零值。否则，返回零。

char c;
scanf( "%c", &c );
if( isalnum(c) )
  printf( "You entered the alphanumeric character %c\n", c );
相关主题
isalpha - iscntrl - isdigit - isgraph - isprint - ispunct - isspace - isxdigit

isalpha

[编辑 | 编辑源代码]
语法 
#include <cctype>
int isalpha( int ch );

如果其参数是字母，则 isalpha() 函数返回非零值。否则，返回零。

char c;
scanf( "%c", &c );
if( isalpha(c) )
  printf( "You entered a letter of the alphabet\n" );
相关主题
isalnum - iscntrl - isdigit - isgraph - isprint - ispunct - isspace - isxdigit

iscntrl

[编辑 | 编辑源代码]
语法 
#include <cctype>
int iscntrl( int ch );

如果其参数是控制字符（介于 0 和 0x1F 之间或等于 0x7F），则 iscntrl() 函数返回非零值。否则，返回零。

相关主题
isalnum - isalpha - isdigit - isgraph - isprint - ispunct - isspace - isxdigit

isdigit

[编辑 | 编辑源代码]
语法 
#include <cctype>
int isdigit( int ch );

如果函数 isdigit() 的参数是 0 到 9 之间的数字，则返回非零值。否则，返回零。

char c;
scanf( "%c", &c );
if( isdigit(c) )
  printf( "You entered the digit %c\n", c );
相关主题
isalnum - isalpha - iscntrl - isgraph - isprint - ispunct - isspace - isxdigit

isgraph

[编辑 | 编辑源代码]
语法 
#include <cctype>
int isgraph( int ch );

如果函数 isgraph() 的参数是除空格之外的任何可打印字符（如果您可以看到该字符，则 isgraph() 将返回非零值），则返回非零值。否则，返回零。

相关主题
isalnum - isalpha - iscntrl - isdigit - isprint - ispunct - isspace - isxdigit

islower

[编辑 | 编辑源代码]
语法 
#include <cctype>
int islower( int ch );

如果函数 islower() 的参数是小写字母，则返回非零值。否则，返回零。

相关主题
isupper

isprint

[编辑 | 编辑源代码]
语法 
#include <cctype>
int isprint( int ch );

如果函数 isprint() 的参数是可打印字符（包括空格），则返回非零值。否则，返回零。

相关主题
isalnum - isalpha - iscntrl - isdigit - isgraph - ispunct - isspace

ispunct

[编辑 | 编辑源代码]
语法 
#include <cctype>
int ispunct( int ch );

如果函数 ispunct() 的参数是打印字符，但不是字母数字字符或空格，则返回非零值。否则，返回零。

相关主题
isalnum - isalpha - iscntrl - isdigit - isgraph - isspace - isxdigit

isspace

[编辑 | 编辑源代码]
语法 
#include <cctype>
int isspace( int ch );

如果函数 isspace() 的参数是某种空格（即单个空格、制表符、垂直制表符、换页符、回车符或换行符），则返回非零值。否则，返回零。

相关主题
isalnum - isalpha - iscntrl - isdigit - isgraph - isprint - ispunct - isxdigit

isupper

[编辑 | 编辑源代码]
语法 
#include <cctype>
int isupper( int ch );

如果函数 isupper() 的参数是大写字母，则返回非零值。否则，返回零。

相关主题
islower - tolower

isxdigit

[编辑 | 编辑源代码]
语法 
#include <cctype>
int isxdigit( int ch );

如果函数 isxdigit() 的参数是十六进制数字（即 A-F、a-f 或 0-9），则返回非零值。否则，返回零。

相关主题
isalnum - isalpha - iscntrl - isdigit - isgraph - ispunct - isspace

memchr

[编辑 | 编辑源代码]
语法 
#include <cstring>
void *memchr( const void *buffer, int ch, size_t count );

函数 memchr() 在由 buffer 指向的数组中查找 count 个字符中 ch 的第一次出现。返回值指向 ch 的第一次出现的地址，或者如果未找到 ch 则为 NULL。例如

char names[] = "Alan Bob Chris X Dave";
if( memchr(names,'X',strlen(names)) == NULL )
  printf( "Didn't find an X\n" );
else
  printf( "Found an X\n" );
相关主题
memcmp - memcpy - strstr

memcmp

[编辑 | 编辑源代码]
语法 
#include <cstring>
int memcmp( const void *buffer1, const void *buffer2, size_t count );

函数 memcmp() 比较 buffer1 和 buffer2 的前 count 个字符。返回值如下

返回值 说明
小于 0 buffer1 小于 buffer2
等于 0 buffer1 等于 buffer2
大于 0 buffer1 大于 buffer2
相关主题
memchr - memcpy - memset - strcmp

memcpy

[编辑 | 编辑源代码]
语法 
#include <cstring>
void *memcpy( void *to, const void *from, size_t count );

函数 memcpy() 将 from 数组中的 count 个字符复制到 to 数组中。memcpy() 的返回值为 to。如果 to 和 from 重叠，则 memcpy() 的行为未定义。

相关主题
memchr - memcmp - memmove - memset - strcpy - strlen - strncpy

memmove

[编辑 | 编辑源代码]
语法 
#include <cstring>
void *memmove( void *to, const void *from, size_t count );

memmove() 函数与 memcpy() 函数相同，区别在于它即使在 to 和 from 发生重叠时也能正常工作。

相关主题
memcpy - memset

memset

[编辑 | 编辑源代码]
语法 
#include <cstring>
void* memset( void* buffer, int ch, size_t count );

memset() 函数将 ch 复制到 buffer 的前 count 个字符中，并返回 buffer。memset() 用于将一块内存初始化为某个值。例如，以下命令

const int ARRAY_LENGTH;
char the_array[ARRAY_LENGTH];
...
// zero out the contents of the_array
memset( the_array, '\0', ARRAY_LENGTH );

...是将 the_array 的所有值设置为零的一种非常有效的方法。

下表比较了两种不同的字符数组初始化方法：for 循环与 memset()。随着初始化数据大小的增加，memset() 显然可以更快地完成工作。

输入大小 使用 for 循环初始化 使用 memset() 初始化
1000 0.016 0.017
10000 0.055 0.013
100000 0.443 0.029
1000000 4.337 0.291
相关主题
memcmp - memcpy - memmove

strcat

[编辑 | 编辑源代码]
语法 
#include <cstring>
char *strcat( char *str1, const char *str2 );

strcat() 函数将 str2 连接到 str1 的末尾，并返回 str1。例如

printf( "Enter your name: " );
scanf( "%s", name );
title = strcat( name, " the Great" );
printf( "Hello, %s\n", title );  ;

请注意，strcat() 不执行边界检查，因此有可能会覆盖 str1 或 str2。对于具有边界检查的类似（更安全）函数，请参见 strncat()。


相关主题
strchr - strcmp - strcpy - strncat

strchr

[编辑 | 编辑源代码]
语法 
#include <cstring>
char *strchr( const char *str, int ch );

strchr() 函数返回指向 str 中 ch 第一次出现的指针，如果未找到 ch 则返回 NULL。

相关主题
strcat - strcmp - strcpy - strlen - strncat - strncmp - strncpy - strpbrk - strrchr -strspn - strstr - strtok

strcmp

[编辑 | 编辑源代码]
语法 
#include <cstring>
int strcmp( const char *str1, const char *str2 );

strcmp() 函数比较 str1 和 str2，然后返回

返回值 说明
小于 0 str1 小于 str2
等于 0 str1 等于 str2
大于 0 str1 大于 str2

例如

printf( "Enter your name: " );
scanf( "%s", name );
if( strcmp( name, "Mary" ) == 0 ) {
  printf( "Hello, Dr. Mary!\n" );
}

请注意，如果 str1 或 str2 缺少空终止符，则 strcmp() 可能无法生成有效结果。对于具有显式边界检查的类似（更安全）函数，请参见 strncmp()。

相关主题
memcmp - strcat - strchr - strcoll - strcpy - strlen - strncmp - strxfrm

strcoll

[编辑 | 编辑源代码]
语法 
#include <cstring>
int strcoll( const char *str1, const char *str2 );

strcoll() 函数比较 str1 和 str2，类似于 strcmp()。但是，strcoll() 使用由（标准 C 日期和时间）setlocale() 函数指定的区域设置执行比较。

相关主题
strcmp - strxfrm
(标准 C 日期和时间) setlocale

strcpy

[编辑 | 编辑源代码]
语法 
#include <cstring>
char *strcpy( char *to, const char *from );

strcpy() 函数将字符串 'from 中的字符复制到字符串 to 中，包括空终止符。返回值为 to。

请注意，strcpy() 不执行边界检查，因此有可能会覆盖 from 或 to。对于具有边界检查的类似（更安全）函数，请参见 strncpy()。

相关主题
memcpy - strcat - strchr - strcmp - strncmp - strncpy

strcspn

[编辑 | 编辑源代码]
语法 
#include <cstring>
size_t strcspn( const char *str1, const char *str2 );

strcspn() 函数返回 str1 中第一个与 str2 中任何字符匹配的字符的索引。

相关主题
strpbrk - strrchr - strstr - strtok

strerror

[编辑 | 编辑源代码]
语法 
#include <cstring>
char *strerror( int num );

strerror() 函数返回与 num 对应的实现定义的字符串。如果发生错误，则错误位于全局变量 errno 中。

相关主题
perror

strlen

[编辑 | 编辑源代码]
语法 
#include <cstring>
size_t strlen( char *str );

strlen() 函数返回str的长度（由空字符终止符之前的字符数决定）。

相关主题
memcpy - strchr - strcmp - strncmp

strncat

[edit | edit source]
语法 
#include <cstring>
char *strncat( char *str1, const char *str2, size_t count );

strncat() 函数将最多count个str2的字符连接到str1上，并添加一个空字符终止符。返回结果字符串。

相关主题
strcat - strchr - strncmp - strncpy

strncmp

[edit | edit source]
语法 
#include <cstring>
int strncmp( const char *str1, const char *str2, size_t count );

strncmp() 函数最多比较str1和str2的count个字符。返回值如下

返回值 说明
小于 0 str1 小于 str2
等于 0 str1 等于 str2
大于 0 str1 大于 str2

如果任一字符串中的字符数少于count，则比较将在遇到第一个空字符终止符后停止。

相关主题
strchr - strcmp - strcpy - strlen - strncat - strncpy

strncpy

[edit | edit source]
语法 
#include <cstring>
char *strncpy( char *to, const char *from, size_t count );

strncpy() 函数将最多count个from的字符复制到字符串to中。只有当from中的字符数少于count时，才会用 '\0' 字符填充剩余部分。return值是结果字符串。

注意
使用未用 '\0' 字符填充的字符串会造成安全漏洞。

相关主题
memcpy - strchr - strcpy - strncat - strncmp

strpbrk

[edit | edit source]
语法 
#include <cstring>
char * strpbrk( const char *str, const char *ch );

strpbrk() 函数返回指向str中ch中任一字符的首次出现的指针，如果未找到任何字符，则返回NULL。

相关主题
strchr - strrchr - strstr

strrchr

[edit | edit source]
语法 
#include <cstring>
char *strrchr( const char *str, int ch );

strrchr() 函数返回指向str中ch的最后一次出现的指针，如果未找到匹配项，则返回NULL。

相关主题
strchr - strcspn - strpbrk - strspn - strstr - strtok

strspn

[edit | edit source]
语法 
#include <cstring>
size_t strspn( const char *str1, const char *str2 );

strspn() 函数返回str1中第一个不匹配str2中任何字符的字符的索引。

相关主题
strchr - strpbrk - strrchr - strstr - strtok

strstr

[edit | edit source]
语法 
#include <cstring>
char *strstr( const char *str1, const char *str2 );

strstr() 函数返回指向str1中str2首次出现的指针，如果未找到匹配项，则返回NULL。如果str2的长度为零，则 strstr() 将简单地返回str1。

例如，以下代码检查一个字符串中是否存在另一个字符串

JHJH-C´(J"JC 

char* str1 = "this is a string of characters   <tr>hai</tr>";
char* str2 = "hai";
char* result = strstr( str1, str2 );
if( result == NULL ) printf( "Could not find '%s' in '%s'\n", str2, str1 );
  else printf( "Found a substring: '%s'\n", result );

运行后，以上代码显示以下输出

 Found a substring: 'a string of characters'
相关主题
memchr - strchr - strcspn - strpbrk - strrchr - strspn - strtok

strtod

[edit | edit source]
语法 
#include <cstdlib>
double strtod( const char *start, char **end );

strtod() 函数将start中首先遇到的任何内容作为双精度浮点数返回。end被设置为指向start中该双精度浮点数之后剩余的任何内容。如果发生溢出，strtod() 将返回HUGE_VAL或-HUGE_VAL。

x = strtod( "42.0is_the_answer" );

会导致 x 被设置为 42.0。

相关主题
atof

strtok

[edit | edit source]
语法 
#include <cstring>
char *strtok( char *str1, const char *str2 );

strtok() 函数返回指向str1中下一个“标记”的指针，其中str2包含确定标记的分隔符。如果未找到标记，则 strtok() 返回NULL。为了将字符串转换为标记，对 strtok() 的第一次调用应该让str1指向要标记的字符串。此后的所有调用都应该让str1为NULL。

例如

char str[] = "now # is the time for all # good men to come to the # aid of their country";
char delims[] = "#";
char *result = NULL;
result = strtok( str, delims );
while( result != NULL ) {
  printf( "result is \"%s\"\n", result );
  result = strtok( NULL, delims );
}

以上代码将显示以下输出

 result is "now "
 result is " is the time for all "
 result is " good men to come to the "
 result is " aid of their country"
相关主题
strchr - strcspn - strpbrk - strrchr - strspn - strstr

strtol

[编辑 | 编辑源代码]
语法 
#include <cstdlib>
long strtol( const char *start, char **end, int base );

strtol() 函数返回start中遇到的第一个元素作为长整型，必要时进行base进制转换。end指向start中长整型之后的剩余部分。如果结果不能用长整型表示，则 strtol() 返回LONG_MAX或LONG_MIN。错误情况下返回零。

相关主题
atol - strtoul

strtoul

[编辑 | 编辑源代码]
语法 
#include <cstdlib>
unsigned long strtoul( const char *start, char **end, int base );

strtoul() 函数的行为与strtol()完全相同，只是它返回一个unsigned长整型，而不是一个普通的长整型。

相关主题
strtol

strxfrm

[编辑 | 编辑源代码]
语法 
#include <cstring>
size_t strxfrm( char *str1, const char *str2, size_t num );

strxfrm() 函数操作str2的前num个字符，并将它们存储在str1中。结果是这样的，如果对str1和旧的str2执行strcoll()，你将获得与strcmp()相同的结果。

相关主题
strcmp - strcoll

tolower

[编辑 | 编辑源代码]
语法 
#include <cctype>
int tolower( int ch );

tolower() 函数返回字符ch的小写版本。

相关主题
isupper - toupper

toupper

[编辑 | 编辑源代码]
语法 
#include <cctype>
int toupper( int ch );

toupper() 函数返回字符ch的大写版本。

相关主题
tolower
检索自"https://wikibooks.cn/w/index.php?title=C%2B%2B_Programming/Code/Standard_C_Library/String_%26_Character&oldid=3676592"
华夏公益教科书