一、 字符串#

字符串是最常用的一种数据类型了，在python中声明字符串和声明其他类型的数据一样，都非常的简单。但是在c++中，对于字符串的操作，相对来说要稍微复杂一些。

C++ 提供了以下两种类型的字符串表示形式：

  • C 风格字符串
  • C++ 引入的 string 类类型

1. C 风格字符串#

C 风格的字符串起源于 C 语言，并在 C++ 中继续得到支持。字符串实际上是使用 null 字符 \0 终止的一维字符数组。如下面的声明和初始化创建了一个 "Hello" 字符串。由于在数组的末尾存储了空字符，所以字符数组的大小比单词 "Hello" 的字符数多一个。

1
2
3
4
5
6
7
8
9
int main(){

    char greeting[6] = {'H', 'e', 'l', 'l', 'o', '\0'};

    //可以简写成：
    char greeting2[] = "Hello";

    return 0 ;
}

2. C风格字符串操作#

1. 遍历字符串#

字符串实际上背后还是一个数组，所以可以使用数组遍历的手法来获取每一个字符 。 

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
#include<iostream>
int main(){

    //最后总会跟着一个\0的空字符，此时括号中如果写长度，必须大于等于6
    char  name[] = "hello";

    for (int i = 0; i < sizeof(name ) / sizeof(char); ++i) {
        std::cout << name[i] << std::endl;
    }
}

2. 字符串其他操作#

C语言中提供了针对字符串操作的大量函数，不过在使用之前，需要先引入 #include<cstring>

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
#include <iostream>

int main(){

    //拷贝字符串
    char  name[] = "hello";
    char name2[6];

    //参数一： 目标字符串， 参数二：源字符串
    strcpy(name2 , name);
    std::cout << name2 << std::endl;

    //拼接字符串
    strcat(name2 , " , 张三");
    std::cout << name2 << std::endl;

    // 返回字符串长度
    int len = strlen(name2);
    std::cout << "name2的长度：" << len << std::endl;

    return 0 ;
}

3. C++ 风格字符串#

C++ 标准库提供了 string 类类型,支持上述所有的操作，另外还增加了其他更多的功能。需要引入 #include ，由于string类声明在命名空间 std ,所以在使用的首要注意 命名空间的联合使用

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
//引入string库
#include <string>

using namespace std;

int mian(){

    string s1;
    string s2 {"北京"};
    string s3{s2};

    string s4 = "你好";

    s1 = s3;
    return 0 ;
}

4. C++风格字符串操作#

  • 拼接字符串

c++的字符串拼接，使用起来比较方便，直接使用+ 操作即可。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
#include<string>
using namespace std;

int main(){
    string part1 {"c++"};
    string part2 {" is a powerful"};

    string sentence ; 
    sentence = part1 + part2 ;
    return 0 ;
}
  • 获取指定位置的字符

可以使用[]和 at（）操作字符串

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
#include<string>
using namespace std;

int main(){
    string s1 {"i love c++"};

    cout << s1[3]<<endl;
    cout << s1.at(0) << endl;
   return 0 ;
}
  • 遍历字符串
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
#include<string>
using namespace std;

int main(){
    string s1 {"abcdef"};

    for(char s : s1){
        cout << s << endl;
    }

    for(int s : s1){
        cout << s <<endl;
    }
    return 0 ;
}
  • 字符串比较

字符串也是可以比较大小的。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
#include<string>
using namespace std;

int main(){

    string s1{"Apple"};
    string s2{"Banana"};
    string s3 {"kiwi"};
    string s3 {"apple"};
    string s3 {s1};

    s1 == s5 // true
    s1 == s2 // false
    s1 != s2 // true
    s1 < s2 // True
    s1 > s2 // false
    s1 == "Apple" // false

    return 0 ;
}
  • 截取字符串
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
#include<string>
using namespace std;

int main(){

    substr(开始索引， 截取长度);

    string s1 {"This is a test"};
    cout << s1.substr(0 , 4) ; // This

    return 0 ;
}
  • 获取字符（字符串）在字符串中的索引
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
#include<string>
using namespace std;
int main(){
    find(搜索的字符)

    string s1 {"This is a test"};
    cout << s1.find("This") ; // 0 
    cout << s1.find("is") ; // 2
    cout << s1.find("test") ; // 10 

   return 0 ;
}
  • 获取字符串长度

length() : 返回字符串长度

二、 Vector#

Vector其实很大程度上和数组一样，只是，数组是固定长度，而vector是不定长度（动态增长）。 假设我们需要记录明年的测试成绩，但是我们并不知道明年会有多少个学生。那么可以有两种选择，定义一个固定长度的数组，这个长度超过假设的长度， 另一种办法就是使用动态数组，比如是： vector

vector 在C++STL(标准模板库)中的一个容器，可以看成是对容器的一种扩展。在运行时可以改变长度 , 与数组具有相似的语法 , 相比数组更高效 , 提供越界检查

1. 声明和初始化#

  • 声明

使用vector除了要导入#include之外，由于它声明于std命名空间里面，所以要配合std命名空间使用

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
#include <vecotr>
using namespace std;

int main(){

    vector <char> vowels; 
    vector <int> test_score;

    // =========================
    vector <char> vowels(5);  //声明一个初始大小为5的char类型vector
    vector <int> test_score(10);
    return 0;
}
  • 初始化
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
#include <vecotr>
using namespace std;

int mian(){
    //数组定义
    int test_score []{100,99,18,81}

    //vector定义
    vector <char> vowels {'a' , 'e' , 'i' , 'o' ,'u'}; 
    vector <int> test_score{ 100 ,98,95,90,80};
    vector <double> temperatures{26,20.7};

    return 0;
}

2. 访问vector#

访问 vector中的元素有两种方式，一是仍以数组的方式，另一种是使用vector提供的at函数

  • 数组的语法
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
#include <iostream>
#include <vector>
using namespace std;

int main(){
    vector<int> test_score {100,90,85};

    cout << "第一个成绩是: " <<test_score[0] << endl;
    cout << "第二个成绩是: " <<test_score[1] << endl;
    cout << "第三个成绩是: " <<test_score[2] << endl;

    cout << "第三个成绩是: " <<test_score[3] << endl;  //不会检查越界
    return 0 ;   
}
  • vector的语法
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
#include <iostream>
#include <vector>
using namespace std;

int main(){

    vector<int> test_score {100,90,85};

    cout << "第一个成绩是: " <<test_score.at(0) << endl;
    cout << "第二个成绩是: " <<test_score.at(1) << endl;
    cout << "第三个成绩是: " <<test_score.at(2) << endl;

    cout << "第三个成绩是: " <<test_score.at(3) << endl; //抛出越界异常
    return 0 ;
}

3. 操作vector#

  • 修改vector中的元素
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
#include <vector>
using namespace std;

int main(){

    vector<int> test_score {100,90,85};
    test_score.at(0) = 73;

    return 0 ;
}
  • 往vector中追加元素
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
#include <vector>
using namespace std;

int main(){
    vector<int> test_score {100,90,85};

    test_score.push_back(80); // 100 , 90 , 85 , 80
    test_score.push_back(95); // 100 ， 90 ， 85 ， 80 ， 95

    return 0 ;
}
  • 越界检查

只要当我们使用了vector的语法去获取超出索引的元素时，就会抛出异常。而使用数组的语法去获取元素，则不会进行越界检查

  • 遍历vector
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
#include <iostream>
#include <vector>
using namespace std;

int main(){

    //使用下标遍历
    vector<int> scores{ 100 ,95 ,88 ,80 ,75};
    for (int i = 0; i < scores.size(); ++i) {
        cout << scores[i] << endl;
    }

    //基于范围for遍历
    vector<int> scores{ 100 ,95 ,88 ,80 ,75};
    for(int score : scores){
        cout << score << endl;
    }
    return 0 ;
}

4. 二维vector#

二维vector和二维数组实际上差不太多，二维数组是数组里面装的是数组，二维vector指的是vector里面装的还是vector，在未来碰到矩阵相关的存储操作，多半使用vector来作为媒介。 比如下面的例子，演示了使用vector来存储3个班的考试成绩。每个班的成绩单独使用一个vector来存储。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
#include <iostream>
#include <vecotr>
using namespace std;

int main(){

    //声明并初始化vector
    vector<vector<int>> scores {
            {95,77,80,85},
            {58,89,93,100},
            {69,73,81,97}
    };

    for (int i = 0; i < scores.size(); ++i) {
        for (int j = 0; j < scores[i].size(); ++j) {
           cout << scores[i][j] <<"\t" ;
        }
        cout << endl;
    }
    return 0 ;
}