C++ String类

1.1 String类概述

• string类的本质：

  • C++标准库中的字符串类
  • 位于std命名空间
  • 自动管理内存，无需担心溢出
  • 提供丰富的字符串操作接口

• 基本使用：

  #include <string>
  using namespace std;
  
  string s1;              // 空字符串
  string s2 = "Hello";    // 用字符串字面量初始化
  string s3(5, 'a');     // "aaaaa"
  string s4 = s2;        // 拷贝构造
  

2.1 访问与修改

string str = "Hello";

// 访问单个字符
char c1 = str[0];      // 使用[]操作符：'H'
char c2 = str.at(1);   // 使用at()方法：'e'

// 修改单个字符
str[0] = 'h';          // 使用[]修改
str.at(1) = 'E';       // 使用at()修改

// 获取长度
int len1 = str.length();    // 5
int len2 = str.size();      // 5（与length()相同）
bool empty = str.empty();   // false

// 修改整个字符串
str.assign("World");        // 替换整个字符串
str.clear();               // 清空字符串

3.1 转换方法

// 字符数组转string
char arr[] = "Hello World";
string s1(arr);                // 构造函数
string s2 = arr;              // 赋值运算符
string s3(arr, 5);            // 只取前5个字符
string s4(arr + 6, arr + 11); // 取下标范围[6,11)

// string转字符数组
string str = "Hello World";
const char* c1 = str.c_str();  // 返回C风格字符串
const char* c2 = str.data();   // 类似c_str()

// 注意：c_str()和data()返回的是临时指针
// 如果需要持久保存，应该复制到自己的缓冲区
char buffer[100];
strcpy(buffer, str.c_str());

4.1 迭代器使用

string str = "Hello World";

// 使用正向迭代器
for(string::iterator it = str.begin(); it != str.end(); ++it) {
    *it = toupper(*it);  // 转换为大写
}

// 使用反向迭代器
for(string::reverse_iterator it = str.rbegin(); 
    it != str.rend(); ++it) {
    cout << *it;  // 反向输出
}

// 使用范围for循环（C++11）
for(char& c : str) {
    c = tolower(c);  // 转换为小写
}

// 常量迭代器
for(string::const_iterator it = str.cbegin(); 
    it != str.cend(); ++it) {
    cout << *it;  // 只读访问
}

4.3 字符串流

#include <sstream>

// 字符串转数字
string str = "123 45.67";
stringstream ss(str);
int n;
double d;
ss >> n >> d;  // n=123, d=45.67

// 数字转字符串
stringstream ss2;
ss2 << 456 << ' ' << 78.9;
string result = ss2.str();  // "456 78.9"

// 字符串分割
string text = "Hello,World,C++";
stringstream ss3(text);
string token;
while(getline(ss3, token, ',')) {
    cout << token << endl;
}

// 格式化字符串
stringstream ss4;
ss4 << "Score: " << 95 << "%";
string formatted = ss4.str();  // "Score: 95%"

// 清空并重用
ss4.str("");
ss4.clear();
ss4 << "New content";

5.1 文本处理

// 单词计数
string text = "Hello World Hello C++";
stringstream ss(text);
string word;
map<string, int> wordCount;

while(ss >> word) {
    wordCount[word]++;
}

// 输出每个单词的出现次数
for(const auto& pair : wordCount) {
    cout << pair.first << ": " << pair.second << endl;
}

// 文本格式化
string formatText(const string& text) {
    string result;
    bool lastWasSpace = true;  // 用于处理开头的空格
    
    for(char c : text) {
        if(isspace(c)) {
            if(!lastWasSpace) {
                result += ' ';
                lastWasSpace = true;
            }
        } else {
            result += c;
            lastWasSpace = false;
        }
    }
    
    // 移除末尾空格
    if(!result.empty() && result.back() == ' ') {
        result.pop_back();
    }
    
    return result;
}

6.1 单词统计问题（HDU 1062）

问题描述：
给定一行文本，将每个单词反转后输出，单词之间的空格保持不变。

示例：

• 输入："Hello World"
• 输出："olleH dlroW"

// HDU 1062 Text Reverse
void solveTextReverse() {
    string line;
    while(getline(cin, line)) {
        stringstream ss(line);
        string word;
        bool first = true;
        
        while(ss >> word) {
            if(!first) cout << " ";
            reverse(word.begin(), word.end());
            cout << word;
            first = false;
        }
        cout << endl;
    }
}

6.2 字符串匹配问题（POJ 3080）

问题描述：
给定m个长度为60的DNA序列，找出这些序列中最长的公共子串。如果有多个答案，输出字典序最小的那个。

// POJ 3080 Blue Jeans
string findLongestCommonSubstring(vector<string>& dna) {
    if(dna.empty()) return "";
    
    string result;
    const string& first = dna[0];
    
    // 枚举所有可能的子串长度
    for(int len = 60; len >= 3; len--) {
        // 枚举first中所有长度为len的子串
        for(int i = 0; i + len <= first.length(); i++) {
            string sub = first.substr(i, len);
            bool found = true;
            
            // 检查是否在其他序列中都能找到
            for(int j = 1; j < dna.size(); j++) {
                if(dna[j].find(sub) == string::npos) {
                    found = false;
                    break;
                }
            }
            
            if(found) {
                if(result.empty() || sub < result) {
                    result = sub;
                }
            }
        }
        
        if(!result.empty()) break;
    }
    
    return result;
}

6.3 文本转换问题（CSP-J 2019）

问题描述：
给定一个加密规则和明文，将明文转换为密文。加密规则是将每个字母替换为另一个字母，保持大小写不变。

// CSP-J 2019 字符串加密
string encrypt(const string& text, const string& rule) {
    string result = text;
    
    // 创建映射表
    map<char, char> upperMap, lowerMap;
    for(int i = 0; i < 26; i++) {
        char original = 'A' + i;
        char encrypted = toupper(rule[i]);
        upperMap[original] = encrypted;
        lowerMap[tolower(original)] = tolower(encrypted);
    }
    
    // 进行转换
    for(char& c : result) {
        if(isupper(c)) {
            c = upperMap[c];
        } else if(islower(c)) {
            c = lowerMap[c];
        }
    }
    
    return result;
}

// 验证规则是否合法
bool isValidRule(const string& rule) {
    if(rule.length() != 26) return false;
    
    set<char> used;
    for(char c : rule) {
        if(!isalpha(c)) return false;
        char upper = toupper(c);
        if(used.count(upper)) return false;
        used.insert(upper);
    }
    
    return true;
}

8.2 进阶建议

1. 深入学习：

   • 了解string的内部实现
   • 学习更多STL算法
   • 掌握正则表达式
   • 研究字符串匹配算法

2. 实践应用：

   • 多做习题
   • 实现常用功能
   • 注重代码质量
   • 关注性能优化

3. 扩展知识：

   • Unicode处理
   • 国际化支持
   • 模式匹配
   • 文本处理库