“cpp/string/byte/memcmp”的版本间的差异

来自cppreference.com
< cpp‎ | string‎ | byte
小
小
 
（未显示1个用户的1个中间版本）
第1行： 第1行：
−
{{cpp/title| memcmp}}
+
{{cpp/title|memcmp}}
 
{{cpp/string/byte/navbar}}
 
{{cpp/string/byte/navbar}}
−
{{ddcl | header=cstring |
+
{{ddcl|header=cstring|
 
int memcmp( const void* lhs, const void* rhs, std::size_t count );
 
int memcmp( const void* lhs, const void* rhs, std::size_t count );
 
}}
 
}}
  
−
 转译 {{tt|lhs}} 和 {{tt|rhs}} 所指向的对象为 {{c|unsigned char}} 数组，并比较这些数组的 首 {{tt|count}} 个字节。按字典序比较。
+
 转译 {{|lhs}} 和 {{|rhs}} 所指向的对象为 {{c|unsigned char}} 数组，并比较这些数组的 {{|count}} 个字节。按字典序比较。
  
−
 结果的 符 号是在被比较对象中相异的 首对 字节 的 值（都转译成 {{c|unsigned char}} ）的差。
+
 结果的 号是在被比较对象中 相异的字节值（都转译成 {{c|unsigned char}}）的差 。
  
 
===参数===
 
===参数===
 
{{par begin}}
 
{{par begin}}
−
{{par | lhs, rhs |指向要比较的内存缓冲区的指针}}
+
{{par|lhs, rhs|指向要比较的内存缓冲区的指针}}
−
{{par | count |要检验的字节数}}
+
{{par|count|要检验的字节数}}
 
{{par end}}
 
{{par end}}
  
 
===返回值===
 
===返回值===
−
  若 {{tt|lhs}} 中首个 相异 字节（转译为 {{c|unsigned char}} ）小于 {{tt|rhs}} 中的对应字节 则为 负值。
+
  {{|lhs}} 中首个 字节（转译为 {{c|unsigned char}}）小于 {{|rhs}} 中的对应字节 负值。
  
−
  若 {{tt|lhs}} 和 {{tt|rhs}} 的所有 {{tt|count}} 个字节相等 则为 {{c|0}} 。
+
  {{|lhs}} 和 {{|rhs}} 的所有 {{|count}} 个字节相等 {{c|0}}。
  
−
  若 {{tt|lhs}} 中首个 相异 字节大于 {{tt|rhs}} 中的对应字节 则为 正值。
+
  {{|lhs}} 中首个 字节大于 {{|rhs}} 中的对应字节 正值。
  
 
===注解===
 
===注解===
−
 此函数读取[[c/language/object|对象表示]]，而非对象值，而且典型地只对无填充的可平凡复制对象有意义。例如 二 个 {{lc|std::string}} 或 {{lc|std::vector}} 类型对象间的 {{tt|memcmp()}} 将不比较 其 内容，而 二 个 {{c|struct{char c; int n;}}} 类型对象间的 {{tt|memcmp()}} 将比较填充字节， 其 值在 {{c|c}} 和 {{c|n}} 相同时可以 相异 。
+
 此函数读取[[/language/object|对象表示]]，而非对象值，而且典型地只对无填充的可平凡复制对象有意义。例如 个 {{lc|std::string}} 或 {{lc|std::vector}} 类型对象间的 {{tt|memcmp()}} 将不比较 内容，而 个 {{c|struct {char c; int n;}}} 类型对象间的 {{tt|memcmp()}} 将比较填充字节， 值在 {{c|c}} 和 {{c|n}} 相同时 可以 。
  
 
===示例===
 
===示例===
 
{{example
 
{{example
−
|
+
|code=
−
| code=
+
−
#include <iostream>
+
 
#include <cstring>
 
#include <cstring>
 +
  
 
void demo(const char* lhs, const char* rhs, std::size_t sz)
 
void demo(const char* lhs, const char* rhs, std::size_t sz)
 
{
 
{
−
     std::cout << std::string(lhs, sz);
+
     std::cout << std::string(lhs, sz) ;
 
     int rc = std::memcmp(lhs, rhs, sz);
 
     int rc = std::memcmp(lhs, rhs, sz);
−
     if(rc == 0)
+
     if (rc == 0)
−
         std::cout << " compares equal to ";
+
         std::cout << " ";
−
     else if(rc < 0)
+
     else if (rc < 0)
−
         std::cout << " precedes ";
+
         std::cout << " " ;
−
     else if(rc > 0)
+
     else if (rc > 0)
−
         std::cout << " follows ";
+
         std::cout << " " << std::string(rhs, sz) << \n;
−
    std::cout << std::string(rhs, sz) << " in lexicographical order\n";
+
 
}
 
}
  
第54行： 第52行：
 
     demo(a1, a1, sizeof a1);
 
     demo(a1, a1, sizeof a1);
 
}
 
}
−
| output=
+
|output=
−
abc precedes abd in lexicographical order
+
abc abd
−
abd follows abc in lexicographical order
+
abd abc
−
abc compares equal to abc in lexicographical order
+
abc abc
 
}}
 
}}
  
 
===参阅===
 
===参阅===
 
{{dsc begin}}
 
{{dsc begin}}
−
{{dsc inc | cpp/string/byte/dsc strcmp}}
+
{{dsc inc|cpp/string/byte/dsc strcmp}}
−
{{dsc inc | cpp/string/byte/dsc strncmp}}
+
{{dsc inc|cpp/string/byte/dsc strncmp}}
−
{{dsc see c | c/string/byte/memcmp}}
+
{{dsc see c|c/string/byte/memcmp}}
 
{{dsc end}}
 
{{dsc end}}
  
 
{{langlinks|de|en|es|fr|it|ja|pt|ru}}
 
{{langlinks|de|en|es|fr|it|ja|pt|ru}}

2024年3月9日 (六) 07:30的最后版本

 
C++
 
文本处理库
 
空终止字节字符串
 
在标头 <cstring> 定义
int memcmp( const void* lhs, const void* rhs, std::size_t count );

转译 lhs 和 rhs 所指向的对象为 unsigned char 数组，并比较这些数组的前 count 个字节。按字典序比较。

结果的正负号是在被比较对象中首对相异的字节值（都转译成 unsigned char）的差的正负号。

目录

[编辑] 参数

lhs, rhs - 指向要比较的内存缓冲区的指针
count - 要检验的字节数

[编辑] 返回值

在 lhs 中首个有差别的字节（转译为 unsigned char）小于 rhs 中的对应字节的情况下返回负值。

在 lhs 和 rhs 的所有 count 个字节相等的情况下返回 ​0​。

在 lhs 中首个有差别的字节大于 rhs 中的对应字节的情况下返回正值。

[编辑] 注解

此函数读取对象表示，而非对象值，而且典型地只对无填充的可平凡复制对象有意义。例如两个 std::string 或 std::vector 类型对象间的 memcmp() 将不比较它们的内容，而两个 struct {char c; int n;} 类型对象间的 memcmp() 将比较填充字节，它们的值在 c 和 n 相同时也可以不同，而且即使没有填充字节，可能在考虑端序的情况下比较 int。

[编辑] 示例

运行此代码
#include <cstring>
#include <iostream>
 
void demo(const char* lhs, const char* rhs, std::size_t sz)
{
    std::cout << std::string(lhs, sz) << " 在字典序中";
    int rc = std::memcmp(lhs, rhs, sz);
    if (rc == 0)
        std::cout << "与 " << std::string(rhs, sz) << " 比较相等\n";
    else if (rc < 0)
        std::cout << "先于 " << std::string(rhs, sz) << '\n';
    else if (rc > 0)
        std::cout << "后于 " << std::string(rhs, sz) << '\n';
}
 
int main()
{
    char a1[] = {'a','b','c'};
    char a2[sizeof a1] = {'a','b','d'};
 
    demo(a1, a2, sizeof a1);
    demo(a2, a1, sizeof a1);
    demo(a1, a1, sizeof a1);
}

输出： 

abc 在字典序中先于 abd
abd 在字典序中后于 abc
abc 在字典序中与 abc 比较相等

[编辑] 参阅

 比较两个字符串
(函数) [编辑]
比较两个字符串的一定量字符
(函数) [编辑]
memcmp 的 C 文档
来自“https://zh.cppreference.com/mwiki/index.php?title=cpp/string/byte/memcmp&oldid=88537”