C++入门-string类

大家好啊，今天呢，我们来聊聊C++中的string类，那么，开始发车喽！

一. 为什么要学习string类？

在C++中，string类是一个重要的类，用于处理字符串。学习string类有以下几个关键原因：

1. 方便操作字符串：string类提供了丰富的方法和操作符，使得对字符串的处理变得简单和高效。
2. 避免内存管理问题：string类自动处理内存分配和释放，避免了手动管理内存的麻烦和可能出现的错误。
3. 与标准库兼容：string类是C++标准库的一部分，使用它可以更好地利用标准库提供的功能。

示例代码

下面是一个简单示例演示如何使用string类：

#include <iostream>
#include <string>

int main() {
    // 定义一个string对象并初始化
    std::string str = "Hello, C++ String!";

    // 输出字符串内容
    std::cout << "String: " << str << std::endl;

    // 获取字符串长度
    std::cout << "Length: " << str.length() << std::endl;

    return 0;
}

在上面的示例中，我们包含了头文件<string>，定义了一个string对象str，并演示了输出字符串内容和获取字符串长度的操作。

习题

1.编写一个程序，接受用户输入的两个字符串，然后将它们连接起来并输出结果。

#include <iostream>
#include <string>

int main() {
    std::string str1, str2;

    // 输入第一个字符串
    std::cout << "Enter the first string: ";
    std::cin >> str1;

    // 输入第二个字符串
    std::cout << "Enter the second string: ";
    std::cin >> str2;

    // 连接两个字符串并输出
    std::string result = str1 + str2;
    std::cout << "Concatenated string: " << result << std::endl;

    return 0;
}

通过上面的习题，我们可以练习使用string类进行字符串的连接操作，加深对string类的理解。

二. 标准库中的string类

在C++标准库中，string类提供了丰富的方法和功能，使得字符串的处理变得更加便捷和高效。以下是一些常用的string类方法和操作：

1. 构造函数：string类提供了多种构造函数，可以通过字符数组、另一个string对象、字符等方式来初始化字符串。

   std::string str1 = "Hello"; // 使用字符数组初始化
   std::string str2("World"); // 使用另一个string对象初始化
   std::string str3(5, 'A'); // 使用重复字符初始化
   

2. 字符串连接：可以使用+操作符或append方法来连接两个字符串。

   std::string result = str1 + " " + str2;
   str1.append(" C++");
   

3. 字符串查找：可以使用find方法来查找子串在字符串中的位置。

   size_t pos = str1.find("lo");
   if (pos != std::string::npos) {
       std::cout << "Substring found at position: " << pos << std::endl;
   }
   

4. 字符串比较：可以使用==、!=、<等操作符来比较字符串的大小。

   if (str1 == str2) {
       std::cout << "Strings are equal" << std::endl;
   } else {
       std::cout << "Strings are not equal" << std::endl;
   }
   

5. 字符串长度：可以使用length()或size()方法来获取字符串的长度。

   std::cout << "Length of str1: " << str1.length() << std::endl;
   

示例代码

下面是一个简单示例演示了如何使用string类的一些常用方法：

#include <iostream>
#include <string>

int main() {
    std::string str1 = "Hello";
    std::string str2 = "World";

    // 连接两个字符串
    std::string result = str1 + " " + str2;
    std::cout << "Concatenated string: " << result << std::endl;

    // 查找子串
    size_t pos = result.find("lo");
    if (pos != std::string::npos) {
        std::cout << "Substring found at position: " << pos << std::endl;
    }

    // 比较字符串
    if (str1 == str2) {
        std::cout << "Strings are equal" << std::endl;
    } else {
        std::cout << "Strings are not equal" << std::endl;
    }

    return 0;
}

在上面的示例中，我们展示了如何使用string类的构造函数、连接字符串、查找子串、比较字符串等操作。

习题

1.编写一个程序，接受用户输入的字符串，然后统计其中包含的数字字符个数并输出结果。

#include <iostream>
#include <string>
#include <cctype>

int main() {
    std::string str;
    int digitCount = 0;

    // 输入字符串
    std::cout << "Enter a string: ";
    std::getline(std::cin, str);

    // 统计数字字符个数
    for (char c : str) {
        if (std::isdigit(c)) {
            digitCount++;
        }
    }

    std::cout << "Number of digit characters: " << digitCount << std::endl;

    return 0;
}

通过上面的习题，我们可以练习使用string类和字符处理函数来处理字符串中的数字字符，加深对string类的应用和理解。

三. 模拟实现C++中的string类

在本部分中，我们将模拟实现一个简化版的string类，包括字符串的存储、构造函数、析构函数、赋值操作符等基本功能。通过模拟实现，可以加深对string类内部原理的理解。

1. 字符串类的定义

首先，我们定义一个简化版的字符串类MyString，包含以下成员变量和方法：

• char* data: 存储字符串的字符数组
• size_t length: 字符串的长度
• 构造函数、析构函数、赋值操作符等基本方法

#include <iostream>
#include <cstring>

class MyString {
private:
    char* data;
    size_t length;

public:
    // 构造函数
    MyString(const char* str = "") {
        length = std::strlen(str);
        data = new char[length + 1];
        std::strcpy(data, str);
    }

    // 析构函数
    ~MyString() {
        delete[] data;
    }

    // 拷贝构造函数
    MyString(const MyString& other) {
        length = other.length;
        data = new char[length + 1];
        std::strcpy(data, other.data);
    }

    // 赋值操作符重载
    MyString& operator=(const MyString& other) {
        if (this != &other) {
            delete[] data;
            length = other.length;
            data = new char[length + 1];
            std::strcpy(data, other.data);
        }
        return *this;
    }

    // 打印字符串
    void print() {
        std::cout << data << std::endl;
    }
};

2. 测试字符串类的功能

接下来，我们编写一个简单的测试程序，用于测试我们模拟实现的MyString类的基本功能。

int main() {
    MyString str1("Hello");
    MyString str2("World");

    // 测试构造函数和打印方法
    str1.print();
    str2.print();

    // 测试赋值操作符重载
    str1 = str2;
    str1.print();

    return 0;
}

在上面的测试程序中，我们创建了两个MyString对象，并测试了构造函数、赋值操作符重载和打印方法。通过这个简单的示例，我们可以看到模拟实现的MyString类的基本功能。

3. string的增删查改的模拟实现

下面是一个简化版的String类的模拟实现，包括字符串的增加、删除、查找和修改等功能：

#include <iostream>
#include <cstring>

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

public:
    // 构造函数
    String(const char* str) {
        length = strlen(str);
        data = new char[length + 1];
        strcpy(data, str);
    }

    // 析构函数
    ~String() {
        delete[] data;
    }

    // 获取字符串长度
    size_t size() const {
        return length;
    }

    // 获取字符串内容
    const char* c_str() const {
        return data;
    }

    // 字符串连接
    String operator+(const String& other) {
        char* newData = new char[length + other.length + 1];
        strcpy(newData, data);
        strcat(newData, other.data);
        return String(newData);
    }

    // 字符串查找
    int find(const char* substr) {
        char* found = strstr(data, substr);
        if (found) {
            return found - data;
        } else {
            return -1;
        }
    }

    // 字符串替换
    void replace(const char* oldStr, const char* newStr) {
        char* found = strstr(data, oldStr);
        if (found) {
            size_t oldLen = strlen(oldStr);
            size_t newLen = strlen(newStr);
            size_t newSize = length - oldLen + newLen;
            char* newData = new char[newSize + 1];
            strncpy(newData, data, found - data);
            strcpy(newData + (found - data), newStr);
            strcpy(newData + (found - data) + newLen, found + oldLen);
            delete[] data;
            data = newData;
            length = newSize;
        }
    }
};

int main() {
    String str1("Hello");
    String str2("World");

    String str3 = str1 + str2;
    std::cout << "Concatenated string: " << str3.c_str() << std::endl;

    int index = str3.find("World");
    if (index != -1) {
        std::cout << "Substring found at index: " << index << std::endl;
    }

    str3.replace("World", "C++");
    std::cout << "After replacement: " << str3.c_str() << std::endl;

    return 0;
}

4. 习题

扩展我们前面模拟实现的MyString类，添加一个方法concatenate，用于将两个MyString对象连接成一个新的字符串，并返回连接后的字符串对象。

// 在MyString类中添加concatenate方法
MyString concatenate(const MyString& other) {
    char* newData = new char[length + other.length + 1];
    std::strcpy(newData, data);
    std::strcat(newData, other.data);
    MyString result(newData);
    delete[] newData;
    return result;
}

// 在测试程序中调用concatenate方法
int main() {
    MyString str1("Hello");
    MyString str2("World");

    MyString result = str1.concatenate(str2);
    result.print();

    return 0;
}

通过上面的习题，我们可以练习在模拟实现的MyString类中添加新的方法，并对字符串进行操作，加深对字符串类的理解和应用。

好了，感谢大家看到这，如果觉得本篇文章对你有帮助的话，还请点个赞支持一下，有什么问题也可以评论区留言，那么我们下次再见了，Peace~