开发语言-C

C语言函数大全--w 开头的函数（3）

总览

函数声明 函数功能
wchar_t *wcsdup(const wchar_t *str); 用于复制宽字符字符串
int wcsicmp(const wchar_t *s1, const wchar_t *s2); 用于比较两个宽字符字符串的大小写不敏感的差异
int wcsicoll(const wchar_t *s1, const wchar_t *s2); 用于比较两个宽字符字符串的大小写不敏感的差异, 并考虑当前本地环境的语言和排序规则
wchar_t *wcslwr(wchar_t *str); 用于将宽字符字符串转换为小写字母形式
wchar_t *wcspbrk(const wchar_t *str, const wchar_t *charset); 用于在宽字符字符串中查找指定字符集中任意一个字符第一次出现的位置
int wcsnicmp(const wchar_t *s1, const wchar_t *s2, size_t n); 用于比较两个宽字符字符串的前若干个字符的大小写不敏感的差异
wchar_t *wcsnset(wchar_t *str, wchar_t ch, size_t n); 用于将宽字符字符串中的前若干个字符设置为指定字符
wchar_t *wcsrev(wchar_t *str); 用于将宽字符字符串反转
wchar_t *wcsset(wchar_t *str, wchar_t ch); 用于将宽字符字符串中的所有字符设置为指定字符
long int wcstoll(const wchar_t* str, wchar_t** endptr, int base); 用于将宽字符串转换为长整形
unsigned long long int wcstoull(const wchar_t* str, wchar_t** endptr, int base); 用于将宽字符串转换为无符号长整型
wchar_t* wcsupr(wchar_t* str); 用于将宽字符串转换为大写
wctrans_t wctrans(const char* property); 用于创建字符转换描述符
wchar_t* wmempcpy(wchar_t* dest, const wchar_t* src, size_t n); 用于将将源宽字符串的前 n 个字节的内容拷贝到目标字符串中
wchar_t* wmemmove(wchar_t* dest, const wchar_t* src, size_t n); 将源宽字符串中指定数量的字节复制到目标宽字符串中，即使目标内存和源内存重叠

1. wcsdup

1.1 函数说明

函数声明 函数功能
wchar_t *wcsdup(const wchar_t *str); 用于复制宽字符字符串

参数：

  • str ： 待复制的宽字符串

返回值：

  • 如果成功复制，则返回指向该内存块的指针；
  • 如果内存分配失败，函数将返回 NULL。

1.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
#include <stdio.h>
#include <stdlib.h>
#include <wchar.h>

int main(void)
{
    // 宽字符字符串 "Hello, world!"
    const wchar_t *ws = L"Hello, world!";

    // 复制宽字符字符串
    wchar_t *ws_copy = wcsdup(ws);

    if (ws_copy == NULL)
    {
        fprintf(stderr, "Error: Failed to allocate memory.\n");
        return 1;
    }

    // 输出原始和副本字符串
    wprintf(L"Original string: %ls\n", ws);
    wprintf(L"Copy: %ls\n", ws_copy);
    // 释放由 wcsdup() 函数分配的内存空间
    free(ws_copy);

    return 0;
}

1.3 运行结果

2. wcsicmp

2.1 函数说明

函数声明 函数功能
int wcsicmp(const wchar_t *s1, const wchar_t *s2); 用于比较两个宽字符字符串的大小写不敏感的差异

参数：

  • s1 ： 待比较的宽字符串1
  • s2 ： 待比较的宽字符串2

返回值：

  • 如果 s1 指向的字符串按字典顺序小于 s2 指向的字符串（忽略大小写），则函数返回一个负整数；
  • 如果 s1 等于 s2，则函数返回 0；
  • 如果 s1 指向的字符串按字典顺序大于 s2 指向的字符串（忽略大小写），则函数返回一个正整数。

2.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
#include <stdio.h>
#include <wchar.h>

int main(void)
{
    // 宽字符字符串 "Hello, huazie!"
    const wchar_t *ws1 = L"Hello, huazie!";

    // 宽字符字符串 "hello, HUAZIE!"
    const wchar_t *ws2 = L"hello, HUAZIE!";

    int cmp_result = wcsicmp(ws1, ws2);

    // 输出比较结果
    if (cmp_result < 0)
    {
        wprintf(L"%ls is less than %ls.\n", ws1, ws2);
    }
    else if (cmp_result == 0)
    {
        wprintf(L"%ls is equal to %ls.\n", ws1, ws2);
    }
    else
    {
        wprintf(L"%ls is greater than %ls.\n", ws1, ws2);
    }

    return 0;
}

2.3 运行结果

3. wcsicoll

3.1 函数说明

函数声明 函数功能
int wcsicoll(const wchar_t *s1, const wchar_t *s2); 用于比较两个宽字符字符串的大小写不敏感的差异, 并考虑当前本地环境的语言和排序规则

参数：

  • s1 ： 待比较的宽字符串1
  • s2 ： 待比较的宽字符串2

返回值：

  • 如果 s1 指向的字符串按字典顺序小于 s2 指向的字符串（忽略大小写），则函数返回一个负整数；
  • 如果 s1 等于 s2，则函数返回 0；
  • 如果 s1 指向的字符串按字典顺序大于 s2 指向的字符串（忽略大小写），则函数返回一个正整数。

3.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
#include <stdio.h>
#include <wchar.h>
#include <locale.h>

int main(void)
{
    // 设置本地环境
    setlocale(LC_ALL, "");

    // 宽字符字符串 "Hello, world!"
    const wchar_t *ws1 = L"Hello, huazie!";

    // 宽字符字符串 "hello, WORLD!"
    const wchar_t *ws2 = L"hello, HUAZIE!";

    int cmp_result = wcsicoll(ws1, ws2);

    // 输出比较结果
    if (cmp_result < 0)
    {
        wprintf(L"%ls is less than %ls.\n", ws1, ws2);
    }
    else if (cmp_result == 0)
    {
        wprintf(L"%ls is equal to %ls.\n", ws1, ws2);
    }
    else
    {
        wprintf(L"%ls is greater than %ls.\n", ws1, ws2);
    }

    return 0;
}

注意： 在使用 wcsicoll() 函数前，需要先调用 setlocale() 函数设置本地环境。

3.3 运行结果

4. wcslwr

4.1 函数说明

函数声明 函数功能
wchar_t *wcslwr(wchar_t *str); 用于将宽字符字符串转换为小写字母形式

参数：

  • str ： 待转换的宽字符串

4.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#include <stdio.h>
#include <wchar.h>

int main(void)
{
    // 宽字符字符串 "Hello, HUAZIE!"
    wchar_t ws[] = L"Hello, HUAZIE!";

    // 将字符串转换为小写字母形式
    wcslwr(ws);

    // 输出转换后的字符串
    wprintf(L"%ls\n", ws);

    return 0;
}

4.3 运行结果

5. wcspbrk

5.1 函数说明

函数声明 函数功能
wchar_t *wcspbrk(const wchar_t *str, const wchar_t *charset); 用于在宽字符字符串中查找指定字符集中任意一个字符第一次出现的位置

参数：

  • str ： 要搜索的宽字符字符串
  • charset ： 要搜索的宽字符集合

wcspbrk() 函数会将 str 指向的宽字符字符串中的每个字符与 charset 指向的宽字符集合中的字符进行比较，直到找到其中任意一个相同的字符为止。
返回值：

  • 如果找到了这样的字符，则函数返回指向该字符的指针；
  • 否则，函数返回 NULL。

5.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#include <stdio.h>
#include <wchar.h>

int main(void)
{
    // 宽字符字符串 "Hello, huazie!"
    const wchar_t *ws = L"Hello, huazie!";

    // 查找第一个出现在 "abcd" 中的字符
    wchar_t *result = wcspbrk(ws, L"abcd");

    if (result == NULL)
    {
        wprintf(L"No matching character found.\n");
    }
    else
    {
        wprintf(L"First matching character: %lc\n", *result);
    }

    return 0;
}

5.3 运行结果

6. wcsnicmp

6.1 函数说明

函数声明 函数功能
int wcsnicmp(const wchar_t *s1, const wchar_t *s2, size_t n); 用于比较两个宽字符字符串的前若干个字符的大小写不敏感的差异

参数：

  • s1 ： 待比较的宽字符串1
  • s2 ： 待比较的宽字符串2
  • n ： 要比较的字符数目

返回值：

  • 如果 s1 指向的字符串按字典顺序小于 s2 指向的字符串（忽略大小写），则函数返回一个负整数；
  • 如果 s1 等于 s2，则函数返回 0；
  • 如果 s1 指向的字符串按字典顺序大于 s2 指向的字符串（忽略大小写），则函数返回一个正整数。

6.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
#include <stdio.h>
#include <wchar.h>

int main(void)
{
    // 宽字符字符串 "Hello, huazie!"
    const wchar_t *ws1 = L"Hello, huazie!";

    // 宽字符字符串 "HELLO, HUAZIE!"
    const wchar_t *ws2 = L"HELLO, HUAZIE!";

    int cmp_result = wcsnicmp(ws1, ws2, 5);

    // 输出比较结果
    if (cmp_result < 0)
    {
        wprintf(L"%ls is less than %ls.\n", ws1, ws2);
    }
    else if (cmp_result == 0)
    {
        wprintf(L"%ls is equal to %ls.\n", ws1, ws2);
    }
    else
    {
        wprintf(L"%ls is greater than %ls.\n", ws1, ws2);
    }

    return 0;
}

6.3 运行结果

7. wcsnset

7.1 函数说明

函数声明 函数功能
wchar_t *wcsnset(wchar_t *str, wchar_t ch, size_t n); 用于将宽字符字符串中的前若干个字符设置为指定字符

参数：

  • s1 ： 要修改的宽字符字符串
  • s2 ： 要设置的宽字符
  • n ： 要设置的宽字符数目

7.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#include <stdio.h>
#include <wchar.h>

int main(void)
{
    // 宽字符字符串 "Hello, huazie!"
    wchar_t ws[] = L"Hello, huazie!";

    // 将前五个字符设置为 '*'
    wcsnset(ws, L'*', 5);

    // 输出修改后的字符串
    wprintf(L"%ls\n", ws);

    return 0;
}

7.3 运行结果

8. wcsrev

8.1 函数说明

函数声明 函数功能
wchar_t *wcsrev(wchar_t *str); 用于将宽字符字符串反转

参数：

  • s1 ： 要反转的宽字符字符串

8.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#include <stdio.h>
#include <wchar.h>

int main(void)
{
    // 宽字符字符串 "Hello, huazie!"
    wchar_t ws[] = L"Hello, huazie!";

    // 反转字符串
    wcsrev(ws);

    // 输出反转后的字符串
    wprintf(L"%ls\n", ws);

    return 0;
}

8.3 运行结果

9. wcsset

9.1 函数说明

函数声明 函数功能
wchar_t *wcsset(wchar_t *str, wchar_t ch); 用于将宽字符字符串中的所有字符设置为指定字符

参数：

  • str ： 要修改的宽字符字符串
  • ch ： 要设置的宽字符

9.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#include <stdio.h>
#include <wchar.h>

int main(void)
{
    // 宽字符字符串 "Hello, huazie!"
    wchar_t ws[] = L"Hello, huazie!";

    // 输出修改前的字符串
    wprintf(L"Before: %ls\n", ws);

    // 将字符串中的每个字符都设置为 '#'
    wcsset(ws, L'#');

    // 输出修改后的字符串
    wprintf(L"After : %ls\n", ws);

    return 0;
}

注意： wcsset() 函数会修改原始字符串，因此需要在操作前确保原始字符串可以被修改。

9.3 运行结果

10. wcstoll

10.1 函数说明

函数声明 函数功能
long int wcstoll(const wchar_t* str, wchar_t** endptr, int base); 用于将宽字符串转换为长整形

参数：

  • str ： 要转换成长整型的宽字符串
  • endptr ： 一个指向指针的指针，可用于检测是否发生了转换错误，并且返回第一个无法被识别的宽字符位置。当该值为 nullptr 时，不会返回无法被识别的宽字符位置
  • base ： 进制数，默认为 10

10.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#include <stdio.h>
#include <stdlib.h>
#include <wchar.h>

int main() 
{
    const wchar_t* str = L"123456789";
    //const wchar_t* str = L"12345a6789";
    //const wchar_t* str = L"a123456789";
    wchar_t* endptr;
    long int num;

    num = wcstoll(str, &endptr, 10);

    wprintf(L"The number is %ld\n", num);

    return 0;
}

10.3 运行结果

11. wcstoull

11.1 函数说明

函数声明 函数功能
unsigned long long int wcstoull(const wchar_t* str, wchar_t** endptr, int base); 用于将宽字符串转换为无符号长整型

参数：

  • str ： 要转换成无符号长整型的宽字符串
  • endptr ： 一个指向指针的指针，可用于检测是否发生了转换错误，并且返回第一个无法被识别的宽字符位置。当该值为 nullptr 时，不会返回无法被识别的宽字符位置
  • base ： 进制数，默认为 10

11.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#include <stdio.h>
#include <stdlib.h>
#include <wchar.h>

int main() 
{
    const wchar_t* str = L"123456789";
    //const wchar_t* str = L"12345a6789";
    //const wchar_t* str = L"a123456789";
    wchar_t* endptr;
    unsigned long long int num;

    num = wcstoull(str, &endptr, 10);

    wprintf(L"The number is %llu\n", num);

    return 0;
}

wcstoull() 函数的用法和 wcstoll() 函数类似，不再赘述了。

11.3 运行结果

12. wcsupr

12.1 函数说明

函数声明 函数功能
wchar_t* wcsupr(wchar_t* str); 用于将宽字符串转换为大写

参数：

  • str ： 要转换为大写的宽字符串

12.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#include <stdio.h>
#include <wchar.h>

int main(void)
{
    // 宽字符字符串 "Hello, huazie!"
    wchar_t ws[] = L"Hello, huazie!";

    // 将宽字符串转换为大写字母形式
    wcsupr(ws);

    // 输出转换后的字符串
    wprintf(L"%ls\n", ws);

    return 0;
}

12.3 运行结果

13. wctrans

13.1 函数说明

函数声明 函数功能
wctrans_t wctrans(const char* property); 用于创建字符转换描述符
wint_t towctrans(wint_t wc, wctrans_t desc); 通过 wctrans() 函数创建的字符转换描述符，可以将一个字符或字符串进行指定类型的转换。

wctrans 参数：

  • property ： 转换属性名称

towctrans 参数：

  • wc ： 待转换的字符
  • desc ： 转换描述符

13.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#include <stdio.h>
#include <wctype.h>
#include <wchar.h>

int main() {
    // 创建一个转换描述符，用于将小写字母转换为大写字母
    wctrans_t to_upper = wctrans("toupper");

    // 使用转换描述符将 wchar_t 类型字符串中的所有小写字母转换为大写字母
    wchar_t str[] = L"hello huazie";
    for (int i = 0; str[i] != L'\0'; i++) {
        str[i] = towctrans(str[i], to_upper);
    }

    // 输出结果："HELLO WORLD"
    wprintf(L"%ls\n", str);

    return 0;
}

13.3 运行结果

14. wmempcpy

14.1 函数说明

函数声明 函数功能
wchar_t* wmempcpy(wchar_t* dest, const wchar_t* src, size_t n); 用于将将源宽字符串的前 n 个字节的内容拷贝到目标字符串中

参数：

  • dest ： 目标宽字符串
  • src ： 源宽字符串
  • n ： 要拷贝的字节数

14.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#include <stdio.h>
#include <wchar.h>
#include <string.h>

int main() 
{
    const wchar_t* src = L"Hello, Huazie!";
    wchar_t dest[20];

    wprintf(L"Original string: %ls\n", src);

    // 将源字符串内容拷贝到目标字符串中
    wchar_t* ptr = wmempcpy(dest, src, wcslen(src) * sizeof(wchar_t));
    *ptr = L'\0';

    wprintf(L"Copied string: %ls\n", dest);

    return 0;
}

14.3 运行结果

15. wmemmove

15.1 函数说明

函数声明 函数功能
wchar_t* wmemmove(wchar_t* dest, const wchar_t* src, size_t n); 将源宽字符串中指定数量的字节复制到目标宽字符串中，即使目标内存和源内存重叠

参数：

  • dest ： 目标宽字符串
  • src ： 源宽字符串
  • n ： 要移动的字节数

15.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#include <stdio.h>
#include <wchar.h>
#include <string.h>

int main() 
{
    wchar_t str[30] = L"Hello, Huazie!";

    wprintf(L"Original string: %ls\n", str);

    // 将字符串中前5个字符移动到后面
    wmemmove(str + 6, str, 5 * sizeof(wchar_t));

    wprintf(L"Moved string: %ls\n", str);

    return 0;
}

15.3 运行结果

开发语言-C

C语言函数大全--w 开头的函数（2）

总览

函数声明 函数功能
wchar_t *wcstok(wchar_t *wcs, const wchar_t *delim, wchar_t **ptr); 用于将一个长字符串拆分成几个短字符串（标记），并返回第一个标记的地址
wchar_t *wcstok(wchar_t *wcs, const wchar_t *delim); 用于将一个长字符串拆分成几个短字符串（标记），并返回第一个标记的地址
long int wcstol(const wchar_t* str, wchar_t** endptr, int base); 用于将字符串转换为长整型数字的函数
unsigned long int wcstoul(const wchar_t* str, wchar_t** endptr, int base); 用于将字符串转换为无符号长整型数字
size_t wcsxfrm(wchar_t* dest, const wchar_t* src, size_t n); 将一个 Unicode 字符串转换为一个 “可排序” 的字符串。该新字符串中的字符序列反映了源字符串中的字符顺序和大小写信息，以便进行字典序比较。
wctype_t wctype(const char* property); 用于确定给定的宽字符类别
int wctob(wint_t wc); 用于将给定的宽字符转换为其对应的字节表示
int wctomb(char* s, wchar_t wc); 用于将给定的宽字符转换为其对应的多字节字符表示
void* wmemchr(const void* s, wchar_t c, size_t n); 用于在宽字符数组中查找给定的宽字符
int wmemcmp(const wchar_t* s1, const wchar_t* s2, size_t n); 用于比较两个宽字符数组的前 n 个宽字符
wchar_t* wmemcpy(wchar_t* dest, const wchar_t* src, size_t n); 用于将一个宽字符数组的前 n 个宽字符复制到另一个宽字符数组
wchar_t* wmemset(wchar_t* s, wchar_t c, size_t n); 用于将一个宽字符数组的前 n 个宽字符设置为给定的宽字符值
int wprintf(const wchar_t* format, ...); 用于格式化输出宽字符字符串
ssize_t write(int fd, const void* buf, size_t count); 用于将数据写入文件描述符
int wscanf(const wchar_t* format, ...); 用于从标准输入流（stdin）读取格式化的宽字符输入

1. wcstok

1.1 函数说明

函数声明 函数功能
wchar_t *wcstok(wchar_t *wcs, const wchar_t *delim, wchar_t **ptr); 用于将一个长字符串拆分成几个短字符串（标记），并返回第一个标记的地址
wchar_t *wcstok(wchar_t *wcs, const wchar_t *delim); 用于将一个长字符串拆分成几个短字符串（标记），并返回第一个标记的地址

参数：

  • wcs ： 被分割的字符串
  • delim ： 分割符字符串，包含多个字符
  • ptr ： 指向保存上次调用后的指针的指针，首次调用时需赋值为 NULL

1.2 演示示例

windows 下两个参数的示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#include <wchar.h>
#include <stdio.h>

int main() {
    wchar_t str[] = L"Hello, huazie! This is wcstok demo.";
    wchar_t* token;

    // 第一次调用
    token = wcstok(str, L" ,.!?");
    while (token != NULL) 
    {
        wprintf(L"%ls\n", token);
        token = wcstok(NULL, L" ,.!?");
    }

    return 0;
}

1.3 运行结果

2. wcstol

2.1 函数说明

函数声明 函数功能
long int wcstol(const wchar_t* str, wchar_t** endptr, int base); 用于将字符串转换为长整型数字的函数

参数：

  • str ： 要转换的字符串
  • endptr ： 可选输出参数，指向第一个不能转换成数字字符的字符的指针
  • base ： 数字基数，介于 2 和 36 之间；
    当 base 参数为 0 时，wcstol() 函数会自动检测数字基数：
    • 如果输入字符串以 "0x" 或 "0X" 开头，则将基数设置为 16。
    • 如果输入字符串以 "0" 开头，则将基数设置为 8。
    • 如果不是这些情况，则将基数设置为 10。

2.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#include <stdio.h>
#include <stdlib.h>
#include <wchar.h>

int main() 
{
    //const wchar_t* str = L"123456";
    //const wchar_t* str = L"123a456";
    //const wchar_t* str = L"a123456";
    const wchar_t* str = L"0xFF";
    wchar_t* endptr;
    long int num;

    //num = wcstol(str, &endptr, 10);
    num = wcstol(str, &endptr, 0);
    if (endptr == str)
        printf("Invalid input.\n");
    else
        printf("The number is %ld\n", num);

    return 0;
}

注意： 如果输入字符串无法转换为数字，则 wcstol() 函数返回 0，并将 endptr 指向输入字符串的起始位置。所以，在使用 wcstol() 函数时，建议检查 endptr 和 str 是否相同，以确定输入是否有效。

2.3 运行结果




3. wcstoul

3.1 函数说明

函数声明 函数功能
unsigned long int wcstoul(const wchar_t* str, wchar_t** endptr, int base); 用于将字符串转换为无符号长整型数字

参数：

  • str ： 要转换的字符串
  • endptr ： 可选输出参数，指向第一个不能转换成数字字符的字符的指针
  • base ： 数字基数，介于 2 和 36 之间；
    当 base 参数为 0 时，wcstol() 函数会自动检测数字基数：
    • 如果输入字符串以 "0x" 或 "0X" 开头，则将基数设置为 16。
    • 如果输入字符串以 "0" 开头，则将基数设置为 8。
    • 如果不是这些情况，则将基数设置为 10。

3.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#include <stdio.h>
#include <stdlib.h>
#include <wchar.h>

int main() 
{
    const wchar_t* str = L"123a456";
    wchar_t* endptr;
    unsigned long int num;

    num = wcstoul(str, &endptr, 10);
    if (endptr == str)
        printf("Invalid input.\n");
    else
        printf("The number is %lu\n", num);

    return 0;
}

wcstoul() 函数的用法和 wcstol() 函数类似，这里就不一一列举了

3.3 运行结果

4. wcsxfrm

4.1 函数说明

函数声明 函数功能
size_t wcsxfrm(wchar_t* dest, const wchar_t* src, size_t n); 将一个 Unicode 字符串转换为一个 “可排序” 的字符串。该新字符串中的字符序列反映了源字符串中的字符顺序和大小写信息，以便进行字典序比较。

参数：

  • dest ： 存储转换后字符串的目标缓冲区
  • src： 要转换的源字符串
  • n ： 目标缓冲区的最大长度

4.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
#include <stdlib.h>
#include <stdio.h>
#include <wchar.h>

#define ARRAY_SIZE 5

int main() 
{
    const wchar_t* arr[ARRAY_SIZE] = { L"Tom", L"Alice", L"Huazie", L"David", L"Charlie" };
    wchar_t sorted_arr[ARRAY_SIZE][50];
    size_t i;

    for (i = 0; i < ARRAY_SIZE; i++) 
    {
        wcsxfrm(sorted_arr[i], arr[i], sizeof(sorted_arr[i]));
    }

    // 使用 qsort 对字符串数组排序
    qsort(sorted_arr, ARRAY_SIZE, sizeof(sorted_arr[0]), wcscmp);

    // 排序后输出
    wprintf(L"Sorted array:\n");
    for (i = 0; i < ARRAY_SIZE; i++) 
    {
        wprintf(L"%ls\n", sorted_arr[i]);
    }

    return 0;
}

在上面的示例代码中，

  • 首先，我们定义一个包含 5 个 Unicode 字符串的字符串数组 arr，每个字符串代表一个人名；
  • 然后，定义一个大小为 5x50 的二维字符数组 sorted_arr，用于存储排序后的字符串；
  • 接着，使用 wcsxfrm() 函数将每个 Unicode 字符串转换为可排序字符串，并将结果存储在 sorted_arr 数组中；
  • 再然后，使用 qsort() 函数按字典序对 sorted_arr 数组中的字符串进行排序；
  • 再接着，使用 wprintf() 函数输出排序后的字符串；
  • 最后结束程序。

4.3 运行结果

5. wctype

5.1 函数说明

函数声明 函数功能
wctype_t wctype(const char* property); 用于确定给定的宽字符类别

参数：

  • property ： 一个指向表示宽字符属性名称的字符串字面量的指针

常见的宽字符属性及含义如下：

属性名称 含义
"alnum" 字母数字字符
"alpha" 字母字符
"blank" 空格或水平制表符字符
"cntrl" 控制字符
"digit" 数字字符
"graph" 可打印字符（除空格字符外）
"lower" 小写字母字符
"print" 可打印字符
"punct" 标点符号字符
"space" 空白字符
"upper" 大写字母字符
"xdigit" 十六进制数字字符

返回值：

  • 如果指定的属性存在，则返回相应的宽字符类型；
  • 如果指定的属性不存在，则返回零。

5.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#include <stdio.h>
#include <wchar.h>
#include <wctype.h>

int main() 
{
    wchar_t ch = L',';
    wctype_t punct_wt;

    // 获取标点符号字符类型
    punct_wt = wctype("punct");

    // 判断指定的宽字符是否为标点符号
    if (iswctype(ch, punct_wt)) {
        wprintf(L"%lc is a punctuation character.\n", ch);
    } else {
        wprintf(L"%lc is not a punctuation character.\n", ch);
    }

    return 0;
}

注意： 在调用 wctype() 函数时，应该传递一个有效的宽字符属性名称作为参数，详见 5.1 的表格所示。

5.3 运行结果

6. wctob

6.1 函数说明

函数声明 函数功能
int wctob(wint_t wc); 用于将给定的宽字符转换为其对应的字节表示

参数：

  • wc ： 一个宽字符值

返回值：

  • 如果能转换成功，则返回返回与之对应的字节表示；
  • 如果无法将给定宽字符转换为字节表示，则返回 EOF。

6.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#include <stdio.h>
#include <wchar.h>

int main() 
{
    wchar_t ch = L'?';
    int byte;

    // 将 Unicode 字符转换为字节表示
    byte = wctob(ch);

    // 输出字节值
    printf("Byte value of %lc: %d (0x%02X)\n", ch, byte, byte);

    return 0;
}

注意： 在使用 wctob() 函数时，应该确保系统当前的本地化环境和编码方式与程序中使用的字符编码一致。如果字符编码不一致，可能会导致错误的结果或未定义行为。

6.3 运行结果

7. wctomb

7.1 函数说明

函数声明 函数功能
int wctomb(char* s, wchar_t wc); 用于将给定的宽字符转换为其对应的多字节字符表示

参数：

  • s ： 一个指向字符数组的指针
  • wc ： 一个宽字符值

返回值：

  • 如果能转换成功，则将 wc 转换为其对应的多字节字符表示，存储在 s 指向的字符数组中；
  • 如果 s 是空指针，则不执行任何操作，只返回转换所需的字符数;
  • 如果无法将给定宽字符转换为多字节字符表示，则返回 -1。

7.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
#include <stdio.h>
#include <stdlib.h>
#include <wchar.h>

int main() 
{
    wchar_t ch = L'?';
    char mb[MB_CUR_MAX];
    int len;

    // 将 Unicode 字符转换为多字节字符表示
    len = wctomb(mb, ch);

    // 输出转换结果
    if (len >= 0) 
    {
        printf("Multibyte representation of %lc: ", ch);
        for (int i = 0; i < len; i++) {
            printf("%02X ", (unsigned char) mb[i]);
        }
        printf("\n");
    } 
    else 
    {
        printf("Failed to convert %lc to multibyte character.\n", ch);
    }

    return 0;
}

在上面的示例程序中，wctomb() 函数被用来将 Unicode 字符 ',' 转换为其对应的多字节字符表示，并将结果保存在字符数组 mb 中。然后，程序输出每个字节的十六进制值。

注意： 在使用 wctomb() 函数时，应该根据当前的本地化环境和编码方式调整字符数组的大小。可以使用 MB_CUR_MAX 宏来获取当前编码方式下一个多字节字符所需的最大字节数，从而确定字符数组的大小。

7.3 运行结果

8. wmemchr

8.1 函数说明

函数声明 函数功能
void* wmemchr(const void* s, wchar_t c, size_t n); 用于在宽字符数组中查找给定的宽字符

参数：

  • s ： 一个指向宽字符数组的指针
  • c ： 要查找的宽字符值
  • n ： 要搜索的字节数

返回值：

  • 如果找到了 c，则返回指向该位置的指针；
  • 否则返回空指针。

8.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#include <stdio.h>
#include <wchar.h>

int main() 
{
    const wchar_t str[] = L"Hello, Huazie!";
    const wchar_t ch = L'u';
    wchar_t* pch;

    // 在宽字符数组中查找给定的宽字符
    // 使用 wcslen() 函数来获取 str 的长度，以指定要搜索的字节数 n
    pch = wmemchr(str, ch, wcslen(str));

    // 根据 pch，来判断是否找到，并输出结果
    if (pch)
        wprintf(L"Found '%lc' at position %d.\n", ch, (int)(pch - str));
    else
        wprintf(L"Could not find '%lc'.\n", ch);

    return 0;
}

8.3 运行结果

9. wmemcmp

9.1 函数说明

函数声明 函数功能
int wmemcmp(const wchar_t* s1, const wchar_t* s2, size_t n); 用于比较两个宽字符数组的前 n 个宽字符

参数：

  • s1 ： 待比较的宽字符串1
  • s2 ： 待比较的宽字符串2
  • n ： 要比较的字节数

返回值：

  • 如果两个数组相等，则返回零；
  • 如果 s1 比 s2 小，则返回负数；
  • 如果 s1 比 s2 大，则返回正数。

9.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#include <stdio.h>
#include <wchar.h>

int main() 
{
    const wchar_t str1[] = L"Hello";
    const wchar_t str2[] = L"Huazie";
    int result;

    // 比较两个宽字符数组
    result = wmemcmp(str1, str2, wcslen(str1));

    // 根据result，来判断，并输出结果
    if (result == 0)
        wprintf(L"%ls and %ls are equal.\n", str1, str2);
    else if (result < 0)
        wprintf(L"%ls is less than %ls.\n", str1, str2);
    else
        wprintf(L"%ls is greater than %ls.\n", str1, str2);

    return 0;
}

9.3 运行结果

10. wmemcpy

10.1 函数说明

函数声明 函数功能
wchar_t* wmemcpy(wchar_t* dest, const wchar_t* src, size_t n); 用于将一个宽字符数组的前 n 个宽字符复制到另一个宽字符数组

参数：

  • dest ： 目标宽字符串
  • src ： 源宽字符串
  • n ： 要复制的字节数

10.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#include <stdio.h>
#include <wchar.h>
#include <string.h>

int main() 
{
    const wchar_t src[] = L"Hello, Huazie!";
    wchar_t dest[20];

    // 将一个宽字符数组复制到另一个宽字符数组
    wmemcpy(dest, src, wcslen(src) + 1);

    // 输出结果
    wprintf(L"Source string: %ls\n", src);
    wprintf(L"Destination string: %ls\n", dest);

    return 0;
}

注意： 在使用 wmemcpy() 函数时，应该确保目标数组有足够的空间来存储源数组的内容，以免发生缓冲区溢出。在上面的示例中，我们使用 wcslen() 函数来获取源数组的长度，然后加上 1，以包括字符串结尾的空字符 '\0'。

10.3 运行结果

11. wmemset

11.1 函数说明

函数声明 函数功能
wchar_t* wmemset(wchar_t* s, wchar_t c, size_t n); 用于将一个宽字符数组的前 n 个宽字符设置为给定的宽字符值

参数：

  • s ： 一个指向宽字符数组的指针
  • c ： 要设置的宽字符值
  • n ： 要设置的字节数

11.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#include <stdio.h>
#include <wchar.h>
#include <string.h>

int main() 
{
    wchar_t str[20]= L"Hello Huazie!";

    // 修改前
    wprintf(L"Before: %ls\n", str);

    // 将一个宽字符数组的所有元素设置为给定的宽字符值X
    wmemset(str, L'X', wcslen(str));

    // 修改后
    wprintf(L"After : %ls\n", str);

    return 0;
}

在上面的示例程序中，

  • 首先，我们定义一个宽字符数组 str，并初始化为 "Hello Huazie!";
  • 接着，调用 wprintf() 函数输出修改之前的宽字符数组 str；
  • 然后，调用 wmemset() 函数将宽字符数组 str 的所有元素都设置为 ‘X’;
  • 最后，再调用 wprintf() 函数输出修改之后的宽字符数组 str，并结束程序。

11.3 运行结果

12. wprintf

12.1 函数说明

函数声明 函数功能
int wprintf(const wchar_t* format, ...); 用于格式化输出宽字符字符串

参数：

  • format ： 一个宽字符格式化字符串
  • … ： 可选参数

12.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include <stdio.h>
#include <wchar.h>

int main() 
{
    wchar_t name[] = L"Huazie";
    int age = 25;
    double height = 1.75;

    // 输出格式化的宽字符字符串
    wprintf(L"%ls %d %.2f\n", name, age, height);

    return 0;
}

12.3 运行结果

13. write

13.1 函数说明

函数声明 函数功能
ssize_t write(int fd, const void* buf, size_t count); 用于将数据写入文件描述符

参数：

  • fd ： 要写入的文件描述符
  • buf： 写入数据的缓冲区
  • count： 写入的字节数

返回值：

  • 如果写入成功，则返回实际写入的字节数；
  • 如果出现错误，则返回 -1。

13.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include <stdio.h>
#include <unistd.h>

int main() 
{
    const char msg[] = "Hello, Huazie!\n";
    int nbytes;

    // 向标准输出流写入数据
    nbytes = write(STDOUT_FILENO, msg, sizeof(msg) - 1);

    // 输出结果
    if (nbytes == -1) 
    {
        perror("write");
        return 1;
    }

    return 0;
}

注意： 在使用 write() 函数时，应该确保给定的文件描述符是有效的，并且缓冲区中有足够的数据可供写入，以免发生未定义的行为

13.3 运行结果

14. wscanf

14.1 函数说明

函数声明 函数功能
int wscanf(const wchar_t* format, ...); 用于从标准输入流（stdin）读取格式化的宽字符输入

参数：

  • format ： 一个宽字符格式化字符串
  • … ： 可选参数

14.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#include <stdio.h>
#include <wchar.h>

int main() 
{
    wchar_t name[20];
    int age;

    // 从标准输入流读取格式化的宽字符输入
    wprintf(L"Please nput your name and age: ");
    wscanf(L"%ls %d", name, &age);

    // 输出结果
    wprintf(L"name: %ls age: %d\n", name, age);

    return 0;
}

14.3 运行结果

开发语言-C

C语言函数大全--w 开头的函数（1）

总览

函数声明 函数功能
wchar_t * wcscat(wchar_t *dest, const wchar_t *src); 用于将一个宽字符字符串追加到另一个宽字符字符串的末尾
wchar_t *wcschr(const wchar_t *str, wchar_t wc); 用于在宽字符串中查找指定字符的位置
int wcscmp(const wchar_t *str1, const wchar_t *str2); 用于比较两个宽字符串的大小；它将两个字符串逐个字符进行比较，直到遇到不同的字符或者其中一个字符串结束为止
int wcscoll(const wchar_t *str1, const wchar_t *str2); 用于比较两个宽字符串的大小
wchar_t *wcscpy(wchar_t *dest, const wchar_t *src); 用于将一个宽字符串复制到另一个字符串中
size_t wcsftime(wchar_t *str, size_t maxsize, const wchar_t *format, const struct tm *timeptr); 用于将日期和时间格式化为宽字符字符串
size_t wcslen(const wchar_t *str); 用于计算宽字符串的长度
wchar_t *wcsncat(wchar_t *dest, const wchar_t *src, size_t n); 用于将一个宽字符串的一部分追加到另一个宽字符串末尾
int wcsncmp(const wchar_t *str1, const wchar_t *str2, size_t n); 用于比较两个宽字符串的前若干个字符是否相同
wchar_t *wcsncpy(wchar_t *dest, const wchar_t *src, size_t n); 用于将一个宽字符串的一部分复制到另一个宽字符串中
size_t wcsrtombs(char *dest, const wchar_t **src, size_t n, mbstate_t *ps); 用于将宽字符串转换为多字节字符串
wchar_t *wcsstr(const wchar_t *haystack, const wchar_t *needle); 用于在一个宽字符串中查找另一个宽字符串
size_t wcsspn(const wchar_t *str, const wchar_t *accept); 用于查找宽字符串中连续包含某些字符集合中的字符的最长前缀
double wcstod(const wchar_t *nptr, wchar_t **endptr); 用于将宽字符串转换为双精度浮点数

1. wcscat

1.1 函数说明

函数声明 函数功能
wchar_t * wcscat(wchar_t *dest, const wchar_t *src); 用于将一个宽字符字符串追加到另一个宽字符字符串的末尾

参数：

  • dest ： 目标字符串
  • src ： 源字符串

1.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
#include <stdio.h>
#include <wchar.h>

int main() {
    wchar_t dest[30] = L"Hello";
    const wchar_t *src = L", Huazie!";

    wcscat(dest, src);

    wprintf(L"%ls\n", dest);

    return 0;
}

在上面的示例代码中，

  • 首先，我们定义了一个大小为 30 的 wchar_t 数组 dest，并初始化为 "Hello";
  • 然后，定义了一个指向常量宽字符串的指针 src，指向字符串 ", Huazie!"；
  • 接着。调用 wcscat() 函数将 src 字符串中的所有字符追加到 dest 字符串的末尾，形成新的宽字符字符串 "Hello, Huazie!"；
  • 最后，使用 wprintf() 函数将新的字符串输出到控制台。

注意： 在使用 wcscat() 函数时，需要确保目标字符串 dest 的空间足够大，以容纳源字符串 src 的所有字符和一个结束符（\0）。如果目标字符串的空间不足，可能会导致数据覆盖和未定义行为。

1.3 运行结果

2. wcschr

2.1 函数说明

函数声明 函数功能
wchar_t *wcschr(const wchar_t *str, wchar_t wc); 用于在宽字符串中查找指定字符的位置

参数：

  • str ： 要查找的宽字符串
  • wc ： 要查找的宽字符

返回值：

  • 如果在 str 字符串中查找到第一个与 wc 相等的宽字符，则返回该字符在字符串中的地址；
  • 否则没有找到匹配字符，则返回空指针。

2.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#include <stdio.h>
#include <wchar.h>

int main() 
{
    const wchar_t *str = L"hello, huazie";
    wchar_t c = L'u';

    wchar_t *p = wcschr(str, c);

    if (p != NULL) 
        printf("Found %lc at position %d.\n", c, p - str);
    else
        printf("%lc not found.\n", c);

    return 0;
}

在上面的示例代码中，

  • 首先，我们定义了一个宽字符串 str，并初始化为 "hello, huazie"；
  • 然后，定义了一个宽字符 c，值为 'u'；
  • 接着调用 wcschr() 函数在 str 字符串中查找字符 c，并将返回结果保存在指针变量 p 中；
  • 最后，根据返回值判断是否找到了匹配字符，并输出相应的信息。

2.3 运行结果

3. wcscmp

3.1 函数说明

函数声明 函数功能
int wcscmp(const wchar_t *str1, const wchar_t *str2); 用于比较两个宽字符串的大小；它将两个字符串逐个字符进行比较，直到遇到不同的字符或者其中一个字符串结束为止

参数：

  • str1： 待比较的宽字符串1
  • str2： 待比较的宽字符串2

返回值：

  • 如果 str1 小于 str2，则返回一个负整数；
  • 如果 str1 等于 str2，则返回 0；
  • 如果 str1 大于 str2，则返回一个正整数。

3.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include <stdio.h>
#include <wchar.h>

int main() 
{
    const wchar_t *str1 = L"hello";
    const wchar_t *str2 = L"huazie";

    int result = wcscmp(str1, str2);

    if (result < 0) 
        printf("%ls is less than %ls.\n", str1, str2);
    else if (result == 0)
        printf("%ls is equal to %ls.\n", str1, str2);
    else
        printf("%ls is greater than %ls.\n", str1, str2);

    return 0;
}

在上述的示例代码中，

  • 首先，我们定义了两个宽字符串 str1 和 str2，分别初始化为 "hello" 和 "huazie"；
  • 然后，调用 wcscmp() 函数比较两个字符串的大小，并将返回结果保存在变量 result 中；
  • 接着根据 result 的值，输出相应的比较结果；
  • 最后结束程序。

3.3 运行结果

4. wcscoll

4.1 函数说明

函数声明 函数功能
int wcscoll(const wchar_t *str1, const wchar_t *str2); 用于比较两个宽字符串的大小

参数：

  • str1： 待比较的宽字符串1
  • str2： 待比较的宽字符串2

4.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#include <stdio.h>
#include <wchar.h>
#include <locale.h>

int main() 
{
    setlocale(LC_ALL, ""); // 设置本地化环境

    const wchar_t *str1 = L"hello";
    const wchar_t *str2 = L"huazie";

    int result = wcscoll(str1, str2);

    if (result < 0)
        printf("%ls is less than %ls.\n", str1, str2);
    else if (result == 0)
        printf("%ls is equal to %ls.\n", str1, str2);
    else
        printf("%ls is greater than %ls.\n", str1, str2);

    return 0;
}

在上述的示例代码中，

  • 首先，我们调用 setlocale() 函数设置本地化环境为当前系统默认设置；
  • 然后，定义了两个宽字符串 str1 和 str2，分别初始化为 “hello” 和 “huazie”；
  • 接着，调用 wcscoll() 函数比较两个字符串的大小，并将返回结果保存在变量 result 中。
  • 最后根据 result 的值，输出相应的比较结果。

注意： 在使用 wcscoll() 函数比较宽字符串大小时，需要确保本地化环境正确设置，以便该函数能够正常工作。如果没有设置本地化环境或者设置错误，可能会导致比较结果不准确。

4.3 运行结果

5. wcscpy

5.1 函数说明

函数声明 函数功能
wchar_t *wcscpy(wchar_t *dest, const wchar_t *src); 用于将一个宽字符串复制到另一个字符串中

参数：

  • dest ： 目标字符串
  • src ： 源字符串

5.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include <stdio.h>
#include <wchar.h>

int main() 
{
    wchar_t dest[20];
    const wchar_t *src = L"Hello, huazie!";

    wcscpy(dest, src);

    wprintf(L"%ls\n", dest);

    return 0;
}

在上述的示例代码中，

  • 首先，我们定义了一个大小为 20 的 wchar_t 数组 dest；
  • 然后，定义了一个指向常量宽字符串的指针 src，指向字符串 “Hello, huazie!”；
  • 接着，调用 wcscpy() 函数将 src 字符串中的所有字符复制到 dest 字符串中，形成新的宽字符字符串 dest；
  • 最后，使用 wprintf() 函数将新的字符串输出到控制台。

5.3 运行结果

6. wcsftime

6.1 函数说明

函数声明 函数功能
size_t wcsftime(wchar_t *str, size_t maxsize, const wchar_t *format, const struct tm *timeptr); 用于将日期和时间格式化为宽字符字符串

参数：

  • str ： 输出结果的缓冲区
  • maxsize ： 缓冲区的大小
  • format ： 格式化字符串
  • timeptr ： 包含日期和时间信息的结构体指针

6.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#include <stdio.h>
#include <wchar.h>
#include <time.h>

int main() 
{
    time_t current_time;
    struct tm *time_info;
    wchar_t buffer[80];

    time(&current_time);
    time_info = localtime(&current_time);

    wcsftime(buffer, 80, L"%c", time_info);
    wprintf(L"The current date and time is: %ls\n", buffer);

    return 0;
}

在上面的示例代码中，

  • 首先，我们定义了一个变量 current_time 来存储当前时间，以及一个指向 struct tm 类型的指针 time_info；
  • 然后，调用 time() 函数获取当前时间，并使用 localtime() 函数将时间转换为本地时间，存储在 time_info 指针变量中；
  • 接着，调用 wcsftime() 函数将日期和时间格式化为宽字符字符串，并存储到缓冲区 buffer 中；
  • 最后，使用 wprintf() 函数输出格式化后的字符串。

6.3 运行结果

7. wcslen

7.1 函数说明

函数声明 函数功能
size_t wcslen(const wchar_t *str); 用于计算宽字符串的长度

参数：

  • str ： 要计算长度的宽字符串

7.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
#include <stdio.h>
#include <wchar.h>

int main() 
{
    const wchar_t *str = L"Hello, huazie!";
    size_t len = wcslen(str);

    wprintf(L"The length of '%ls' is %zu.\n", str, len);

    return 0;
}

在上面的示例代码中，

  • 首先，我们定义了一个指向常量宽字符串的指针 str，指向字符串 "Hello, huazie!"；
  • 然后，调用 wcslen() 函数计算 str 字符串的长度，并将结果保存在变量 len 中；
  • 最后，使用 wprintf() 函数输出字符串的长度。

7.3 运行结果

8. wcsncat

8.1 函数说明

函数声明 函数功能
wchar_t *wcsncat(wchar_t *dest, const wchar_t *src, size_t n); 用于将一个宽字符串的一部分追加到另一个宽字符串末尾

参数：

  • dest ： 目标字符串
  • src ： 源字符串
  • n ： 要追加的字符数

8.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include <stdio.h>
#include <wchar.h>

int main() 
{
    wchar_t dest[20] = L"Hello, ";
    const wchar_t *src = L"huazie!";
    size_t n = 3;

    wcsncat(dest, src, n);

    wprintf(L"%ls\n", dest);

    return 0;
}

在上述的示例代码中，

  • 首先，我们定义了一个大小为 20 的 wchar_t 数组 dest，并初始化为 "Hello, "；
  • 然后，定义了一个指向常量宽字符串的指针 src，指向字符串 "huazie!"。
  • 接着，调用 wcsncat() 函数将 src 字符串中的前 3 个字符追加到 dest 字符串的末尾，形成新的宽字符字符串 dest；
  • 最后，使用 wprintf() 函数将新的字符串输出到控制台。

8.3 运行结果

9. wcsncmp

9.1 函数说明

函数声明 函数功能
int wcsncmp(const wchar_t *str1, const wchar_t *str2, size_t n); 用于比较两个宽字符串的前若干个字符是否相同

参数：

  • str1 ： 待比较的宽字符串1
  • str2 ： 待比较的宽字符串2
  • n ： 要比较的字符数

返回值：
将字符串 str1 和字符串 str2 中的前 n 个字符进行比较

  • 如果两个字符串相同，返回值为 0；
  • 如果字符串 str1 在前 n 个字符中的第一个不同于字符串 str2 对应字符的字符大于字符串 str2 对应字符的字符，返回值为正数；
  • 如果字符串 str1 在前 n 个字符中的第一个不同于字符串 str2 对应字符的字符小于字符串 str2 对应字符的字符，返回值为负数。

9.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include <stdio.h>
#include <wchar.h>

int main() 
{
    const wchar_t *str1 = L"hello";
    const wchar_t *str2 = L"huazie";
    size_t n = 3;

    int result = wcsncmp(str1, str2, n);

    if (result < 0)
        printf("%ls is less than %ls in the first %zu characters.\n", str1, str2, n);
    else if (result == 0)
        printf("%ls is equal to %ls in the first %zu characters.\n", str1, str2, n);
    else
        printf("%ls is greater than %ls in the first %zu characters.\n", str1, str2, n);

    return 0;
}

9.3 运行结果

10. wcsncpy

10.1 函数说明

函数声明 函数功能
wchar_t *wcsncpy(wchar_t *dest, const wchar_t *src, size_t n); 用于将一个宽字符串的一部分复制到另一个宽字符串中

参数：

  • dest ： 目标字符串
  • src ： 源字符串
  • n ： 要复制的字符数

10.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#include <stdio.h>
#include <wchar.h>

int main() 
{
    wchar_t dest[20];
    const wchar_t *src = L"Hello, huazie!";
    size_t n = 5;

    wcsncpy(dest, src, n);
    dest[n] = L'\0';

    wprintf(L"%ls\n", dest);

    return 0;
}

在上面的示例代码中，

  • 首先，我们定义了一个大小为 20 的 wchar_t 数组 dest，以及一个指向常量宽字符串的指针 src，指向字符串 "Hello, huazie!"；
  • 然后，调用 wcsncpy() 函数将 src 字符串中的前 5 个字符复制到 dest 字符串中，形成新的宽字符字符串 dest；
  • 最后，手动添加空字符 \0 以确保字符串结束，并使用 wprintf() 函数将新的字符串输出到控制台。

10.3 运行结果

11. wcsrtombs

11.1 函数说明

函数声明 函数功能
size_t wcsrtombs(char *dest, const wchar_t **src, size_t n, mbstate_t *ps); 用于将宽字符串转换为多字节字符串

参数：

  • dest ： 输出结果的缓冲区
  • src ： 指向源字符串的指针
  • n ： 要转换的最大字符数
  • ps ： 一个指向转换状态的指针

11.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
#include <stdio.h>
#include <stdlib.h>
#include <wchar.h>
#include <locale.h>

int main() 
{
    setlocale(LC_ALL, "");

    const wchar_t *src = L"Hello, huazie!";
    size_t n = wcslen(src) + 1;

    char *dest = (char *) malloc(n * sizeof(char));

    if (dest == NULL) 
    {
        fprintf(stderr, "Memory allocation failed.\n");
        return EXIT_FAILURE;
    }

    mbstate_t state = {0};

    wcsrtombs(dest, &src, n, &state);

    printf("%s\n", dest);

    free(dest);

    return 0;
}

在上面的示例代码中，

  • 首先，我们调用 setlocale() 函数设置程序的本地化环境，以便可以正确地进行宽字符和多字节字符之间的转换；
  • 然后，定义了一个指向常量宽字符串的指针 src，指向字符串 "Hello, huazie!"；
  • 接着，根据源字符串的长度分配了足够大小的缓冲区 dest，并初始化为 0；
  • 再然后，调用 wcsrtombs() 函数将宽字符串 src 转换为多字节字符串，并存储到缓冲区 dest 中；
  • 最后，使用 printf() 函数输出多字节字符串，并释放目标缓存区的内存。

注意： 在使用 wcsrtombs() 函数进行宽字符和多字节字符转换时，需要确保程序的本地化环境已经正确设置，否则可能会导致转换失败或者输出结果不正确。此外，在分配缓冲区 dest 的大小时，可以考虑将源字符串的长度加 1，以容纳字符串的结尾空字符（\0）。最后在使用完毕后要记得释放缓冲区的内存。

11.3 运行结果

12. wcsstr

12.1 函数说明

函数声明 函数功能
wchar_t *wcsstr(const wchar_t *haystack, const wchar_t *needle); 用于在一个宽字符串中查找另一个宽字符串

参数：

  • haystack ： 要查找的宽字符串
  • needle ： 要查找的子串

返回值：

  • 如果从 haystack 字符串中查找到第一个匹配 needle 子串的位置，则返回指向匹配位置的指针；
  • 否则未找到匹配的子串，返回空指针（NULL）。

12.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#include <stdio.h>
#include <wchar.h>

int main() 
{
    const wchar_t *haystack = L"Hello, huazie!";
    const wchar_t *needle = L"huazie";

    wchar_t *result = wcsstr(haystack, needle);

    if (result != NULL)
        wprintf(L"The substring '%ls' was found at position %d.\n", needle, result - haystack);
    else
        wprintf(L"The substring '%ls' was not found in '%ls'.\n", needle, haystack);

    return 0;
}

在上述的示例代码中，

  • 首先，我们定义了一个指向常量宽字符串的指针 haystack，指向字符串 "Hello, huazie!"。
  • 然后，定义了一个指向常量宽字符串的指针 needle，指向字符串 "huazie"；
  • 接着，调用 wcsstr() 函数在 haystack 字符串中查找子串 needle，并将结果指针保存在变量 result 中。
  • 最后，根据 result 的值，输出相应的查找结果。

注意： 在使用 wcsstr() 函数查找子串时，该函数会自动遍历整个字符串，直到找到匹配的子串或者结束字符串。如果要查找的子串在字符串中多次出现，该函数将返回第一次出现的位置，并不会考虑后续的匹配。

12.3 运行结果

13. wcsspn

13.1 函数说明

函数声明 函数功能
size_t wcsspn(const wchar_t *str, const wchar_t *accept); 用于查找宽字符串中连续包含某些字符集合中的字符的最长前缀

参数：

  • str ： 要查找的宽字符串
  • accept ： 一个包含要接受字符集合的宽字符串

13.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include <stdio.h>
#include <wchar.h>

int main() 
{
    const wchar_t *str = L"123456789a0";
    const wchar_t *accept = L"0123456789";

    size_t length = wcsspn(str, accept);

    wprintf(L"The length of the prefix that contains digits is %zu.\n", length);

    return 0;
}

在上述的示例代码中，

  • 首先，我们定义了一个指向常量宽字符串的指针 str，指向字符串 "123456789a0"；
  • 然后，定义了一个指向常量宽字符串的指针 accept，指向字符串 "0123456789"，表示数字字符的集合；
  • 接着，调用 wcsspn() 函数查找 str 字符串中连续包含数字字符集合中的字符的最长前缀，并将返回结果保存在变量 length 中。
  • 最后，根据 length 的值，调用 wprintf() 函数 输出 最长前缀的长度。

注意： 在使用 wcsspn() 函数查找宽字符串中的字符集合时，该函数会自动遍历整个字符串，直到找到第一个不在字符集合中的字符或者结束字符串。如果要查找的字符集合为空串，则返回 0。

13.3 运行结果

14. wcstod

14.1 函数说明

函数声明 函数功能
double wcstod(const wchar_t *nptr, wchar_t **endptr); 用于将宽字符串转换为双精度浮点数

参数：

  • nptr ： 要转换的宽字符串
  • endptr ： 一个指向指针的指针，用于存储第一个无法解析的字符的位置

返回值：

  • 如果从 nptr 字符串中解析出一个双精度浮点数，则返回该数值；
  • 如果 nptr 字符串不包含有效的浮点数，则返回 0；
  • 如果存在无法解析的字符，存储其位置到 endptr 指针中。

14.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#include <stdio.h>
#include <wchar.h>

int main() 
{
    const wchar_t *str = L"3.14159265358979323846";
    //const wchar_t *str = L"3.141592653589793a23846";
    //const wchar_t *str = L"a3.14159265358979323846";
    wchar_t *end;

    double number = wcstod(str, &end);

    if (end == str)
        wprintf(L"No digits were found.\n");
    else if (*end != L'\0')
        wprintf(L"Invalid character at position %ld: '%lc'.\n", end - str, *end);
    else
        wprintf(L"The parsed number is %.20lf.\n", number);

    return 0;
}

在上面的示例代码中，

  • 首先，我们定义了一个指向常量宽字符串的指针 str，指向字符串 "3.14159265358979323846"；
  • 然后，调用 wcstod() 函数将字符串转换为双精度浮点数，并将结果保存在变量 number 中。
  • 最后，根据函数的返回结果 number 和 endptr 指针所指向的值，输出相应的转换结果。

注意： 在使用 wcstod() 函数转换宽字符串为双精度浮点数时，要确保字符串中只包含有效的浮点数表示，否则可能会导致转换错误或者未定义行为。

14.3 运行结果



开发语言-C

C语言函数大全--v 开头的函数

总览

函数声明 函数功能
void va_start(va_list ap, last_arg); 用于初始化一个 va_list 类型的变量，使其指向可变参数列表中的第一个参数
type va_arg(va_list ap, type); 用于从可变参数列表中获取下一个参数，并将其转换为指定的类型
void va_copy(va_list dest, va_list src); 用于将一个 va_list 类型的变量复制到另一个变量中
void va_end(va_list ap); 用于清理一个 va_list 类型的变量
int vfprintf(FILE *stream, const char *format, va_list arg); 用于将格式化输出写入到指定的文件流中
int vfscanf(FILE *stream, const char *format, va_list arg); 用于将指定文件流中的格式化输入读取到指定变量中
int vprintf(const char *format, va_list ap); 它使用格式化字符串 format 中的指令来指定输出的格式，并将后续的可变参数按照指令指定的格式输出到标准输出流 stdout
int vscanf(const char *format, va_list arg); 它使用格式化字符串 format 中的指令来指定输入的格式，并从标准输入流 stdin 中读取数据，并将数据按照指令指定的格式存储到相应的变量中
int vsprintf(char *str, const char *format, va_list ap); 它使用格式化字符串 format 中的指令来指定输出的格式，并将后续的可变参数按照指令指定的格式输出到字符数组 str 中。
int vsscanf(const char *str, const char *format, va_list ap); 它使用格式化字符串 format 中的指令来指定输入的格式，并从字符数组 str 中读取数据，并将数据按照指令指定的格式存储到相应的变量中

1. va_start

1.1 函数说明

函数声明 函数功能
void va_start(va_list ap, last_arg); 用于初始化一个 va_list 类型的变量，使其指向可变参数列表中的第一个参数

参数：

  • ap： 一个指向 va_list 类型的变量的指针，表示要初始化的可变参数列表
  • last_arg： 一个指向最后一个固定参数的指针，用于确定可变参数列表的起始位置

1.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
#include <stdio.h>
#include <stdarg.h>

void print_args(int count, ...) 
{
    va_list args1, args2;
    int i;

    va_start(args1, count); /* 初始化可变参数列表 */

    /* 复制可变参数列表 */
    va_copy(args2, args1);

    for (i = 0; i < count; i++) 
    {
        int arg1 = va_arg(args1, int); /* 获取下一个参数 */
        int arg2 = va_arg(args2, int);
        printf("arg[%d] = %d %d\n", i, arg1, arg2);
    }

    va_end(args2); /* 清理复制的可变参数列表 */
    va_end(args1); /* 清理原始可变参数列表 */
}

int main() 
{
    print_args(3, 10, 20, 30);
    return 0;
}

在上面的示例代码中，

  • 我们首先调用自定义的 print_args() 函数，并传入了 4 个入参，第一个为 可变参数的个数，后面三个为具体的整数型可变参数。
  • 然后在print_args() 函数内部，我们首先定义了两个 va_list 类型的变量 args1 和 args2，并使用 va_start() 函数初始化 args1 变量。
  • 接着，我们使用 va_copy() 函数将 args1 复制到 args2 中，并使用 for 循环和 两个 va_arg() 函数来分别访问这两个可变参数列表，并依次输出每个参数的值。
  • 最后，我们使用两次 va_end() 函数来清理这两个可变参数列表。

1.3 运行结果

2. va_arg

2.1 函数说明

函数声明 函数功能
type va_arg(va_list ap, type); 用于从可变参数列表中获取下一个参数，并将其转换为指定的类型

参数：

  • ap ： 一个指向 va_list 类型的变量的指针，表示要访问的可变参数列表
  • type ： 一个类型说明符，表示下一个参数的类型

2.2 演示示例

可参考 1.2 中所示

3. va_copy

3.1 函数说明

函数声明 函数功能
void va_copy(va_list dest, va_list src); 用于将一个 va_list 类型的变量复制到另一个变量中

参数：

  • dest ： 一个指向 va_list 类型的变量的指针，表示目标可变参数列表
  • src ： 另一个指向 va_list 类型的变量的指针，表示要被复制的可变参数列表

3.2 演示示例

可参考 1.2 中所示

4. va_end

4.1 函数说明

函数声明 函数功能
void va_end(va_list ap); 用于清理一个 va_list 类型的变量

参数：

  • ap： 一个指向 va_list 类型的变量的指针，表示要清理的可变参数列表

4.2 演示示例

可参考 1.2 中所示

5. vfprintf

5.1 函数说明

函数声明 函数功能
int vfprintf(FILE *stream, const char *format, va_list arg); 用于将格式化输出写入到指定的文件流中

参数：

  • stream ： 要写入数据的文件流指针
  • format ： 格式化字符串，用来指定要输出的内容和格式
  • arg ： 一个 va_list 类型的变量，包含了可变参数列表

5.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>

FILE *fp;

int vfpf(const char *fmt, ...)
{
    va_list argptr;
    int cnt;

    va_start(argptr, fmt);
    cnt = vfprintf(fp, fmt, argptr);
    va_end(argptr);

    return cnt;
}

int main()
{
    int inumber;
    float fnumber;
    char string[4];

    fp = tmpfile();
    if (fp == NULL)
    {
        perror("tmpfile() call");
        exit(1);
    }

    vfpf("%d %f %s", 30, 90.0, "abc");

    rewind(fp);
    
    fscanf(fp,"%d %f %s", &inumber, &fnumber, string);
    
    printf("%d %.2f %s\n", inumber, fnumber, string);
    
    fclose(fp);

    return 0;
}

在上述的示例代码中，

  • 我们首先声明了三个变量 inumber、fnumber 和 string；
  • 然后，调用 tmpfile() 函数创建一个临时文件，并将返回的文件指针赋值给全局变量 fp。如果创建文件失败，则打印错误信息并退出程序；
  • 接着，调用自定义的 vfpf() 函数来向临时文件中写入数据。它里面使用 vfprintf() 函数将格式化输出写入到一个文件流中；
  • 再然后，调用 rewind() 函数将文件指针重新定位到文件开头；
  • 再接着使用 fscanf() 函数从文件中读取数据，并使用 printf() 函数中输出从文件中读取的数据【其中浮点数部分保留两位小数】
  • 最后调用 fclose() 函数关闭文件指针，并结束程序

5.3 运行结果

6. vfscanf

6.1 函数说明

函数声明 函数功能
int vfscanf(FILE *stream, const char *format, va_list arg); 用于将指定文件流中的格式化输入读取到指定变量中

参数：

  • stream ： 要读取数据的文件流指针
  • format ： 格式化字符串，用来指定要读取的内容和格式
  • arg ： 一个 va_list 类型的变量，包含了可变参数列表

返回值：

  • 如果读取成功，返回成功读取并赋值给变量的项目数；
  • 如果出现错误，则返回负数。

6.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>

FILE *fp;

int vfsf(const char *fmt, ...) {
    va_list argptr;
    int cnt;

    va_start(argptr, fmt);
    cnt = vfscanf(fp, fmt, argptr);
    va_end(argptr);

    return cnt;
}

int main()
{
    int inumber;
    float fnumber;
    char string[4];

    fp = tmpfile();
    if (fp == NULL)
    {
        perror("tmpfile() call");
        exit(1);
    }

    fprintf(fp, "%d %f %s", 30, 90.0, "abc");

    rewind(fp);
    
    vfsf("%d %f %s", &inumber, &fnumber, string);

    printf("%d %.2f %s\n", inumber, fnumber, string);

    fclose(fp);

    return 0;
}

在上面的示例代码中，

  • 我们首先声明了三个变量 inumber、fnumber 和 string；
  • 然后，程序调用 tmpfile() 函数创建一个临时文件，并将返回的文件指针赋值给全局变量 fp。如果创建文件失败，则打印错误信息并退出程序；
  • 接着，我们使用 fprintf() 函数将三个数据（一个整型数字、一个浮点数和一个字符串）写入该文件中；
  • 再然后，调用 rewind() 函数将文件指针重新定位到文件开头；
  • 再接着，我们调用自定义的 vfsf() 函数，里面使用 vfscanf() 函数从文件中读取数据；
  • 最后，打印出从文件中读取的数据，并关闭临时文件，退出程序。

6.3 运行结果

7. vprintf

7.1 函数说明

函数声明 函数功能
int vprintf(const char *format, va_list ap); 它使用格式化字符串 format 中的指令来指定输出的格式，并将后续的可变参数按照指令指定的格式输出到标准输出流 stdout

参数：

  • format ： 格式化字符串，用来指定要打印的内容和格式
  • va_list ： 一个 va_list 类型的变量，包含了可变参数列表

7.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include <stdio.h>
#include <stdarg.h>

void myprint(const char *format, ...) 
{
    va_list args;
    va_start(args, format);
    vprintf(format, args);
    va_end(args);
}

int main() 
{
    int a = 10;
    float b = 3.14;
    char s[] = "hello";
    
    myprint("a=%d, b=%.2f, s=%s\n", a, b, s);
    return 0;
}

在上面的示例代码中，

  • 我们首先定义了三个变量 整形 a 、浮点型 b 和 字符数组 s；
  • 然后，调用自定义的 myprint() 函数将这些变量的值输出到标准输出流 stdout 中；
    在 myprint() 函数中，
    • 我们首先使用 va_start() 宏初始化一个 va_list 变量 args；
    • 然后调用 vprintf() 函数将格式化字符串和参数列表传递给该函数进行输出；
    • 最后使用 va_end() 宏清理 args 变量。
  • 最后结束程序。

7.3 运行结果

8. vscanf

8.1 函数说明

函数声明 函数功能
int vscanf(const char *format, va_list arg); 它使用格式化字符串 format 中的指令来指定输入的格式，并从标准输入流 stdin 中读取数据，并将数据按照指令指定的格式存储到相应的变量中

参数：

  • format ： 格式化字符串，用来指定要读取的内容和格式
  • va_list ： 一个 va_list 类型的变量，包含了可变参数列表

8.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#include <stdio.h>
#include <stdarg.h>

void myscan(const char *format, ...) 
{
    va_list args;
    va_start(args, format);
    vscanf(format, args);
    va_end(args);
}

int main() 
{
    int a;
    float b;
    char s[10];
    
    myscan("%d%f%s", &a, &b, s);
    printf("a=%d, b=%.2f, s=%s\n", a, b, s);
    return 0;
}

在上面的示例代码中，

  • 我们首先定义了三个变量 整形 a 、浮点型 b 和 字符数组 s；
  • 然后，调用自定义的 myscan() 函数从标准输入流 stdin 中读取数据，并将数据存储到这些变量中
    在 myscan() 函数中，
    • 我们首先使用 va_start() 宏初始化一个 va_list 变量 args；
    • 然后调用 vscanf() 函数将格式化字符串和参数列表传递给该函数进行输入；
    • 最后使用 va_end() 宏清理 args 变量。
  • 最后我们打印输出上面输入的两个变量的数据，并结束程序。

8.3 运行结果

9. vsprintf

9.1 函数说明

函数声明 函数功能
int vsprintf(char *str, const char *format, va_list ap); 它使用格式化字符串 format 中的指令来指定输出的格式，并将后续的可变参数按照指令指定的格式输出到字符数组 str 中。

参数：

  • str： 用来存储格式化数据的字符数组的指针
  • format ： 格式化字符串，用来指定要输出的内容和格式
  • va_list ： 一个 va_list 类型的变量，包含了可变参数列表

9.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#include <stdio.h>
#include <stdarg.h>

void myprint(const char *format, ...) 
{
    char buffer[100];
    va_list args;
    va_start(args, format);
    vsprintf(buffer, format, args);
    va_end(args);
    printf("%s", buffer);
}

int main() 
{
    int a = 10;
    float b = 3.1415;
    char s[] = "huazie";
    
    myprint("a=%d, b=%.4f, s=%s\n", a, b, s);
    return 0;
}

在上面的示例代码中，

  • 我们首先定义了三个变量 整形 a 、浮点型 b 和 字符数组 s；
  • 然后，调用自定义的 myprint() 函数将格式化字符串和这些变量的值输出到字符数组 buffer 中，并打印输出字符数组 buffer ；
    在 myprint() 函数中，
    • 我们首先使用 va_start() 宏初始化一个 va_list 变量 args；
    • 然后调用 vsprintf() 函数将格式化字符串和参数列表传递给该函数进行输出，并将输出结果存储到 buffer 数组中；
    • 最后使用 va_end() 宏清理 args 变量。
  • 最后结束程序。

9.3 运行结果

10. vsscanf

10.1 函数说明

函数声明 函数功能
int vsscanf(const char *str, const char *format, va_list ap); 它使用格式化字符串 format 中的指令来指定输入的格式，并从字符数组 str 中读取数据，并将数据按照指令指定的格式存储到相应的变量中

参数：

  • str： 用来读取的格式化数据的字符数组的指针
  • format ： 格式化字符串，用来指定要读取的内容和格式
  • va_list ： 一个 va_list 类型的变量，包含了可变参数列表

10.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#include <stdio.h>
#include <stdarg.h>

void myscan(const char *str, const char *format, ...) 
{
    va_list args;
    va_start(args, format);
    vsscanf(str, format, args);
    va_end(args);
}

int main() 
{
    int a;
    float b;
    char s[10];
    char buffer[] = "10 3.1415 huazie";
    
    myscan(buffer, "%d%f%s", &a, &b, s);
    printf("a=%d, b=%.4f, s=%s\n", a, b, s);
    return 0;
}

在上面的示例代码中，

  • 我们首先定义了四个变量 整形 a 、浮点型 b 、 字符数组 s 和 字符数组 buffer；
  • 然后，调用自定义的 myscan() 函数从字符数组 buffer 中读取数据，并将数据存储到另外 3 个变量中；
    在 myscan() 函数中，
    • 我们首先使用 va_start() 宏初始化一个 va_list 变量 args；
    • 然后调用 vsscanf() 函数将字符数组 buffer 和格式化字符串以及参数列表传递给该函数进行输入，并将数据存储到相应的变量中；
    • 最后使用 va_end() 宏清理 args 变量。
  • 最后我们打印输出上面从字符数组 buffer 中读取并输入的三个变量的数据，并结束程序。

10.3 运行结果

参考

  1. [API Reference Document]
开发语言-C

C语言函数大全--u 开头的函数

总览

函数声明 函数功能
char *ultoa(unsigned long value, char *str, int base); 用于将无符号长整型数转换成指定基数下的字符串表示
int ungetc(int c, FILE *stream); 用于将字符推回输入流中
int ungetch(int c); 用于将字符推回输入流中
int unix2dos(const char *src_file, const char *dst_file); 用于将文本文件的行末标志符从 Unix 风格的 \n 转换为 Windows/DOS 风格的 \r\n
int dos2unix(const char *src_file, const char *dst_file); 用于将将文本文件的行末标志符从 Windows/DOS 风格的 \r\n 转换为 Unix 风格的 \n
int unlink(const char *pathname); 用于删除指定文件
int unlock(int handle, long offset, long length); 它不是标准 C 库中的函数，而是 Linux/Unix 系统下用于文件锁定和解锁的函数
BOOL UnlockFile(HANDLE hFile, DWORD dwFileOffsetLow, DWORD dwFileOffsetHigh, DWORD nNumberOfBytesToUnlockLow, DWORD nNumberOfBytesToUnlockHigh); 用于对文件进行解锁操作

1. ultoa

1.1 函数说明

函数声明 函数功能
char *ultoa(unsigned long value, char *str, int base); 用于将无符号长整型数转换成指定基数下的字符串表示

参数：

  • value ： 要转换的无符号长整型数
  • str ： 用于存储转换后的字符串
  • base ： 要使用的进制数，可以为 2、8、10 或 16

函数 ultoa() 将参数 value 转换为以 base 进制表示的形式，并将结果存储在缓冲区 str 中。如果转换成功，则返回指向 str 的指针。

注意： 函数 ultoa() 不会检查缓冲区是否足够大，因此调用者需要确保缓冲区足够大以避免发生缓冲区溢出。

1.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include <stdio.h>
#include <stdlib.h>

int main() 
{
    unsigned long num = 0xDEADBEEF;
    char str[20];

    _ultoa(num, str, 16); 

    printf("The hexadecimal representation of %lu is %s\n", num, str);

    return 0;
}

1.3 运行结果

2. ungetc

2.1 函数说明

函数声明 函数功能
int ungetc(int c, FILE *stream); 用于将字符推回输入流中

参数：

  • c ： 要推回的字符
  • stream ： 要推回字符的文件指针

2.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
#include <stdio.h>

//int ungetc(int c, FILE *stream);

int main() 
{
    int c;
    FILE *fp = fopen("test.txt", "r");

    if (fp == NULL) 
    {
        printf("Failed to open file\n");
        return 1;
    }

    // 读取一个字符
    c = fgetc(fp);

    if (c == EOF) 
    {
        printf("Failed to read character\n");
        return 1;
    }

    printf("Read character: %c\n", c);

    // 推回字符到输入流中
    if (ungetc(c, fp) == EOF) 
    {
        printf("Failed to unget character\n");
        return 1;
    }

    // 再次读取字符
    c = fgetc(fp);

    if (c == EOF) 
    {
        printf("Failed to read character\n");
        return 1;
    }

    printf("Read character again: %c\n", c);

    fclose(fp);
    return 0;
}

在上面的示例代码中，

  • 我们首先打开了一个名为 test.txt 的文本文件；
  • 接着，使用 fgetc() 函数从中读取一个字符；
  • 然后，我们使用 ungetc() 函数将该字符推回输入流中；
  • 再接着使用 fgetc() 函数从输入流中读取字符；
  • 最后，我们使用 printf() 函数将两次读取的字符打印到标准输出流中。

注意： 在使用 ungetc() 函数推回字符之前，必须先读取一个字符并检查其是否成功读取。否则，ungetc() 函数将无法确定将字符推回哪个位置。

2.3 运行结果

3. ungetch

3.1 函数说明

函数声明 函数功能
int ungetch(int c); 用于将字符推回输入流中

参数：

  • c ： 要推回的字符

3.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include <stdio.h>
#include <ctype.h>
#include <conio.h>

int main()
{
    int i=0;
    char ch;

    puts("Input an integer followed by a char:");

    while((ch = getche()) != EOF && isdigit(ch))
        i = 10 * i + ch - 48; 

    if (ch != EOF)
        ungetch(ch);

    printf("\n\ni = %d, next char in buffer = %c\n", i, getch());
    return 0;
}

在上述的示例代码中，

  • 我们首先输出一条提示信息 "Input an integer followed by a char:"
  • 接着，通过循环调用 getche() 函数从输入流中逐个读取字符，并检查它是否是数字字符。如果是数字字符，则将其转换为整数并存储在变量 i 中。
  • 然后，在读取到非数字字符时，使用 ungetch() 函数将该字符推回输入流中，以保留它供后续使用。
  • 最后，使用 getch() 函数从输入流中读取一个字符，并打印出读取到的下一个字符和此时 i 的值。

注意： getch() 和 ungetch() 函数通常只在 Windows 平台上可用，因此这段代码可能不可移植到其他操作系统或编译器中。

3.3 运行结果

4. unix2dos

4.1 函数说明

函数声明 函数功能
int unix2dos(const char *src_file, const char *dst_file); 用于将文本文件的行末标志符从 Unix 风格的 \n 转换为 Windows/DOS 风格的 \r\n
int dos2unix(const char *src_file, const char *dst_file); 用于将将文本文件的行末标志符从 Windows/DOS 风格的 \r\n 转换为 Unix 风格的 \n

参数：

  • src_file ： 要转换的源文件名
  • dst_file ： 转换后保存到的目标文件名

返回值：

  • 如果转换成功，则返回 0；
  • 否则返回一个 非零值， 表示错误代码。

4.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
#include <stdio.h>
#include <stdlib.h>

int unix2dos(const char *src_file, const char *dst_file);
int dos2unix(const char *src_file, const char *dst_file);

int main() 
{
    int status;

    // 将 Unix 格式的文件转换为 DOS 格式
    status = unix2dos("input_unix.txt", "output_dos.txt");
    if (status != 0) 
    {
        printf("Failed to convert file: %d\n", status);
        return 1;
    }

    // 将 DOS 格式的文件转换为 Unix 格式
    status = dos2unix("input_dos.txt", "output_unix.txt");
    if (status != 0) 
    {
        printf("Failed to convert file: %d\n", status);
        return 1;
    }

    printf("File conversion successful\n");
    return 0;
}

int unix2dos(const char *src_file, const char *dst_file) 
{
    FILE *in = fopen(src_file, "r");
    FILE *out = fopen(dst_file, "w");

    if (in == NULL || out == NULL)
        return -1;

    int c;

    while ((c = fgetc(in)) != EOF) 
    {
        if (c == '\n')
            fputc('\r', out);
        fputc(c, out);
    }

    fclose(in);
    fclose(out);

    return 0;
}

int dos2unix(const char *src_file, const char *dst_file) 
{
    FILE *in = fopen(src_file, "r");
    FILE *out = fopen(dst_file, "w");

    if (in == NULL || out == NULL) 
        return -1;

    int c;
    int prev = -1;

    while ((c = fgetc(in)) != EOF) 
    {
        if (prev == '\r' && c == '\n') 
        {
            // skip CR character
            prev = c;
            continue;
        }
        fputc(c, out);
        prev = c;
    }

    fclose(in);
    fclose(out);

    return 0;
}

5. unlink

5.1 函数说明

函数声明 函数功能
int unlink(const char *pathname); 用于删除指定文件

参数：

  • pathname ： 要删除的文件路径名

5.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#include <stdio.h>
#include <stdlib.h>

int main() 
{
    int status;

    // 删除指定文件
    status = unlink("huazie.txt");
    if (status != 0) 
    {
        printf("Failed to delete file: %d\n", status);
        return 1;
    }

    printf("File deletion successful\n");
    return 0;
}

在上面的示例代码中，我们使用 unlink() 函数删除了当前目录下名为 huazie.txt 的文件。如果 unlink() 函数返回值不为 0，则说明删除操作失败，可能是由于权限不足、文件不存在或其他原因导致的。如果删除操作成功，则会输出一条简短的提示信息 "File deletion successful"。

注意： 由于删除操作无法撤销，并且被删除的文件内容将无法恢复，因此在使用 unlink() 函数删除文件时需要小心谨慎，建议在执行此类敏感操作之前进行备份或确认。

5.3 运行结果

6. unlock

6.1 函数说明

函数声明 函数功能
int unlock(int handle, long offset, long length); 它不是标准 C 库中的函数，而是 Linux/Unix 系统下用于文件锁定和解锁的函数

参数：

  • handle ： 要解锁的文件句柄
  • offset： 解锁操作的起始偏移量（以字节为单位）。通常情况下，偏移量应该为正整数，代表从文件开头开始的偏移量。如果 offset 参数小于零，则将从文件末尾开始向前计算偏移量。
  • length： 要解锁的字节数

6.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
#include <io.h>
#include <fcntl.h>
#include <sys\stat.h>
#include <process.h>
#include <share.h>
#include <stdio.h>
#include <sys\locking.h>

int main(void)
{
    int handle, status;
    long length;
    // 打开名为 test.txt 的文件
    handle = sopen("test.txt",O_RDONLY,SH_DENYNO,S_IREAD);

    if (handle < 0)
    {
        printf("sopen failed\n");
        exit(1);
    }
    // 获取文件长度
    length = filelength(handle);
    // 锁定上面打开的文件
    status = lock(handle,0L,length/2);
    // 检查锁定操作是否成功，返回0，表示成功，返回非0，则加锁失败
    if (status == 0)
        printf("lock succeeded\n");
    else
        printf("lock failed\n");
    // 对上面锁定的文件进行解除锁定
    status = unlock(handle,0L,length/2);
    // 检查解除锁定操作是否成功，返回0，表示成功，返回非0，则解锁失败
    if (status == 0)
        printf("unlock succeeded\n");
    else
        printf("unlock failed\n");
    // 关闭文件句柄
    close(handle);
    return 0;
}

7. UnlockFile

7.1 函数说明

函数声明 函数功能
BOOL UnlockFile(HANDLE hFile, DWORD dwFileOffsetLow, DWORD dwFileOffsetHigh, DWORD nNumberOfBytesToUnlockLow, DWORD nNumberOfBytesToUnlockHigh); 用于对文件进行解锁操作

参数：

  • hFile ： 要解锁的文件句柄
  • dwFileOffsetLow 和 dwFileOffsetHigh： 解锁操作的起始偏移量（以字节为单位）。由于文件大小可能超过 4GB，因此需要使用两个参数表示完整的偏移量
  • nNumberOfBytesToUnlockLow 和 nNumberOfBytesToUnlockHigh： 要解锁的字节数。同样地，这些参数也需要使用两个参数表示完整的字节数

7.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
#include <windows.h>
#include <stdio.h>

int main() {
    HANDLE file_handle;
    DWORD bytes_written;
    OVERLAPPED overlapped = {0};
    DWORD offset = 0;
    DWORD length = 0;
    BOOL status;

    // 打开指定文件并获取文件句柄
    file_handle = CreateFile("test.txt", GENERIC_WRITE, 0, NULL, CREATE_ALWAYS,
                             FILE_ATTRIBUTE_NORMAL, NULL);
    if (file_handle == INVALID_HANDLE_VALUE) 
    {
        printf("Failed to open file\n");
        return 1;
    }

    // 将字符串写入文件
    const char *data = "Hello, world!";
    status = WriteFile(file_handle, data, strlen(data), &bytes_written, &overlapped);
    if (!status) 
    {
        printf("Failed to write to file\n");
        CloseHandle(file_handle);
        return 1;
    }

    // 锁定文件的前半部分
    length = GetFileSize(file_handle, NULL) / 2;
    status = LockFile(file_handle, offset, 0, length, 0);
    if (!status) 
    {
        printf("Failed to lock file\n");
        CloseHandle(file_handle);
        return 1;
    }

    printf("File locked successfully\n");

    // 解锁文件的前半部分
    status = UnlockFile(file_handle, offset, 0, length, 0);
    if (!status) 
        printf("Failed to unlock file\n");
    else 
        printf("File unlocked successfully\n");

    // 关闭文件句柄并返回
    CloseHandle(file_handle);
    return 0;
}

在上面的示例代码中，

  • 我们首先使用 Windows API 中的 CreateFile() 函数打开名为 test.txt 的文件，并获取其文件句柄；
  • 然后，我们使用 WriteFile() 函数将字符串写入文件；
  • 接着，我们使用 LockFile() 函数对文件进行锁定操作，并使用 UnlockFile() 函数进行解锁操作；
  • 最后，我们关闭文件句柄并退出程序。

注意：在使用 UnlockFile() 函数时，需要确保已经使用 CreateFile() 或其他文件打开函数打开了文件，并获得了有效的文件句柄。

7.3 运行结果

参考

  1. [API Reference Document]
  2. [LockFile function]
开发语言-C

C语言函数大全--t 开头的函数

总览

函数声明 函数功能
double tan(double x) 计算 以弧度 x 为单位的角度的正切值（double）
float tanf(float x) 计算 以弧度 x 为单位的角度的正切值（float）
long double tanl(long double x) 计算 以弧度 x 为单位的角度的正切值（long double）
double tanh(double x); 计算 x 的双曲正切值（double）
float tanhf(float x); 计算 x 的双曲正切值（float）
long double tanhl(long double x); 计算 x 的双曲正切值（long double）
off_t tell(int fd); 用于返回文件指针当前位置相对于文件开头的偏移量
long int telldir(DIR *dirp); 获取目录流的当前位置
int textheight(char *string); 用于获取当前文本模式下字符的高度
int textwidth(char *string); 用于获取当前文本模式下字符的宽度
time_t time(time_t *timer); 可以用于获取从 1970 年 1 月 1 日 00:00:00 UTC 到当前时间的秒数
FILE *tmpfile(void); 可以用于在临时目录中创建一个唯一的临时文件，并返回文件指针
char *tmpnam(char *s); 用于创建一个唯一的临时文件名
int toascii(int c); 将一个字符转换为其对应的 ASCII 码值
int tolower(int c); 可以用于将一个 ASCII 字符转换为小写字母
int toupper(int c); 可以用于将一个 ASCII 字符转换为大写字母
double trunc(double x); 截取 x 的小数部分，并返回整数部分（double）
float truncf(float x); 截取 x 的小数部分，并返回整数部分（float）
long double truncl(long double x); 截取 x 的小数部分，并返回整数部分（long double）
void tzset(void); 可以用于设置时区信息
double tgamma(double x); 用于计算 Gamma 函数（double）
float tgammaf(float x); 用于计算 Gamma 函数（float）
long double tgammal(long double x); 用于计算 Gamma 函数（long double）

1. tan，tanf，tanl

1.1 函数说明

函数声明 函数功能
double tan(double x) 计算 以弧度 x 为单位的角度的正切值（double）
float tanf(float x) 计算 以弧度 x 为单位的角度的正切值（float）
long double tanl(long double x) 计算 以弧度 x 为单位的角度的正切值（long double）

1.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#include <stdio.h>
#include <math.h>

int main() 
{
    double x = 45.0;
    double tan_value = tan(x * M_PI / 180.0);
    printf("The tangent of %lf degrees is %lf\n", x, tan_value);

    float xf = 60.0f;
    float tan_valuef = tanf(xf * M_PI / 180.0f);
    printf("The tangent of %f degrees is %f\n", xf, tan_valuef);

    long double xL = 30.0l;
    long double tan_valueL = tanl(xL * M_PI / 180.0l);
    printf("The tangent of %Lf degrees is %Lf\n", xL, tan_valueL);
    return 0;
}

1.3 运行结果

2. tanh，tanhf，tanhl

2.1 函数说明

函数声明 函数功能
double tanh(double x); 计算 x 的双曲正切值（double）
float tanhf(float x); 计算 x 的双曲正切值（float）
long double tanhl(long double x); 计算 x 的双曲正切值（long double）

2.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#include <stdio.h>
#include <math.h>

int main() 
{
    double x = 1.0;
    double tan_value = tanh(x);
    printf("%lf 的双曲正切值是 %lf\n", x, tan_value);

    float y = 2.0f;
    float tanh_value = tanhf(y);
    printf("%f 的双曲正切值是 %f\n", y, tanh_value);

    long double z = 3.0l;
    long double tanhl_value = tanhl(z);
    printf("%Lf 的双曲正切值是 %Lf\n", z, tanhl_value);

    return 0;
}

2.3 运行结果

3. tell

3.1 函数说明

函数声明 函数功能
off_t tell(int fd); 用于返回文件指针当前位置相对于文件开头的偏移量

参数：

  • fd ： 是文件描述符，表示要查询的文件

3.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>

int main() 
{
    char buf[100];
    int fd = open("test.txt", O_RDONLY);
    off_t offset = tell(fd);
    printf("当前的文件偏移量是 %ld\n", offset);

    int nread = read(fd, buf, sizeof(buf));
    offset = tell(fd);
    printf("读取了 %d 个字节后，文件偏移量是 %ld\n", nread, offset);

    close(fd);
    return 0;
}

在上面这个示例中，

  • 首先我们打开了一个名为 test.txt 的文件，并使用 tell() 函数获取了当前的文件偏移量。
  • 然后我们用 read() 函数读取了一些数据,并再次使用 tell() 函数来获取新的文件偏移量。
  • 最后我们使用 close() 函数关闭文件。

注意：tell() 函数和 lseek 函数的功能类似，但有一个重要的区别：tell() 函数只用于查询当前位置，而不能修改文件指针的位置。如果要修改文件指针的位置，请使用 lseek() 函数。

下面我们来看看，使用 lseek() 函数来演示上面的 tell() 函数的示例 ：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>

int main() 
{
    char buf[100];
    int fd = open("test.txt", O_RDONLY);
    off_t offset = lseek(fd, 0, SEEK_CUR);
    printf("当前的文件偏移量是 %ld\n", offset);

    int nread = read(fd, buf, sizeof(buf));
    offset = lseek(fd, 0, SEEK_CUR);
    printf("读取了 %d 个字节后，文件偏移量是 %ld\n", nread, offset);

    close(fd);
    return 0;
}

3.3 运行结果


4. telldir

4.1 函数说明

函数声明 函数功能
long int telldir(DIR *dirp); 获取目录流的当前位置

参数：

  • dirp ： 指向 DIR 类型结构体的指针

4.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
#include <stdio.h>
#include <dirent.h>

int main() 
{
    DIR *dirp;
    struct dirent *direntp;

    // 打开当前工作目录
    dirp = opendir(".");

    if (dirp == NULL) 
    {
        printf("无法打开目录。\n");
        return 1;
    }

    // 遍历目录下的所有文件和子目录
    while ((direntp = readdir(dirp)) != NULL) 
    {
        printf("%s\n", direntp->d_name);
    }

    closedir(dirp);

    return 0;
}

4.3 运行结果

5. textheight，textwidth

5.1 函数说明

函数声明 函数功能
int textheight(char *string); 用于获取当前文本模式下字符的高度
int textwidth(char *string); 用于获取当前文本模式下字符的宽度

参数：

  • string ： 要查询的字符串

5.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#include <graphics.h>

int main() {
   initwindow(640, 480, "Example");
   char str[] = "Hello, world!";
   int height = textheight(str); // 当前文本模式下字符的高度
   int width = textwidth(str); // 当前文本模式下字符的宽度
   outtextxy(100, 100, str);
   outtextxy(100, 120, "Height: ");
   outtextxy(170, 120, itoa(height, str, 10));
   outtextxy(100, 140, "Width: ");
   outtextxy(170, 140, itoa(width, str, 10));
   getch();
   closegraph();
   return 0;
}

5.3 运行结果

6. time

6.1 函数说明

函数声明 函数功能
time_t time(time_t *timer); 可以用于获取从 1970 年 1 月 1 日 00:00:00 UTC 到当前时间的秒数

参数：

  • timer ： 一个指向 time_t 类型对象的指针，如果不想使用此参数，可以将它设置为 NULL

6.2 演示示例

1
2
3
4
5
6
7
8
9
10
#include <stdio.h>
#include <time.h>

int main() 
{
    time_t curtime;
    time(&curtime);
    printf("当前时间是 %s", ctime(&curtime));
    return 0;
}

在上面的示例中，

  • 首先我们使用 time() 函数来获取当前时间的秒数；
  • 然后使用 ctime() 函数将其转换为可读的日期和时间格式；
  • 最后，再用将日期和时间字符串输出到标准输出流中。

6.3 运行结果

7. tmpfile

7.1 函数说明

函数声明 函数功能
FILE *tmpfile(void); 可以用于在临时目录中创建一个唯一的临时文件，并返回文件指针

7.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#include <stdio.h>

int main() 
{
    FILE *fp;
    char str[60];

    fp = tmpfile();
    if (fp == NULL) 
    {
        perror("打开临时文件失败");
        return 1;
    }

    fputs("这是一个临时文件", fp);
    rewind(fp);
    fgets(str, sizeof(str), fp);
    printf("从临时文件读取的内容是： %s", str);

    fclose(fp);
    return 0;
}

在上述的示例中，

  • 首先我们使用 tmpfile() 函数创建一个临时文件；
  • 接着使用 fputs() 函数将字符串 "这是一个临时文件" 写入该文件；
  • 然后，我们使用 rewind() 函数将文件指针移动到文件开始处；
  • 再接着，使用 fgets() 函数从临时文件中读取数据并将其存储到字符串数组 str 中；
  • 最后，我们输出从临时文件中读取的数据，并关闭临时文件。

注意： 使用 tmpfile() 创建的临时文件只在程序运行期间存在，并在程序终止时自动删除。如果需要在程序运行期间保留临时文件，请使用 tmpnam() 或 mkstemp() 等函数来创建文件。

7.3 运行结果

8. tmpnam

8.1 函数说明

函数声明 函数功能
char *tmpnam(char *s); 用于创建一个唯一的临时文件名

参数：

  • s ： 一个指向字符数组的指针，用于存储临时文件名。如果 s 等于 NULL，则函数会返回指向静态内存区的指针，该内存区包含了唯一的临时文件名

8.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
#include <stdio.h>

int main() 
{
    char tmpname[L_tmpnam];
    char *filename;

    filename = tmpnam(tmpname);
    printf("临时文件名是：%s\n", filename);

    return 0;
}

在上面的示例中，

  • 我们首先使用 tmpnam() 函数创建一个唯一的临时文件名；
  • 然后将其存储到字符数组 tmpname 中；
  • 最后，我们输出该临时文件名。

注意： 使用 tmpnam() 创建的临时文件名只在程序运行期间存在，不具有真正唯一性，因此可能存在一定程度的风险。如果需要创建一个具有真正唯一性的临时文件，请考虑使用 mkstemp() 或类似的函数。

8.3 运行结果

9. toascii

9.1 函数说明

函数声明 函数功能
int toascii(int c); 将一个字符转换为其对应的 ASCII 码值

参数：

  • c ： 要转换的字符

9.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include <stdio.h>
#include <ctype.h>

int main() 
{
    char ch = 'A';

    // 将字符转换为其对应的 ASCII 码值
    int ascii_val = toascii(ch);

    printf("字符 %c 的 ASCII 码值为 %d\n", ch, ascii_val);

    return 0;
}

注意 ： toascii() 函数已经过时，不建议在新代码中使用。在 C99 标准中，改用更安全的 isascii() 函数来检查字符是否为 7-bit ASCII 字符，并使用位掩码操作或其他算法来将非 ASCII 字符转换为相应的 7-bit ASCII 码值。

知识点： 7-bit ASCII，也称为美国信息交换标准代码 (American Standard Code for Information Interchange)，是一种基于英语的字符编码系统，使用 7 个二进制位（即一个字节）表示每个字符。它涵盖了拉丁字母、数字、标点符号和一些特殊符号，共计 128 个字符。

9.3 运行结果

10. tolower

10.1 函数说明

函数声明 函数功能
int tolower(int c); 可以用于将一个 ASCII 字符转换为小写字母

参数：

  • c ： 要转换的字符

10.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#include <stdio.h>
#include <ctype.h>

int main() 
{
    char str[] = "Hello, World!";
    int i = 0;

    printf("转换前字符串： %s\n", str);

    printf("转换后字符串： ");
    while (str[i]) {
        putchar(tolower(str[i]));
        i++;
    }

    return 0;
}

10.3 运行结果

11. toupper

11.1 函数说明

函数声明 函数功能
int toupper(int c); 可以用于将一个 ASCII 字符转换为大写字母

参数：

  • c ： 要转换的字符

11.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#include <stdio.h>
#include <ctype.h>

int main() 
{
    char str[] = "Hello, World!";
    int i = 0;

    printf("转换前字符串： %s\n", str);

    printf("转换后字符串： ");
    while (str[i]) {
        putchar(toupper(str[i]));
        i++;
    }

    return 0;
}

11.3 运行结果

12. trunc，truncf，truncl

12.1 函数说明

函数声明 函数功能
double trunc(double x); 截取 x 的小数部分，并返回整数部分（double）
float truncf(float x); 截取 x 的小数部分，并返回整数部分（float）
long double truncl(long double x); 截取 x 的小数部分，并返回整数部分（long double）

12.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#include <stdio.h>
#include <math.h>

int main() 
{
    double x = 3.14159;
    float y = 2.71828f;
    long double z = 1.41421356L;

    // 截去 double 类型浮点数的小数部分
    double a = trunc(x);

    // 截去 float 类型浮点数的小数部分
    float b = truncf(y);

    // 截去 long double 类型浮点数的小数部分
    long double c = truncl(z);

    printf("double 类型 %.5lf 的整数部分为 %.0lf\n", x, a);
    printf("float 类型 %.5f 的整数部分为 %.0f\n", y, b);
    printf("long double 类型 %.8Lf 的整数部分为 %.0Lf\n", z, c);

    return 0;
}

12.3 运行结果

13. tzset

13.1 函数说明

函数声明 函数功能
void tzset(void); 可以用于设置时区信息

13.2 演示示例

UNIX/Linux 下示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

#define _XOPEN_SOURCE 700

int main() 
{
    time_t rawtime;
    struct tm *timeinfo;

    // 设置时区为 UTC
    setenv("TZ", "UTC", 1);
    tzset();

    time(&rawtime);
    timeinfo = localtime(&rawtime);
    printf("当前时间是：%s", asctime(timeinfo));

    return 0;
}

windows 下示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
#include <stdio.h>
#include <windows.h>
#include <time.h>

int main()
{
    time_t rawtime;
    struct tm *timeinfo;

    TIME_ZONE_INFORMATION tzinfo;
    GetTimeZoneInformation(&tzinfo);

    // 将 WCHAR* 转换为 char*
    int len = WideCharToMultiByte(CP_UTF8, 0, tzinfo.StandardName, -1, NULL, 0, NULL, NULL);
    char* standard_name = (char*) malloc(len * sizeof(char));
    WideCharToMultiByte(CP_UTF8, 0, tzinfo.StandardName, -1, standard_name, len, NULL, NULL);

    _putenv_s("TZ", standard_name);
    tzset();

    time(&rawtime);
    timeinfo = localtime(&rawtime);
    printf("当前时间是：%s", asctime(timeinfo));

    free(standard_name);
    return 0;
}

在上述示例代码中，

  • 首先定义变量 rawtime 和 timeinfo，分别用于存储当前时间和时间结构体。
  • 接着使用 GetTimeZoneInformation() 函数获取当前系统时区信息，并将其存储在 tzinfo 变量中。
  • 然后使用 WideCharToMultiByte() 函数将 tzinfo.StandardName 转换为 UTF-8 编码的字符串，并将其存储在 standard_name 变量中。
  • 再接着使用 putenv_s() 函数将 standard_name 设置为环境变量 TZ 的值，并使用 tzset 函数更新本地时区信息。
  • 再然后使用 localtime() 函数将 rawtime 转换为时间结构体 timeinfo。
  • 之后使用 asctime() 函数将时间结构体 timeinfo 转换为字符串格式，并输出到标准输出流中。
  • 最后释放 standard_name 分配的内存空间，并正常结束程序。

13.3 运行结果

14. tgamma，tgammaf，tgammal

14.1 函数说明

函数声明 函数功能
double tgamma(double x); 用于计算 Gamma 函数（double）
float tgammaf(float x); 用于计算 Gamma 函数（float）
long double tgammal(long double x); 用于计算 Gamma 函数（long double）

14.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#include <stdio.h>
#include <math.h>

int main() 
{
    double x = 5.0;
    float y = 7.2f;
    long double z = 2.5L;

    double result1 = tgamma(x);
    float result2 = tgammaf(y);
    long double result3 = tgammal(z);

    printf("tgamma(%lf) = %lf\n", x, result1);
    printf("tgammaf(%f) = %f\n", y, result2); 
    printf("tgammal(%Lf) = %Lf\n", z, result3);

    return 0;
}

知识点： 伽玛函数（Gamma 函数），也叫欧拉第二积分，是阶乘函数在实数与复数上扩展的一类函数。

14.3 运行结果

参考

  1. [API Reference Document]
  2. [ASCII]
开发语言-C

C语言函数大全--s 开头的函数（4）

总览

函数声明 函数功能
char * strdup(const char *s); 用于将一个以 NULL 结尾的字符串复制到新分配的内存空间中
int stricmp(const char *s1, const char *s2); 用于比较两个字符串的字母序是否相等，忽略大小写
char *strerror(int errnum); 用于将指定的错误码转换为相应的错误信息
int strcmpi(const char *s1, const char *s2); 用于比较两个字符串的字母序是否相等，忽略大小写
int strncmp(const char *s1, const char *s2, size_t n); 用于比较两个字符串的前n个字符是否相等
int strncmpi(const char *s1, const char *s2, size_t n); 用于比较两个字符串的前n个字符是否相等，忽略大小写
char *strncpy(char *dest, const char *src, size_t n); 用于将一个字符串的一部分拷贝到另一个字符串中
int strnicmp(const char *s1, const char *s2, size_t n); 用于比较两个字符串的前n个字符是否相等，忽略大小写
char *strnset(char *str, int c, size_t n); 用于将一个字符串的前n个字符都设置为指定的字符
char *strpbrk(const char *str1, const char *str2); 用于在一个字符串中查找任意给定字符集合中的字符的第一次出现位置
char *strrchr(const char *str, int character); 在给定的字符串中查找指定字符的最后一个匹配项
char *strrev(char *str); 将给定字符串中的所有字符顺序颠倒，并返回颠倒后的字符串
char *strset(char *str, int character); 用于设置给定字符串中的所有字符为指定的值，并返回修改后的字符串
size_t strspn(const char *str1, const char *str2); 计算字符串 str1 中包含在字符串 str2 中的前缀子字符串长度，并返回该长度值
char *strstr(const char *str1, const char *str2); 在字符串 str1 中查找第一个出现的字符串 str2，如果找到了，则返回指向该位置的指针；否则，返回 NULL
double strtod(const char *str, char **endptr); 将字符串 str 转换为一个浮点数（double 类型），并返回该浮点数。如果发生了转换错误，则返回 0.0，并且可以通过 endptr 指针返回指向第一个无法转换的字符的指针。
char *strtok(char *str, const char *delim); 用于将一个字符串分割成多个子字符串
long int strtol(const char *str, char **endptr, int base); 将字符串 str 转换为一个长整型数（long int 类型）
char *strupr(char *str); 将字符串 str 中的所有小写字母转换为大写字母，并返回指向该字符串的指针
void swab(const void *src, void *dest, ssize_t nbytes); 将源缓冲区中的每两个相邻字节进行互换，然后将结果存储到目标缓冲区中
int system(const char *command); 执行一个 shell 或 cmd 命令，并等待命令的完成

1. strdup

1.1 函数说明

函数声明 函数功能
char * strdup(const char *s); 用于将一个以 NULL 结尾的字符串复制到新分配的内存空间中

注意： strdup() 函数返回指向新分配的内存空间的指针，如果空间不足则返回 NULL。调用者负责释放返回的指针所指向的内存空间。 strdup() 函数与strcpy() 函数类似，但是它会动态地分配内存空间，而 strcpy() 需要调用者提供足够大的目标缓冲区。

1.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

int main() 
{
    char *source = "Hello World!";
    char *destination = strdup(source);
    
    if(destination != NULL) 
    {
        printf("Original string: %s\n", source);
        printf("Duplicated string: %s\n", destination);
        free(destination); // 释放内存，避免内存泄漏
    }
    
    return 0;
}

1.3 运行结果

2. stricmp

2.1 函数说明

函数声明 函数功能
int stricmp(const char *s1, const char *s2); 用于比较两个字符串的字母序是否相等，忽略大小写

返回值：

  • 如果 s1 和 s2 代表的字符串相等（忽略大小写），则返回 0；
  • 如果 s1 比 s2 小，则返回负数；
  • 如果 s1 比 s2 大，则返回正数。

2.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
#include <stdio.h>
#include <string.h>

int main() 
{
    char *s1 = "Hello";
    char *s2 = "hElLo";
    
    int result = stricmp(s1, s2); // 忽略大小写比较
    
    if(result == 0) 
    {
        printf("The strings are equal.\n");
    } 
    else if(result < 0) 
    {
        printf("%s is less than %s.\n", s1, s2);
    }
    else 
    {
        printf("%s is greater than %s.\n", s1, s2);
    }
    
    return 0;
}

2.3 运行结果

3. strerror

3.1 函数说明

函数声明 函数功能
char *strerror(int errnum); 用于将指定的错误码转换为相应的错误信息

参数：

  • errnum ： 要转换为错误信息的错误码，通常是由系统调用或库函数返回的错误码。

返回值：
指向错误信息字符串的指针，该字符串描述了与错误码相关的错误

3.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#include <stdio.h>
#include <string.h>
#include <errno.h>

int main() 
{
    FILE *file = fopen("nonexistent.txt", "r");
    
    if(file == NULL) 
    {
        int errcode = errno; // 获取发生的错误码
        printf("Error opening file: %s\n", strerror(errcode)); // 将错误码转换为错误信息并打印
    } 
    else 
    {
        printf("File opened successfully.\n");
        fclose(file);
    }
    
    return 0;
}

3.3 运行结果

4. strcmpi

4.1 函数说明

函数声明 函数功能
int strcmpi(const char *s1, const char *s2); 用于比较两个字符串的字母序是否相等，忽略大小写

返回值：

  • 如果 s1 和 s2 代表的字符串相等（忽略大小写），则返回 0；
  • 如果 s1 比 s2 小，则返回负数；
  • 如果 s1 比 s2 大，则返回正数。

4.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
#include <stdio.h>
#include <string.h>

int main() 
{
    char *s1 = "Hello";
    char *s2 = "hElLo";
    
    int result = strcmpi(s1, s2); // 忽略大小写比较
    
    if(result == 0) 
    {
        printf("The strings are equal.\n");
    } 
    else if(result < 0) 
    {
        printf("%s is less than %s.\n", s1, s2);
    } 
    else 
    {
        printf("%s is greater than %s.\n", s1, s2);
    }
    
    return 0;
}

看到这里，可能会疑惑 上面不是已经有了 忽略大小写的字符串比较了嘛？

那 strcmpi 和 stricmp 有什么区别呢？

虽然它们的实现功能相同，但是不同的编译器或操作系统可能会提供其中一个或两个函数。在具备这两个函数的系统中，strcmpi 常常作为 VC（Visual C++）和 Borland C++ 的扩展库函数，而 stricmp 则是 POSIX 标准中定义的函数，在许多 类UNIX系统 上可用。因此，如果需要编写可移植的代码，则应该使用 stricmp 函数，而不是 strcmpi 函数。

4.3 运行结果

5. strncmp

5.1 函数说明

函数声明 函数功能
int strncmp(const char *s1, const char *s2, size_t n); 用于比较两个字符串的前n个字符是否相等

参数：

  • s1 ： 待比较的第一个字符串
  • s2 ： 待比较的第二个字符串
  • n ： 要比较的字符数

返回值：

  • 如果 s1 和 s2 代表的字符串相等（忽略大小写），则返回 0；
  • 如果 s1 比 s2 小，则返回负数；
  • 如果 s1 比 s2 大，则返回正数。

5.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
#include <stdio.h>
#include <string.h>

int main() 
{
    char *s1 = "Hello World";
    char *s2 = "Hell!";
    
    int result = strncmp(s1, s2, 4); // 比较前4个字符
    
    if(result == 0) 
    {
        printf("The first 4 characters are equal.\n");
    } 
    else if(result < 0) 
    {
        printf("The first 4 characters of %s are less than %s.\n", s1, s2);
    } 
    else 
    {
        printf("The first 4 characters of %s are greater than %s.\n", s1, s2);
    }
    
    return 0;
}

5.3 运行结果

6. strncmpi

6.1 函数说明

函数声明 函数功能
int strncmpi(const char *s1, const char *s2, size_t n); 用于比较两个字符串的前n个字符是否相等，忽略大小写

参数：

  • s1 ： 待比较的第一个字符串
  • s2 ： 待比较的第二个字符串
  • n ： 要比较的字符数

返回值：

  • 如果 s1 和 s2 代表的字符串相等（忽略大小写），则返回 0；
  • 如果 s1 比 s2 小，则返回负数；
  • 如果 s1 比 s2 大，则返回正数。

6.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
#include <stdio.h>
#include <string.h>

int main() 
{
    char *s1 = "Hello World";
    char *s2 = "heLL!";
    
    int result = strncmpi(s1, s2, 4); // 比较前4个字符，忽略大小写
    
    if(result == 0) 
    {
        printf("The first 4 characters are equal (case insensitive).\n");
    } 
    else if(result < 0) 
    {
        printf("The first 4 characters of %s are less than %s (case insensitive).\n", s1, s2);
    } 
    else 
    {
        printf("The first 4 characters of %s are greater than %s (case insensitive).\n", s1, s2);
    }
    
    return 0;
}

注意： strncmpi 函数不是 C 语言标准库中的函数，但在某些编译器或操作系统中可能会提供。

7. strncpy

7.1 函数说明

函数声明 函数功能
char *strncpy(char *dest, const char *src, size_t n); 用于将一个字符串的一部分拷贝到另一个字符串中

参数：

  • dest ： 目标字符串
  • src ： 源字符串
  • n ： 要拷贝的字符数

7.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include <stdio.h>
#include <string.h>

int main() 
{
    char dest[20];
    const char *src = "Hello";
    
    strncpy(dest, src, 8); // 拷贝前8个字符
    
    printf("The copied string is: %s\n", dest);
    
    return 0;
}

当源字符串长度小于 n 时，strncpy() 函数将在目标字符串的末尾填充 \0 字符以达到指定的拷贝长度 n

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#include <stdio.h>
#include <string.h>

int main() 
{
    char dest[6];
    const char *src = "Hello World";
    
    strncpy(dest, src, 5); // 拷贝前5个字符
    
    dest[5] = '\0'; // 手动添加末尾的\0字符
    
    printf("The copied string is: %s\n", dest);
    
    return 0;
}

如果源字符串长度大于等于 n 个字符，strncpy() 函数将会拷贝源字符串的前 n 个字符到目标字符串中，并且不会自动添加末尾的 \0 字符。这种情况下，目标字符串可能不是以 \0 字符结尾，因此需要手动在拷贝后的目标字符串中添加 \0 字符。

7.3 运行结果

8. strnicmp

8.1 函数说明

函数声明 函数功能
int strnicmp(const char *s1, const char *s2, size_t n); 用于比较两个字符串的前n个字符是否相等，忽略大小写

参数：

  • s1 ： 待比较的第一个字符串
  • s2 ： 待比较的第二个字符串
  • n ： 要比较的字符数

返回值：

  • 如果 s1 和 s2 代表的字符串相等（忽略大小写），则返回 0；
  • 如果 s1 比 s2 小，则返回负数；
  • 如果 s1 比 s2 大，则返回正数。

8.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
#include <stdio.h>
#include <string.h>

int main() 
{
    const char *s1 = "Hello World";
    const char *s2 = "heLL!";
    
    int result = strnicmp(s1, s2, 4); // 比较前4个字符，忽略大小写
    
    if(result == 0) 
    {
        printf("The first 4 characters are equal (case insensitive).\n");
    } 
    else if(result < 0) 
    {
        printf("The first 4 characters of %s are less than %s (case insensitive).\n", s1, s2);
    } 
    else 
    {
        printf("The first 4 characters of %s are greater than %s (case insensitive).\n", s1, s2);
    }
    
    return 0;
}

8.3 运行结果

9. strnset

9.1 函数说明

函数声明 函数功能
char *strnset(char *str, int c, size_t n); 用于将一个字符串的前n个字符都设置为指定的字符

参数：

  • str： 要进行操作的字符串
  • c： 要设置的字符
  • n ： 要设置的字符数

9.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
#include <stdio.h>
#include <string.h>

int main() {
    char str[20] = "Hello World";
    printf("Before: %s\n", str);

    strnset(str, '*', 5); // 将前5个字符都设置为*

    printf("After: %s\n", str);

    return 0;
}

注意： strnset() 函数是非标准函数，并不是所有的编译器和操作系统都支持该函数。如果需要跨平台兼容，请使用标准库函数 memset() 来实现类似的功能

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include <stdio.h>
#include <string.h>

int main() 
{
    char str[20] = "Hello World";
    printf("Before: %s\n", str);

    memset(str, '*', 5); // 将前5个字符都设置为*

    printf("After: %s\n", str);

    return 0;
}

上述示例使用了标准库函数 memset 来将 str 的前 5 个字符都设置为 *

9.3 运行结果

10. strpbrk

10.1 函数说明

函数声明 函数功能
char *strpbrk(const char *str1, const char *str2); 用于在一个字符串中查找任意给定字符集合中的字符的第一次出现位置

参数：

  • str1 ： 要进行搜索的字符串
  • str2 ： 要查找的字符集合

注意： 如果在str1中没有找到str2中的任何字符，则 strpbrk 函数返回NULL 指针

10.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#include <stdio.h>
#include <string.h>

int main() 
{
    char str[] = "Hello World";
    char *ptr;

    ptr = strpbrk(str, "aeiou"); // 查找元音字母

    if (ptr != NULL) 
    {
        printf("Found vowel '%c' at position: %lld\n", *ptr, ptr - str + 1);
    } 
    else 
    {
        printf("No vowel found.\n");
    }

    return 0;
}

10.3 运行结果

11. strrchr

11.1 函数说明

函数声明 函数功能
char *strrchr(const char *str, int character); 在给定的字符串中查找指定字符的最后一个匹配项

参数：

  • str ： 要进行搜索的字符串
  • character ： 要查找的字符，其 ASCII 值由整数表示

返回值：

  • 如果匹配到，返回匹配字符的地址；
  • 如果没有找到匹配项，则返回 NULL。

11.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
#include <stdio.h>
#include <string.h>

int main () 
{
    const char str[] = "Hello World!";

    printf("在 '%s' 中查找字符 'o' 的最后一次出现：\n", str);
    char *last_o = strrchr(str, 'o');

    if (last_o) 
        printf("最后一个 'o' 的位置：%lld\n", last_o - str);
    else 
        printf("未找到匹配的字符。\n");

    printf("在 '%s' 中查找字符 'w' 的最后一次出现：\n", str);
    char *last_w = strrchr(str, 'w');

    if (last_w) 
        printf("最后一个 'w' 的位置：%lld\n", last_w - str);
    else 
        printf("未找到匹配的字符。\n");

    return 0;
}

11.3 运行结果

12. strrev

12.1 函数说明

函数声明 函数功能
char *strrev(char *str); 将给定字符串中的所有字符顺序颠倒，并返回颠倒后的字符串

参数：

  • str ： 要反转的的字符串

注意：因为 strrev() 函数是一个非标准的库函数，许多编译器可能并不支持该函数，所以在使用该函数之前，请确保你的编译器支持它。

12.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include <stdio.h>
#include <string.h>

int main () 
{
    char str[50];

    printf("输入一个字符串：");
    scanf("%s", str);

    printf("原始字符串：%s\n", str);
    printf("反转后的字符串：%s\n", strrev(str));

    return 0;
}

12.3 运行结果

13. strset

13.1 函数说明

函数声明 函数功能
char *strset(char *str, int character); 用于设置给定字符串中的所有字符为指定的值，并返回修改后的字符串

参数：

  • str ： 要修改的字符串
  • character ： 要设置的字符，其 ASCII 值由整数表示

13.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include <stdio.h>
#include <string.h>

int main () 
{
    char str[50];

    printf("请输入一个字符串：");
    scanf("%s", str);

    printf("原始字符串：%s\n", str);
    printf("将所有字符设置为 'X' 后的字符串：%s\n", strset(str, 'X'));

    return 0;
}

13.3 运行结果

14. strspn

14.1 函数说明

函数声明 函数功能
size_t strspn(const char *str1, const char *str2); 计算字符串 str1 中包含在字符串 str2 中的前缀子字符串长度，并返回该长度值

参数：

  • str1 ： 要搜索的字符串
  • str2 ： 包含要搜索的字符集合的 字符串

14.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include <stdio.h>
#include <string.h>

int main () 
{
    const char str[] = "Hello World!";
    const char charset[] = "lHeoWrd";

    size_t length = strspn(str, charset);

    printf("在 '%s' 中，最长的前缀子串 '%s' 包含于 '%s' 中。长度为 %zu\n", 
          str, strndup(str, length), charset, length);

    return 0;
}

上述示例代码运行后，如果出现 error: 'strndup' was not declared in this scope ，说明当前的编译器不支持 strndup() 函数。

因为 strndup() 函数是 C11 新增的函数，因此可能不是所有编译器都支持。

那我们就用如下的方式来替换一下 :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main () 
{
   const char str[] = "Hello World!";
   const char charset[] = "lHeoWrd";
   
   size_t length = strspn(str, charset);

   char *substr = (char *)malloc(length + 1);
   memcpy(substr, str, length);
   substr[length] = '\0';

   printf("在 '%s' 中，最长的前缀子串 '%s' 包含于 '%s' 中。长度为 %zu\n", 
          str, substr, charset, length);

   free(substr);
   return 0;
}

14.3 运行结果

15. strstr

15.1 函数说明

函数声明 函数功能
char *strstr(const char *str1, const char *str2); 在字符串 str1 中查找第一个出现的字符串 str2，如果找到了，则返回指向该位置的指针；否则，返回 NULL

参数：

  • str1 ： 源字符串
  • str2 ： 要查找的子字符串

15.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#include <stdio.h>
#include <string.h>

int main () 
{
    const char str[] = "Hello World!";
    const char substr[] = "World";

    char *result = strstr(str, substr);

    if (result) 
        printf("在 '%s' 中找到了子串 '%s'。子串起始位置是 '%s'\n", str, substr, result);
    else 
        printf("在 '%s' 中未找到子串 '%s'\n", str, substr);

    return 0;
}

15.3 运行结果

16. strtod

16.1 函数说明

函数声明 函数功能
double strtod(const char *str, char **endptr); 将字符串 str 转换为一个浮点数（double 类型），并返回该浮点数。如果发生了转换错误，则返回 0.0，并且可以通过 endptr 指针返回指向第一个无法转换的字符的指针。
参数：
  • str ： 要转换为浮点数的字符串
  • endptr ： 可选参数，用于存储第一个无法转换的字符的指针地址

16.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#include <stdio.h>
#include <stdlib.h>

int main () 
{
    const char str[] = "3.14";
    // const char str[] = "3.1a4";
    // const char str[] = "a3.14";
    char *endptr;

    double num = strtod(str, &endptr);

    printf("输入字符串为 '%s'\n", str);
    printf("转换后的浮点数为 %f\n", num);

    if (endptr == str) 
        printf("无法进行任何转换。\n");
    else if (*endptr != '\0') 
        printf("字符串 '%s' 的末尾非法字符是 '%c'\n", str, *endptr);

    return 0;
}

16.3 运行结果



17. strtok

17.1 函数说明

函数声明 函数功能
char *strtok(char *str, const char *delim); 用于将一个字符串分割成多个子字符串

参数：

  • str ： 要被分割的 字符串。第一次调用时，应该将其设置为要被分割的字符串的地址；以后的调用中，该参数应该为 NULL
  • delim： 分隔符字符集合，用于指定子字符串的分割标准

返回值： 分割后的第一个子字符串，并在每次调用时修改传入的原始字符串 str，使其指向下一个要被分割的子字符串

17.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#include <stdio.h>
#include <string.h>

int main () 
{
    const char str[] = "Hello,World!How are you?";
    const char delim[] = ", !";
    char *token;

    token = strtok((char *)str, delim);

    while (token != NULL) 
    {
        printf("%s\n", token);
        token = strtok(NULL, delim);
    }

    return 0;
}

在上述的示例中，

  • 我们首先定义了字符串 str 和 字符集合 delim ；
  • 然后使用 strtok() 函数将字符串 str 按照字符集合 delim 中的分隔符进行分割。每次调用 strtok() 函数时，它会返回分割出的第一个子字符串，并且会修改 str 指向下一个将要被分割的子字符串。
  • 最后我们不断循环调用 strtok() 函数，并输出返回的每个子字符串，直到没有更多的子字符串可以分割为止

17.3 运行结果

18. strtol

18.1 函数说明

函数声明 函数功能
long int strtol(const char *str, char **endptr, int base); 将字符串 str 转换为一个长整型数（long int 类型）

参数：

  • str ： 要被转换为长整型数的字符串
  • endptr ： 可选参数，用于存储第一个无法转换的字符的指针地址
  • base： 转换的进制数，必须是 2 到 36 之间的有效数字或者 0。为 0 表示采用默认的进制数，即可以解释成合法的整数的最大进制数（一般是 10）

返回值：

  • 如果成功转换，返回一个长整型数；
  • 如果发生了转换错误，则返回 0，并且可以通过 endptr 指针返回指向第一个无法转换的字符的指针。

18.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#include <stdio.h>
#include <stdlib.h>

int main () 
{
    const char str[] = "101011";
    // const char str[] = "10101a1";
    // const char str[] = "a101011";
    char *endptr;

    long int num = strtol(str, &endptr, 2);

    printf("输入字符串为 '%s'\n", str);
    printf("转换后的十进制数为 %ld\n", num);

    if (endptr == str) 
        printf("无法进行任何转换。\n");
    else if (*endptr != '\0') 
        printf("字符串 '%s' 的末尾非法字符是 '%c'\n", str, *endptr);

    return 0;
}

18.3 运行结果



19. strupr

19.1 函数说明

函数声明 函数功能
char *strupr(char *str); 将字符串 str 中的所有小写字母转换为大写字母，并返回指向该字符串的指针

参数：

  • str ： 要进行大小写转换的字符串

19.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
#include <stdio.h>
#include <string.h>

int main () 
{
    char str[] = "Hello, World!";
    printf("原始字符串为 '%s'\n", str);
    strupr(str);
    printf("转换后的字符串为 '%s'\n", str);
    return 0;
}

19.3 运行结果

20. swab

20.1 函数说明

函数声明 函数功能
void swab(const void *src, void *dest, ssize_t nbytes); 将源缓冲区中的每两个相邻字节进行互换，然后将结果存储到目标缓冲区中

参数：

  • str ： 源缓冲区的指针
  • dest ： 目标缓冲区的指针
  • nbytes ： 需要交换的字节数

20.2 演示示例

1
2
3
4
5
6
7
8
9
10
11
12
13
#include <stdio.h>
#include <string.h>
#include <unistd.h>

int main () 
{
    char src[] = "Hello, World!";
    char dest[15];
    printf("原始字符串为 '%s'\n", src);
    swab(src, dest, strlen(src));
    printf("转换后的字符串为 '%s'\n", dest);
    return 0;
}

上面示例中，我在一开始演示时，因为没有加上 #include <unistd.h> 这个头文件，导致出现如下错误：

20.3 运行结果

21. system

21.1 函数说明

函数声明 函数功能
int system(const char *command); 执行一个 shell 或 cmd 命令，并等待命令的完成

参数：

  • command ： 要执行的 shell 或 cmd 命令。

21.2 演示示例

下面演示 执行 ls -l 的 shell 命令，笔者是在 windows环境下运行，故会出错，详见运行结果那里

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#include <stdio.h>
#include <stdlib.h>

int main () 
{
    const char command[] = "ls -l";

    printf("执行命令: '%s'\n", command);

    int status = system(command);

    if (status != 0) 
        printf("执行出错！\n");

    return 0;
}

再来看下，演示使用 dir 命令，在 windows 下可以输出当前目录下的所有文件和子目录

1
2
3
4
5
6
7
8
#include <stdlib.h>

int main () 
{
    const char command[] = "dir";
    system(command);
    return 0;
}

21.3 运行结果