c++ substr( ).compare（）

`substr()` 是 C++ 中的字符串成员函数，用于提取子字符串。`compare()` 也是字符串成员函数，用于比较两个字符串。

在使用时，你可以先使用 `substr()` 函数提取一个字符串的子串，然后再使用 `compare()` 函数将提取的子串与目标字符串进行比较。`compare()` 函数返回一个整数值，表示两个字符串的比较结果。

下面是一个示例代码：

#include <iostream>
#include <string>

int main() {
    std::string str = "Hello, World!";
    std::string sub = str.substr(0, 5); // 提取从索引0开始的长度为5的子串

    if (sub.compare("Hello") == 0) {
        std::cout << "子串与目标字符串相等" << std::endl;
    } else {
        std::cout << "子串与目标字符串不相等" << std::endl;
    }

    return 0;
}

在上面的示例中，`substr(0, 5)` 提取了从索引0开始的长度为5的子串，即 "Hello"。然后使用 `compare()` 函数将提取的子串与目标字符串 "Hello" 进行比较，如果相等则输出 "子串与目标字符串相等"，否则输出 "子串与目标字符串不相等"。

相关问题

C++中.find（）函数如何只找单词，并非字符

在C++中，`find()`函数通常用于查找字符串中的子串或字符。如果你想只查找完整的单词而不是字符，你需要先对输入的字符串进行一些预处理。这里你可以考虑以下步骤：

1. **使用`std::string::find_first_of`和空格分隔符**：遍历字符串，找到连续的非空白字符（即单词），然后从那个位置开始查找特定单词。

#include <string>
#include <cctype>

std::string str = "Hello World, this is a test.";
size_t start = 0;

while ((start = str.find_first_not_of(" ", start)) != std::string::npos) {
    size_t end = str.find_first_of(" ", start);
    if (end == std::string::npos) { // 如果没有找到下一个空格，意味着找到了一个单独的单词
        end = str.size();
    }
    if (str.substr(start, end - start).compare("target_word") == 0) {
        // 找到了目标单词
        // ...
    }
    start = end + 1; // 更新搜索起始位置到下一个单词
}

2. **使用正则表达式库**：如果你的项目支持正则表达式，可以使用`<regex>`库来进行更复杂模式的匹配。

#include <regex>
#include <string>

std::smatch match;
std::string pattern("\\btarget_word\\b"); // 匹配整个单词
std::regex re(pattern);

std::string str = "Hello World, this is a target_word and another one.";
if (std::regex_search(str, match, re)) {
    // 找到了目标单词
    // ...
}

记住，这种方法假设单词之间由单个空格分隔。如果有可能存在其他分隔符，如逗号、句点等，需要相应地调整分隔符列表。

c++编程，用动态数组来存放字符串的每个字符，实现以下函数：求长度Strlen,串连接StrConcat,求子串Substr,按字典序比较两个串Strcmp,在串中指定位置插入StrIns,在串中指定位置删除StrDel,把串中的对应子串换成另一字符串StrRep

在C++中，使用动态数组存储字符串并实现上述功能，你需要定义一个包含字符的动态数组结构，并为每个函数编写相应的实现。这里是一个简单的示例：

#include <iostream>
#include <cstring>

class String {
private:
    char* data;
    int length;

public:
    // 构造函数
    String(const char* str = "") : length(strlen(str) + 1) {
        if (str != nullptr) {
            data = new char[length];
            std::copy(str, str + strlen(str), data);
            data[length - 1] = '\0'; // 结尾添加空字符
        } else {
            data = new char[1]; // 空字符串
            data[0] = '\0';
        }
    }

    ~String() { delete[] data; }

    // 求长度
    int Strlen() const { return length; }

    // 串连接
    String StrConcat(const String& other) const {
        String result(*this);
        result.length += other.length;
        result.data = new char[result.length];
        std::copy(result.data, result.data + result.length - 1, result.data + result.length - other.length);
        std::copy(other.data, other.data + other.length, result.data);
        result.data[result.length - 1] = '\0';
        return result;
    }

    // 求子串
    String Substr(int start, int end = -1) const {
        if (end == -1)
            end = length - 1;
        String substr;
        substr.length = end - start + 1;
        substr.data = new char[substr.length];
        std::copy(data + start, data + end + 1, substr.data);
        substr.data[substr.length - 1] = '\0';
        return substr;
    }

    // 字典序比较
    bool Strcmp(const String& other) const {
        for (int i = 0; i < std::min(length, other.length); ++i) {
            if (data[i] != other.data[i])
                return data[i] < other.data[i];
        }
        return length <= other.length;
    }

    // 在串中指定位置插入
    String StrIns(int pos, const String& insertStr) {
        String temp(*this);
        int newLength = length + insertStr.length;
        temp.length = newLength;
        temp.data = new char[newLength];
        std::copy(temp.data, temp.data + pos, temp.data);
        std::copy(insertStr.data, insertStr.data + insertStr.length, temp.data + pos);
        std::copy(temp.data + pos + insertStr.length, temp.data + length, temp.data + pos + insertStr.length);
        return temp;
    }

    // 在串中指定位置删除
    String StrDel(int pos, int len = 1) {
        String temp(*this);
        int newLength = length - len;
        temp.length = newLength;
        temp.data = new char[newLength];
        if (pos > newLength) pos = newLength;
        std::copy(temp.data + pos, temp.data + length, temp.data);
        return temp;
    }

    // 串替换
    String StrRep(const String& search, const String& replace) {
        String temp(*this);
        for (int i = 0; i < temp.length; ++i) {
            if (temp.data[i] == search.data[0]) {
                temp.data[i] = replace.data[0];
                size_t found = std::search(temp.data + i + 1, temp.data + temp.length,
                                          search.data + 1, search.data + search.length);
                if (found != temp.data + temp.length) {
                    temp.Length -= found - temp.data + i + 1;
                    temp.data += found - temp.data + i + 1;
                    temp.Length++;
                }
            }
        }
        return temp;
    }
};

// 示例用法
int main() {
    String s("Hello");
    std::cout << "Length: " << s.Strlen() << std::endl;
    String t("World");
    std::cout << "Concat: " << s.StrConcat(t).data << std::endl;
    std::cout << "Substring: " << s.Substring(6).data << std::endl;

    String u("Hello");
    std::cout << "Compare: " << (u.Strcmp(s) ? "Less" : "Equal") << std::endl;

    s = s.StrIns(5, "There");
    std::cout << "Insertion: " << s.data << std::endl;

    s = s.StrDel(7, 5);
    std::cout << "Deletion: " << s.data << std::endl;

    s = s.StrRep("o", "*");
    std::cout << "Replacement: " << s.data << std::endl;
    
    return 0;
}

注意，这个示例中的所有操作假设了字符串的内存管理是安全的，实际项目中应使用智能指针等手段处理内存分配与释放。