C++基础：（九）string类的使用与模拟实现

auto a; // 错误：未初始化，无法推导类型
auto b = 10; // 正确：b推导为int
auto c = 'a'; // 正确：c推导为char
auto d = string("hello"); // 正确：d推导为string

int x = 10;
auto y = &x; // y是int*（指针）
auto* z = &x; // z也是int*（与auto等价）
auto& m = x; // m是int&（引用，修改m会改变x）

auto a = 1, b = 2; // 正确：a和b均为int
auto c = 3, d = 4.0; // 错误：c是int，d是double，类型不一致

// 错误：auto不能作为函数参数
void func(auto a) {} 
// 错误：auto不能声明数组
auto arr[] = {1, 2, 3}; 

#include <iostream>
#include <string>
#include <map>
using namespace std;

int main() {
    map<string, string> dict = {{"apple", "苹果"}, {"orange", "橙子"}};
    // 传统写法：类型冗长
    map<string, string>::iterator it1 = dict.begin();
    // auto写法：简洁
    auto it2 = dict.begin();
    // 遍历map
    while (it2 != dict.end()) {
        cout << it2->first << ":" << it2->second << endl;
        ++it2;
    }
    return 0;
}

for (迭代变量 : 集合) {
    // 循环体
}

#include <iostream>
#include <string>
using namespace std;

int main() {
    string str = "hello world";
    
    // 传统for循环：需手动控制索引
    for (int i = 0; i < str.size(); ++i) {
        cout << str[i] << " ";
    }
    cout << endl;
    
    // 范围for循环：自动遍历
    for (auto ch : str) { // 读取元素（值类型）
        cout << ch << " ";
    }
    cout << endl;
    
    // 范围for修改元素（引用类型）
    for (auto& ch : str) {
        ch = toupper(ch); // 转为大写
    }
    cout << str << endl; // 输出：HELLO WORLD
    return 0;
}

#include <iostream>
#include <string>
using namespace std;

void TestStringConstructor() {
    // 1. 无参构造：空字符串
    string s1;
    cout << "s1: " << s1 << " (size: " << s1.size() << ")" << endl; // 输出：s1:  (size: 0)
    
    // 2. C风格字符串构造
    string s2("hello bit");
    cout << "s2: " << s2 << " (size: " << s2.size() << ")" << endl; // 输出：s2: hello bit (size: 8)
    
    // 3. n个字符c构造
    string s3(5, 'x');
    cout << "s3: " << s3 << " (size: " << s3.size() << ")" << endl; // 输出：s3: xxxxx (size: 5)
    
    // 4. 拷贝构造
    string s4(s2);
    cout << "s4: " << s4 << " (size: " << s4.size() << ")" << endl; // 输出：s4: hello bit (size: 8)
}

int main() {
    TestStringConstructor();
    return 0;
}

#include <iostream>
#include <string>
using namespace std;

void TestStringCapacity() {
    string s("hello");
    cout << "初始状态：" << endl;
    cout << "size: " << s.size() << ", capacity: " << s.capacity() << endl; // 输出：size:5, capacity:15（VS下）
    
    // 1. empty()判断空
    cout << "是否为空：" << (s.empty() ? "是" : "否") << endl; // 输出：否
    
    // 2. clear()清空有效字符
    s.clear();
    cout << "clear后：" << endl;
    cout << "size: " << s.size() << ", capacity: " << s.capacity() << endl; // 输出：size:0, capacity:15（capacity不变）
    
    // 3. reserve()预留空间
    s.reserve(20);
    cout << "reserve(20)后：" << endl;
    cout << "size: " << s.size() << ", capacity: " << s.capacity() << endl; // 输出：size:0, capacity:20（扩容到20）
    
    // 4. resize()调整有效字符个数
    s.resize(10, 'a'); // 用'a'填充，size变为10
    cout << "resize(10, 'a')后：" << endl;
    cout << "s: " << s << ", size: " << s.size() << ", capacity: " << s.capacity() << endl; // 输出：s:aaaaaaaaaa, size:10, capacity:20
    
    s.resize(5); // 截断到5个字符
    cout << "resize(5)后：" << endl;
    cout << "s: " << s << ", size: " << s.size() << ", capacity: " << s.capacity() << endl; // 输出：s:aaaaa, size:5, capacity:20
}

int main() {
    TestStringCapacity();
    return 0;
}

#include <iostream>
#include <string>
using namespace std;

void TestStringAccess() {
    string s("hello world");
    
    // 1. operator[]访问单个字符
    cout << "第3个字符（索引2）：" << s[2] << endl; // 输出：l
    s[2] = 'L'; // 修改字符
    cout << "修改后：" << s << endl; // 输出：heLlo world
    
    // 2. 迭代器遍历（正向）
    cout << "正向迭代器遍历：";
    string::iterator it = s.begin();
    while (it != s.end()) {
        cout << *it << " ";
        ++it;
    }
    cout << endl; // 输出：h e L l o   w o r l d 
    
    // 3. 反向迭代器遍历（反向）
    cout << "反向迭代器遍历：";
    string::reverse_iterator rit = s.rbegin();
    while (rit != s.rend()) {
        cout << *rit << " ";
        ++rit;
    }
    cout << endl; // 输出：d l r o w   o l L e h 
    
    // 4. 范围for遍历（C++11）
    cout << "范围for遍历：";
    for (auto ch : s) {
        cout << ch << " ";
    }
    cout << endl; // 输出：h e L l o   w o r l d 
}

int main() {
    TestStringAccess();
    return 0;
}

#include <iostream>
#include <string>
using namespace std;

void TestStringModify() {
    string s("hello");
    
    // 1. 尾部插入/追加
    s.push_back(' '); // 插入空格："hello "
    s.append("world"); // 追加字符串："hello world"
    s += "!!!"; // 重载+=："hello world!!!"
    cout << "追加后：" << s << endl; // 输出：hello world!!!
    
    // 2. c_str()：转为C风格字符串
    printf("C风格输出：%s\n", s.c_str()); // 输出：hello world!!!（printf需C风格字符串）
    
    // 3. find()查找
    size_t pos1 = s.find("world");
    if (pos1 != string::npos) {
        cout << "\"world\"的起始索引：" << pos1 << endl; // 输出：6
    }
    
    size_t pos2 = s.find("test");
    if (pos2 == string::npos) {
        cout << "\"test\"未找到" << endl; // 输出："test"未找到
    }
    
    // 4. rfind()反向查找
    size_t pos3 = s.rfind('l');
    cout << "最后一个'l'的索引：" << pos3 << endl; // 输出：9（"hello world!!!"中最后一个'l'在索引9）
    
    // 5. substr()截取
    string sub1 = s.substr(6, 5); // 从索引6开始，截取5个字符
    cout << "截取sub1：" << sub1 << endl; // 输出：world
    
    string sub2 = s.substr(12); // 从索引12开始，截取到末尾
    cout << "截取sub2：" << sub2 << endl; // 输出：!!
}

int main() {
    TestStringModify();
    return 0;
}

#include <iostream>
#include <string>
using namespace std;

void TestStringNonMember() {
    string s1, s2;
    
    // 1. operator>>输入（忽略空格）
    cout << "输入s1（空格分隔）：";
    cin >> s1; // 若输入"hello world"，s1仅存"hello"
    cout << "s1: " << s1 << endl;
    
    // 注意：cin >> 后会残留换行符，需用cin.ignore()清除，否则getline会读取空行
    cin.ignore(); // 清除缓冲区中的换行符
    
    // 2. getline输入（读取整行）
    cout << "输入s2（含空格）：";
    getline(cin, s2); // 输入"hello world"，s2存"hello world"
    cout << "s2: " << s2 << endl;
    
    // 3. 比较运算符
    string s3("apple"), s4("banana");
    cout << "s3 == s4? " << (s3 == s4 ? "是" : "否") << endl; // 输出：否
    cout << "s3 < s4? " << (s3 < s4 ? "是" : "否") << endl; // 输出：是（'a' < 'b'）
}

int main() {
    TestStringNonMember();
    return 0;
}

#include <iostream>
#include <cstring>
#include <cassert>
using namespace std;

class String {
public:
    // 构造函数：用C风格字符串初始化
    String(const char* str = "") {
        if (str == nullptr) { // 防止传入nullptr
            assert(false);
            return;
        }
        // 分配空间：strlen(str) + 1（+1用于存储'\0'）
        _str = new char[strlen(str) + 1];
        strcpy(_str, str); // 拷贝字符串
    }

    // 析构函数：释放空间
    ~String() {
        if (_str) {
            delete[] _str; // 释放堆内存
            _str = nullptr; // 避免野指针
        }
    }

private:
    char* _str; // 指向存储字符串的堆内存
};

// 测试
void TestString() {
    String s1("hello");
    String s2(s1); // 调用编译器合成的拷贝构造函数
}

int main() {
    TestString();
    return 0;
}

#include <iostream>
#include <cstring>
#include <cassert>
using namespace std;

class String {
public:
    // 1. 构造函数
    String(const char* str = "") {
        if (str == nullptr) {
            assert(false);
            return;
        }
        _str = new char[strlen(str) + 1];
        strcpy(_str, str);
    }

    // 2. 拷贝构造函数（深拷贝）
    String(const String& s) {
        // 为新对象分配独立空间
        _str = new char[strlen(s._str) + 1];
        strcpy(_str, s._str); // 复制内容
    }

    // 3. 赋值运算符重载（深拷贝）
    // 返回值为String&：支持链式赋值（如s1 = s2 = s3）
    // 参数为const String&：避免拷贝，且防止修改原对象
    String& operator=(const String& s) {
        // 防止自赋值（如s1 = s1）
        if (this != &s) {
            // 步骤1：先释放当前对象的旧空间
            delete[] _str;
            // 步骤2：分配新空间并拷贝内容
            _str = new char[strlen(s._str) + 1];
            strcpy(_str, s._str);
        }
        return *this;
    }

    // 4. 析构函数
    ~String() {
        if (_str) {
            delete[] _str;
            _str = nullptr;
        }
    }

    // 辅助接口：获取字符串（用于测试）
    const char* c_str() const {
        return _str;
    }

private:
    char* _str;
};

// 测试
void TestString() {
    String s1("hello");
    String s2(s1); // 调用深拷贝构造函数
    cout << "s1: " << s1.c_str() << endl; // 输出：hello
    cout << "s2: " << s2.c_str() << endl; // 输出：hello

    String s3("world");
    s3 = s1; // 调用深拷贝赋值运算符
    cout << "s3: " << s3.c_str() << endl; // 输出：hello
}

int main() {
    TestString();
    return 0;
}

#include <iostream>
#include <cstring>
#include <cassert>
using namespace std;

class String {
public:
    // 1. 构造函数（同传统版）
    String(const char* str = "") {
        if (str == nullptr) {
            assert(false);
            return;
        }
        _str = new char[strlen(str) + 1];
        strcpy(_str, str);
    }

    // 2. 拷贝构造函数（现代版）
    String(const String& s)
        : _str(nullptr) { // 先初始化为nullptr，避免swap后野指针
        String strTmp(s._str); // 用s._str构造临时对象strTmp（调用构造函数，分配新空间）
        swap(_str, strTmp._str); // 交换当前对象和临时对象的_str
    }

    // 3. 赋值运算符重载（现代版1：参数为值传递）
    String& operator=(String s) { // s是实参的拷贝（调用拷贝构造函数）
        swap(_str, s._str); // 交换当前对象和s的_str
        return *this;
    }

    /*
    // 赋值运算符重载（现代版2：参数为const引用，内部构造临时对象）
    String& operator=(const String& s) {
        if (this != &s) {
            String strTmp(s); // 构造临时对象
            swap(_str, strTmp._str);
        }
        return *this;
    }
    */

    // 4. 析构函数（同传统版）
    ~String() {
        if (_str) {
            delete[] _str;
            _str = nullptr;
        }
    }

    // 辅助接口
    const char* c_str() const {
        return _str;
    }

private:
    char* _str;
};

// 测试
void TestStringModern() {
    String s1("hello");
    String s2(s1);
    cout << "s1: " << s1.c_str() << endl; // 输出：hello
    cout << "s2: " << s2.c_str() << endl; // 输出：hello

    String s3("world");
    s3 = s1;
    cout << "s3: " << s3.c_str() << endl; // 输出：hello
}

int main() {
    TestStringModern();
    return 0;
}

#include <iostream>
#include <cstring>
#include <cassert>
using namespace std;

class String {
private:
    // 引用计数结构体：存储在堆内存，与字符串数据关联
    struct RefCount {
        size_t count; // 引用计数
        char data[1]; // 柔性数组：存储字符串数据（实际大小动态分配）
    };

    RefCount* _pRef; // 指向RefCount结构体的指针

public:
    // 构造函数：创建新的RefCount和字符串数据
    String(const char* str = "") {
        if (str == nullptr) str = "";
        size_t len = strlen(str);
        // 分配内存：RefCount大小 + 字符串长度 + 1（'\0'）
        _pRef = (RefCount*)new char[sizeof(RefCount) + len + 1];
        _pRef->count = 1; // 初始引用计数为1
        strcpy(_pRef->data, str); // 拷贝字符串
    }

    // 拷贝构造函数：增加引用计数（浅拷贝）
    String(const String& s) {
        _pRef = s._pRef;
        _pRef->count++; // 引用计数+1
    }

    // 赋值运算符重载：先减少当前引用计数，再共享新内存
    String& operator=(const String& s) {
        if (this != &s) {
            // 减少当前内存的引用计数，若为0则释放
            Release();
            // 共享s的内存，引用计数+1
            _pRef = s._pRef;
            _pRef->count++;
        }
        return *this;
    }

    // 析构函数：减少引用计数，必要时释放内存
    ~String() {
        Release();
    }

    // 重载operator[]：写操作时触发拷贝（COW核心）
    char& operator[](size_t pos) {
        assert(pos < strlen(_pRef->data));
        // 若引用计数>1，触发深拷贝
        if (_pRef->count > 1) {
            size_t len = strlen(_pRef->data);
            // 分配新内存
            RefCount* newRef = (RefCount*)new char[sizeof(RefCount) + len + 1];
            newRef->count = 1;
            strcpy(newRef->data, _pRef->data);
            // 减少原内存的引用计数，若为0则释放
            _pRef->count--;
            _pRef = newRef;
        }
        // 返回当前内存的数据（可修改）
        return _pRef->data[pos];
    }

    // 辅助接口：获取字符串
    const char* c_str() const {
        return _pRef->data;
    }

private:
    // 释放内存：引用计数-1，若为0则删除
    void Release() {
        _pRef->count--;
        if (_pRef->count == 0) {
            delete[] (char*)_pRef; // 释放整个RefCount结构体
            _pRef = nullptr;
        }
    }
};

// 测试写时拷贝
void TestCOW() {
    String s1("hello");
    String s2(s1); // 浅拷贝，引用计数=2
    cout << "s1: " << s1.c_str() << ", s2: " << s2.c_str() << endl; // 输出：hello, hello

    s2[0] = 'H'; // 修改s2，触发深拷贝，引用计数分别为1
    cout << "s1: " << s1.c_str() << ", s2: " << s2.c_str() << endl; // 输出：hello, Hello
}

int main() {
    TestCOW();
    return 0;
}

#include <iostream>
#include <string>
using namespace std;

class Solution {
public:
    // 判断是否为字母
    bool isLetter(char ch) {
        return (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z');
    }

    string reverseOnlyLetters(string s) {
        if (s.empty()) return s;
        size_t begin = 0;
        size_t end = s.size() - 1;
        while (begin < end) {
            // 找到左侧第一个字母
            while (begin < end && !isLetter(s[begin])) {
                ++begin;
            }
            // 找到右侧第一个字母
            while (begin < end && !isLetter(s[end])) {
                --end;
            }
            // 交换
            swap(s[begin], s[end]);
            ++begin;
            --end;
        }
        return s;
    }
};

int main() {
    Solution sol;
    string s1 = "ab-cd";
    cout << sol.reverseOnlyLetters(s1) << endl; // 输出：dc-ba

    string s2 = "a-bC-dEf-ghIj";
    cout << sol.reverseOnlyLetters(s2) << endl; // 输出：j-Ih-gfE-dCba
    return 0;
}

#include <iostream>
#include <string>
using namespace std;

class Solution {
public:
    int firstUniqChar(string s) {
        // 初始化计数数组（256个ASCII字符）
        int count[256] = {0};
        // 第一次遍历：统计次数
        for (char ch : s) {
            count[ch]++;
        }
        // 第二次遍历：找第一个次数为1的字符
        for (int i = 0; i < s.size(); ++i) {
            if (count[s[i]] == 1) {
                return i;
            }
        }
        // 无重复字符
        return -1;
    }
};

int main() {
    Solution sol;
    string s1 = "leetcode";
    cout << sol.firstUniqChar(s1) << endl; // 输出：0

    string s2 = "loveleetcode";
    cout << sol.firstUniqChar(s2) << endl; // 输出：2
    return 0;
}

#include <iostream>
#include <string>
#include <algorithm> // 用于reverse函数
using namespace std;

class Solution {
public:
    string addStrings(string num1, string num2) {
        int end1 = num1.size() - 1;
        int end2 = num2.size() - 1;
        int next = 0; // 进位
        string result;

        // 循环条件：任意一个字符串未遍历完，或有进位
        while (end1 >= 0 || end2 >= 0 || next > 0) {
            // 取当前位的值（若已遍历完，取0）
            int value1 = (end1 >= 0) ? (num1[end1--] - '0') : 0;
            int value2 = (end2 >= 0) ? (num2[end2--] - '0') : 0;

            // 计算当前位总和
            int sum = value1 + value2 + next;
            next = sum / 10; // 新的进位
            int current = sum % 10; // 当前位的值

            // 存入结果（尾部插入，后续需反转）
            result += (current + '0');
        }

        // 反转结果（从后向前存储→从前向后）
        reverse(result.begin(), result.end());
        return result;
    }
};

int main() {
    Solution sol;
    string num1 = "11", num2 = "123";
    cout << sol.addStrings(num1, num2) << endl; // 输出：134

    num1 = "456", num2 = "77";
    cout << sol.addStrings(num1, num2) << endl; // 输出：533
    return 0;
}

#include <iostream>
#include <string>
#include <cctype> // 用于toupper函数
using namespace std;

class Solution {
public:
    // 判断是否为字母或数字
    bool isLetterOrNumber(char ch) {
        return isalnum(ch); // 库函数：判断是否为字母或数字
    }

    bool isPalindrome(string s) {
        // 预处理：转为大写，忽略非字母数字
        for (char& ch : s) {
            if (islower(ch)) {
                ch = toupper(ch); // 小写转大写
            }
        }

        int begin = 0;
        int end = s.size() - 1;
        while (begin < end) {
            // 找到左侧第一个字母/数字
            while (begin < end && !isLetterOrNumber(s[begin])) {
                ++begin;
            }
            // 找到右侧第一个字母/数字
            while (begin < end && !isLetterOrNumber(s[end])) {
                --end;
            }
            // 比较
            if (s[begin] != s[end]) {
                return false;
            }
            ++begin;
            --end;
        }
        return true;
    }
};

int main() {
    Solution sol;
    string s1 = "A man, a plan, a canal: Panama";
    cout << (sol.isPalindrome(s1) ? "true" : "false") << endl; // 输出：true

    string s2 = "race a car";
    cout << (sol.isPalindrome(s2) ? "true" : "false") << endl; // 输出：false
    return 0;
}