如何在C++中比较两个字符串_C++字符串比较操作指南-C++-PHP中文网

C++中比较字符串需区分std::string和C风格字符串：前者用==、<等运算符或compare()方法，后者用strcmp()或strncmp()函数；注意std::string的比较是基于字符编码值，默认区分大小写，不区分大小写时需转换后再比较；常见错误是误用==比较char*指针内容而非地址，应避免；性能上，运算符更直观适合常规比较，compare()支持子串和三态结果，适用于复杂场景。

如何在c++中比较两个字符串_c++字符串比较操作指南

在C++中比较两个字符串，核心无非是两种情况：判断它们是否完全相同，或者确定它们在字典序上的前后关系。对于现代C++而言，最直观且推荐的方式是使用

std::string

登录后复制

对象及其重载的比较运算符（如

==

登录后复制

、

登录后复制

等）。而如果你的代码还在处理C风格字符串（即

char*

登录后复制

），那么

strcmp

登录后复制

函数就是你的老朋友了。选择哪种方法，完全取决于你手头的数据类型。

解决方案

谈到C++里的字符串比较，我们得区分开两种主要场景：

std::string

登录后复制

对象和C风格字符串（

char*

登录后复制

）。它们的处理方式，虽然目的相似，但底层机制和用法却大相径庭。

std::string

登录后复制

对象的比较

这是C++标准库为我们提供的强大工具，我个人觉得，用起来简直是享受。它封装了内存管理，让我们可以专注于逻辑。

立即学习“C++免费学习笔记（深入）”；

相等性与不等性判断：

==

登录后复制

和
!=
登录后复制
最常用的莫过于判断两个字符串内容是否完全一致。

std::string

登录后复制

重载了

==

登录后复制

和

!=

登录后复制

运算符，用起来就像比较基本数据类型一样自然。它们会逐字符比较，直到发现不同或者字符串结束。

#include <string>
#include <iostream>

int main() {
    std::string s1 = "hello";
    std::string s2 = "hello";
    std::string s3 = "world";

    if (s1 == s2) {
        std::cout << "s1 and s2 are equal." << std::endl; // Output: s1 and s2 are equal.
    }

    if (s1 != s3) {
        std::cout << "s1 and s3 are not equal." << std::endl; // Output: s1 and s3 are not equal.
    }
    return 0;
}

登录后复制

字典序（Lexicographical）比较：

登录后复制

,
>
登录后复制
,
<=
登录后复制
,
>=
登录后复制
如果你需要知道一个字符串在字典序上是排在另一个字符串之前还是之后，这些运算符就派上用场了。它们按照字符的ASCII或Unicode值进行逐个比较，直到找到第一个不同的字符，或者其中一个字符串结束。

#include <string>
#include <iostream>

int main() {
    std::string a = "apple";
    std::string b = "banana";
    std::string c = "apricot";

    if (a < b) {
        std::cout << a << " comes before " << b << std::endl; // Output: apple comes before banana
    }

    if (a > c) { // 'p' == 'p', 'p' > 'r' is false, 'p' < 'r' is true
        std::cout << a << " comes after " << c << std::endl;
    } else {
        std::cout << a << " comes before " << c << std::endl; // Output: apple comes before apricot
    }
    return 0;
}

登录后复制

compare()

登录后复制

方法

std::string

登录后复制

还提供了一个

compare()

登录后复制

方法，它更接近C风格字符串的

strcmp

登录后复制

，返回一个整数值：0表示相等，负数表示当前字符串在字典序上小于参数字符串，正数表示大于。这个方法有多个重载，可以实现子字符串的比较，这在某些特定场景下非常有用。

#include <string>
#include <iostream>

int main() {
    std::string s1 = "programming";
    std::string s2 = "program";

    if (s1.compare(s2) == 0) {
        std::cout << "s1 and s2 are equal." << std::endl;
    } else if (s1.compare(s2) < 0) {
        std::cout << "s1 is lexicographically less than s2." << std::endl;
    } else {
        std::cout << "s1 is lexicographically greater than s2." << std::endl; // Output: s1 is lexicographically greater than s2.
    }

    // 比较子字符串：s1从索引0开始的7个字符与s2比较
    if (s1.compare(0, 7, s2) == 0) {
        std::cout << "First 7 chars of s1 are equal to s2." << std::endl; // Output: First 7 chars of s1 are equal to s2.
    }
    return 0;
}

登录后复制

*2. C风格字符串（`char`）的比较**

如果你还在使用

char

登录后复制

数组或者

char*

登录后复制

指针来表示字符串，那么标准库中的

<cstring>

登录后复制

头文件提供了一系列函数。这里最重要的是，*千万不要直接使用
==
登录后复制
运算符来比较两个`char

指针指向的字符串内容**，因为

登录后复制

==`会比较的是指针的地址，而不是它们所指向的实际字符序列。这是一个非常经典的C/C++错误！

strcmp()

登录后复制

函数

strcmp(const char* s1, const char* s2)

登录后复制

函数用于比较两个以空字符（

\0

登录后复制

）结尾的C风格字符串。

如果
```
s1
```
登录后复制
和
```
s2
```
登录后复制
相等，返回
```
0
```
登录后复制
。
如果
```
s1
```
登录后复制
在字典序上小于
```
s2
```
登录后复制
，返回一个负数。
如果
```
s1
```
登录后复制
在字典序上大于
```
s2
```
登录后复制
，返回一个正数。

#include <cstring> // For strcmp
#include <iostream>

int main() {
    const char* str1 = "apple";
    const char* str2 = "apple";
    const char* str3 = "banana";

    if (strcmp(str1, str2) == 0) {
        std::cout << "str1 and str2 are equal." << std::endl; // Output: str1 and str2 are equal.
    }

    if (strcmp(str1, str3) < 0) {
        std::cout << "str1 comes before str3." << std::endl; // Output: str1 comes before str3.
    }

    // 错误示范：比较指针地址，而不是内容
    if (str1 == str2) {
        // 这通常不会成立，除非它们指向同一个内存地址
        std::cout << "This might be misleading for content comparison." << std::endl;
    }
    return 0;
}

登录后复制

strncmp()

登录后复制

函数

strncmp(const char* s1, const char* s2, size_t n)

登录后复制

函数用于比较两个C风格字符串的前

登录后复制

个字符。这在你需要比较字符串的一部分，或者字符串可能没有空字符终止（但你知道它的最大长度）时非常有用。

#include <cstring> // For strncmp
#include <iostream>

int main() {
    const char* full_str = "programming";
    const char* prefix = "program";

    // 比较full_str的前7个字符和prefix
    if (strncmp(full_str, prefix, 7) == 0) {
        std::cout << "full_str starts with 'program'." << std::endl; // Output: full_str starts with 'program'.
    }
    return 0;
}

登录后复制

C++字符串比较是否区分大小写？如何实现不区分大小写的比较？

是的，C++标准库提供的所有字符串比较操作，无论是

std::string

登录后复制

的运算符重载还是C风格字符串的

strcmp

登录后复制

家族函数，默认都是区分大小写的。这意味着，

"Hello"

登录后复制

和

"Hello"

登录后复制

在它们看来是两个完全不同的字符串。这是因为它们是基于字符的二进制值（通常是ASCII或Unicode编码点）进行比较的，而大写字母和小写字母的编码值是不同的。

那么，如果我们想实现不区分大小写的比较，该怎么办呢？这在很多实际应用中都非常常见，比如用户输入的校验、搜索功能等。

实现不区分大小写比较的方法，通常是在比较之前，将两个字符串都转换成统一的大小写格式（全部转为小写或全部转为大写），然后再进行比较。

一种比较直接的做法是：

逐字符转换并比较： 我们可以遍历两个字符串，对每个字符在比较前都进行大小写转换。这种方法的好处是避免了创建完整的临时字符串副本，对于内存敏感的场景可能更有利。

#include <string>
#include <iostream>
#include <cctype> // For std::tolower

// 辅助函数：将字符转为小写，处理EOF
char my_tolower(char ch) {
    return static_cast<char>(std::tolower(static_cast<unsigned char>(ch)));
}

bool equalsIgnoreCase(const std::string& s1, const std::string& s2) {
    if (s1.length() != s2.length()) {
        return false;
    }
    for (size_t i = 0; i < s1.length(); ++i) {
        if (my_tolower(s1[i]) != my_tolower(s2[i])) {
            return false;
        }
    }
    return true;
}

int main() {
    std::string strA = "Hello World";
    std::string strB = "hello world";
    std::string strC = "HELLO C++";

    if (equalsIgnoreCase(strA, strB)) {
        std::cout << "'" << strA << "' and '" << strB << "' are equal ignoring case." << std::endl; // Output: 'Hello World' and 'hello world' are equal ignoring case.
    }

    if (!equalsIgnoreCase(strA, strC)) {
        std::cout << "'" << strA << "' and '" << strC << "' are not equal ignoring case." << std::endl; // Output: 'Hello World' and 'HELLO C++' are not equal ignoring case.
    }
    return 0;
}

登录后复制

这里

std::tolower

登录后复制

需要一个

int

登录后复制

类型的参数，并且返回

int

登录后复制

，所以通常会先

static_cast

登录后复制

到

unsigned char

登录后复制

以避免负值字符（比如某些扩展ASCII字符）导致的问题，然后再转回

char

登录后复制

。这可能看起来有点繁琐，但这是一个常见的安全做法。

创建临时小写（或大写）字符串： 另一种方法是先将两个字符串都完全转换成小写（或者大写）的临时字符串，然后再用普通的区分大小写比较方法进行比较。这种方法代码可能更简洁，但会涉及额外的内存分配和字符串复制，对性能敏感的场景需要权衡。

#include <string>
#include <iostream>
#include <algorithm> // For std::transform
#include <cctype>    // For std::tolower

std::string toLower(std::string s) {
    std::transform(s.begin(), s.end(), s.begin(),
                   [](unsigned char c){ return std::tolower(c); });
    return s;
}

int main() {
    std::string strX = "Example String";
    std::string strY = "example string";

    if (toLower(strX) == toLower(strY)) {
        std::cout << "'" << strX << "' and '" << strY << "' are equal ignoring case." << std::endl; // Output: 'Example String' and 'example string' are equal ignoring case.
    }
    return 0;
}

登录后复制

这种方式利用了

std::transform

登录后复制

和lambda表达式，代码非常现代且易读。

需要注意的是，

std::tolower

登录后复制

和

std::toupper

登录后复制

的行为是受当前C语言环境（locale）影响的。对于非ASCII字符集（如UTF-8编码的中文、日文等），仅仅使用

std::tolower

登录后复制

可能无法正确处理所有的大小写转换规则。如果你的应用需要处理多语言环境，可能需要更复杂的国际化库（如ICU）来确保大小写转换的正确性。不过，对于常见的英文场景，上述方法已经足够了。

标书对比王

标书对比王是一款标书查重工具，支持多份投标文件两两相互比对，重复内容高亮标记，可快速定位重复内容原文所在位置，并可导出比对报告。

查看详情

std::string::compare()

登录后复制

方法与运算符重载有何不同？何时选用它？

std::string

登录后复制

的比较运算符（如

==

登录后复制

）和

compare()

登录后复制

方法都用于字符串的字典序比较，但它们在功能细节、返回值类型和使用场景上确实存在一些差异。理解这些差异能帮助我们做出更合适的选择。

1. 运算符重载 (

==

登录后复制

,
!=
登录后复制
,
<
登录后复制
,
>
登录后复制
,
<=
登录后复制
,
>=
登录后复制
)

简洁性与直观性： 这是它们最大的优势。使用这些运算符，代码看起来非常自然，就像比较数字一样。它们返回布尔值（
```
true
```
登录后复制
或
```
false
```
登录后复制
），非常适合条件判断。
功能： 主要用于判断两个完整的
```
std::string
```
登录后复制
对象是否相等，或者确定它们的整体字典序关系。
适用场景： 绝大多数情况下，当你需要对整个字符串进行相等性或排序比较时，运算符重载是首选。它们是C++中最符合习惯的用法，代码可读性高。
```
std::string s_op1 = "abc";
std::string s_op2 = "abd";
if (s_op1 < s_op2) { // 直观判断字典序
    // ...
}
```
登录后复制

std::string::compare()

登录后复制

方法

返回值：
```
compare()
```
登录后复制
方法返回一个
```
int
```
登录后复制
值，其行为类似于C风格字符串的
```
strcmp
```
登录后复制
函数：
- ```
0
```
  登录后复制
  ：表示两个字符串（或子字符串）相等。
- 负数：表示调用
```
compare()
```
  登录后复制
  的字符串（或子字符串）在字典序上小于参数字符串。
- 正数：表示调用
```
compare()
```
  登录后复制
  的字符串（或子字符串）在字典序上大于参数字符串。这种整数返回值在某些算法中可能比布尔值更有用，例如，当你需要知道“差多少”或者需要一个三态的比较结果时。
强大的子字符串比较能力： 这是
```
compare()
```
登录后复制
方法的核心优势，也是它与运算符重载最显著的区别。它提供了多个重载版本，允许你指定从哪个位置开始、比较多少个字符，以及与另一个字符串的哪个部分进行比较。
- ```
s1.compare(s2)
```
  登录后复制
  ：比较整个
```
s1
```
  登录后复制
  和
```
s2
```
  登录后复制
  。
- ```
s1.compare(pos1, len1, s2)
```
  登录后复制
  ：比较
```
s1
```
  登录后复制
  从
```
pos1
```
  登录后复制
  开始的
```
len1
```
  登录后复制
  个字符与整个
```
s2
```
  登录后复制
  。
- ```
s1.compare(pos1, len1, s2, pos2, len2)
```
  登录后复制
  ：比较
```
s1
```
  登录后复制
  从
```
pos1
```
  登录后复制
  开始的
```
len1
```
  登录后复制
  个字符与
```
s2
```
  登录后复制
  从
```
pos2
```
  登录后复制
  开始的
```
len2
```
  登录后复制
  个字符。

与C风格字符串的兼容性：

compare()

登录后复制

方法也有接受

const char*

登录后复制

参数的重载，可以直接与C风格字符串进行比较，而无需显式转换。

std::string s_comp1 = "programming";
std::string s_comp2 = "program";
const char* c_str_comp = "program";

// 比较s_comp1从索引0开始的7个字符与s_comp2
if (s_comp1.compare(0, 7, s_comp2) == 0) {
    std::cout << "s_comp1 starts with s_comp2" << std::endl;
}

// 比较s_comp1从索引0开始的7个字符与C风格字符串
if (s_comp1.compare(0, 7, c_str_comp) == 0) {
    std::cout << "s_comp1 starts with c_str_comp" << std::endl;
}

// 获取三态结果
int result = s_comp1.compare("programmer");
if (result < 0) {
    std::cout << "s_comp1 < programmer" << std::endl;
}

登录后复制

何时选用

compare()

登录后复制

方法？

我个人的经验是，如果你只是简单地判断两个完整的

std::string

登录后复制

是否相等或者它们的字典序，总是优先使用运算符重载，因为它们更简洁、更符合C++的习惯。

然而，

compare()

登录后复制

方法在以下场景中显得尤为强大和不可替代：

子字符串比较： 这是
```
compare()
```
登录后复制
最核心的价值。当你只需要比较字符串的某个片段，而不是整个字符串时，
```
compare()
```
登录后复制
提供了非常灵活的接口。例如，检查一个字符串是否以某个前缀开头，或者是否包含某个子字符串，
```
compare()
```
登录后复制
都能提供精确的控制。
需要三态比较结果： 如果你的算法需要一个整数返回值来区分“小于”、“等于”和“大于”这三种状态（例如，在实现自定义排序函数或查找算法时），那么
```
compare()
```
登录后复制
的整数返回值就非常方便。
与C风格字符串的混合操作： 当你的代码需要在
```
std::string
```
登录后复制
和
```
const char*
```
登录后复制
之间进行比较，并且希望保持接口一致性时，
```
compare()
```
登录后复制
可以作为一种选择。

总的来说，运算符重载是日常使用的“瑞士军刀”，而

compare()

登录后复制

方法则是一把“手术刀”，在需要精细控制和处理子字符串时发挥其最大价值。

C++中比较字符串时常见的错误和性能考量有哪些？

在C++中处理字符串比较，虽然看起来简单，但实际上还是有一些陷阱和性能上的考考量。作为开发者，我们得留心这些细节，才能写出健壮高效的代码。

常见的错误：

C风格字符串的
==
登录后复制
陷阱：这是最最经典，也最容易犯的错误。当你用
```
const char* str1 = "hello"; const char* str2 = "hello";
```
登录后复制
然后写
```
if (str1 == str2)
```
登录后复制
时，你不是在比较字符串内容，而是在比较

以上就是如何在C++中比较两个字符串_C++字符串比较操作指南的详细内容，更多请关注php中文网其它相关文章！