C++：08.string、c++const增强和引用本质分析

知识点：

1. string 常见操作

#include <algorithm> // STL 算法包
#include <cctype>   // 用到一个函数指针，回调函数

1.1.string创建

    string str1 = "123";
    string str2("123");
    string str3(5,'A'); // 5 个 A = AAAAA
    string *str4 = new string ("123");

1.2. string 与 char* 互转

    // string 转 char* c_str();
    const char* c_str1 = str1.c_str();

    // char* 转 string
    char* c_str = "east";
    string str(c_str); // 对象

1.3. 遍历

str.at(i) 和 str[i]，区别在于 str.at(i)如果数组越界会报异常，而str[i]不一定

    try{
        for(int i = 0; i < str.length() + 2; i++){
            cout << str.at(i) <<endl; // 如果越界会抛异常
        }

        for(int i = 0; i < str.length() + 2; i++){
            cout << str[i] <<endl; // 不会报错！！！，会导致程序宕机，AS里面是可以的
        }
    } catch (...) {
        cout << "异常了" << endl;
    }

    string str("1234567");
    // 1. 字符串的遍历
    for(int i = 0; i < str.length(); i++){
        cout << str[i] << endl;
    }

    // 2. 迭代器遍历
    for(string::iterator it = str.begin(); it < str.end(); it++){
        cout << *it <<endl;
    }

1.4. 添加

1. str1 = str1 + str2;
2. str1 = str1.append(str2);

int main(){
    string str1 = "123";
    string str2 = "456";

//     str1 = str1 + str2;    
     str1 = str1.append(str2);

    cout << str1 << endl;
}

打印结果

123456

1.5. 删除

• str1.erase(it);

    string str1 = "123 abc 123 abc 123";

    // str1.erase(0,3);// 第一个参数：从哪里开始，第二个参数：删除几个（默认值，字符串结尾）

    // 迭代器删除 2 bc 123 abc 123 解释
    for(string::iterator it = str1.begin(); it<str1.begin()+3; it++){ // 删除一个节后都会从头开始计算
        str1.erase(it);
    }

打印结果：

// 删除一个节后都会从头开始计算
2 bc 123 abc 123

1.6. 替换

• str1.replace(0,6,"1234");：从0开始，替换6个字符

    string str1 = "123 abc 123 abc 123";

    // 第一个参数：从哪里开始
    // 第二个参数：替换几个
    // 第三个参数：替换成谁
    str1.replace(0,6,"1234");

打印结果：

1234c 123 abc 123

1.7. 查找

• str1.find("123",0);：// 查找谁，从哪里开始
• str1.rfind("123");：// 从后面往前找

    string str1 = "123 abc 123 abc 123";
    // 查找谁，从哪里开始
    // int position = str1.find("123",0);
    // 从后面往前找
    int position = str1.rfind("123");

打印结果：

0,16

1.8. 大小写转换

• transform(str1.begin(),str1.end(),str1.begin(),::toupper);：转大写
• transform(str1.begin(),str1.end(),str1.begin(),::tolower);：转小写

int main(){
    string str1 = "AAA abc BBB abc 123";
    // 转换成大写
    transform(str1.begin(),str1.end(),str1.begin(),::toupper);

    // 转小写
    transform(str1.begin(),str1.end(),str1.begin(),::tolower);

    cout << str1.c_str() << endl;
}

2. c++ 相对 c 的一些增强

2.1 实用性增强

    int a;
    printf("hello");
    
    a=10;
    int b; // 有的编译器不通过， c++ 中肯定能通过
    b = 10;

2.2 register 增强(c中报错，c++可以通过)

	// 寄存器上面的变量不能取地址，register 快速
	register int a = 10;  // c中报错，c++可以通过
	printf("%d",&a);
	getchar();

2.3 参数增强 (以下代码，c中没问题，c++中会检测报错)

// 参数处理增强
    int a = 10;
    int a;
    
    void main(){
    
        printf("%d",a);// c中没问题，c++中会检测报错
    
        getchar();
    }

2.4 检测增强 (以下代码，c中没问题，c++中会检测报错)

    f(){
        return -1;
    }
    
    // 检测增强
    void mian(){
        printf("%d",f()); // c中没问题，c++中会检测报错
        getchar();
    }

3. const 关键字

const 使用场景：

    // 1. 修饰变量不可改变
    // const int number = 1;
    // 修饰指针 常量指针，指针常量
    int number = 1;
    // const int *n_p = &number;
    // *n_p = 3; // 常量指针不能改变值
    // 指针常量
    int *const n_p = &number;
    int a = 200;
    // n_p = &a; // 指针常量不能修改值

    // 拷贝构造函数，操作符重载，方法后面（都是由于它的成员不可改变）

区别：

• c 里面 const 是一个伪命题，可以通过指针去操作，编译时期的检测
• c++ 里面不光在编译时期做处理，还在运行时做了处理

4. 引用加强

其实引用的本质就是 指针

class Student {
private:
    string name;
public:
    Student(string name) : name(name) {}

    string &getName() {// java 想都别想
        return this->name;
    }
};

int main(){
    Student stu = Student("eastrise");

    // 改不动
    // stu.getName() = "Jack";

    stu.getName() = "Jack";

    cout << stu.getName() << endl;

    // vector front back

}