JAVA 转 C++ 必记 PartB

来源：互联网发布：小米推送php demo 编辑：程序博客网时间：2024/06/06 00:18

JAVA 转型C++必记 partB

顺序容器

有5个顺序容器和其特性：

vector : 可变的数组，支持快速随机访问。在尾部以外插入元素和删除元素可能会很慢。

deque：双端列表。支持快速随机访问，在头部和尾部以外插入和删除元素可能会很慢。

list：双向链表，支持双向顺序访问，在任意插入或者删除速度好快。

forward_list ：单向链表，支持单向顺序访问。在任意插入或者删除速度好快。

string：类似于vector容器，随机访问快，在尾部插入和添加速度快。

顺序容器比较像JAVA的List，也像JAVA一样指定容器的存储类型，但是需要注意的是C++的容器是必须要在<>中指定类型的，而且他们叫做模板类不是JAVA所称为的泛型。

deque<double> deque_for_double;

容器的构造函数，有默认构造函数，还有以下两个构造函数

vector<noDefualt> v1(10); //如果有默认构造函数则成功通过编译，使用默认构造函数初始化10个元素

vector<NoDefault> v1(10,{10,”adsf"}); //使用指定的构造函数初始化10个成员。

vector<NoDefault> v2(v1) //复制v1所有元素为v2进行初始化，注意v1必须要和v2一样的容器类型以及元素类型一致，否则报错。

vector<NoDefault> v1 = {NoDefault(11, "11"), NoDefault(13, “13")}; //通过初始化列表进行初始化。

vector<NoDefault> v1 = {NoDefault(11, "11"), NoDefault(13, "13")};

deque<NoDefault> d1(v1.begin(),v1.end()); //通过迭代器进行初始化，不限制容器类型。

vector<NoDefault> v2(v1.begin(),v1.end());

迭代器

迭代器基本和内置数组的迭代器一致，其中end是指向最后一个元素的后一位。[begin,end)开闭区间。

vector<NoDefault> v1(10, {10, "adsf"});

vector<NoDefault>::iterator it = v1.begin();

while (it != v1.end()) {

static int index = 0;

cout << it->toString() << " ---- index : " << index++ << endl;

it++;

}

容器的迭代器函数：

v1.begin(); //这个是获得一个带const或者不带const的正向迭代器，做了begin做了const的重载，当v1是const的时候返回const_iterator。

v1.rbegin(); //这个获得一个反向的迭代器，同样做了const和非const的重载。

v1.cbegin(); //这个获得个正向的迭代器const版本。

v2.crbegin(); //这个获得一个反向的迭代器同样返回的是const版本。

const vector<NoDefault> v1(10, {10, "adsf"});

vector<NoDefault>::const_iterator iter = v1.begin(); //这里主要返回的是一个const版本。

const_iterator 不能修改容器的内容，即容器中元素也是不能修改元素中的成员数据的。

iter->setNumberAndText(0,”test"); //报错的是无法再到定义了const的成员函数。因为iter解引用之后是一个const的对象。

array 是类似于内置数组的容器，这个容器和内置数组一样都是固定了容器的长度无法自动扩展的。

array<int,10> ai1; //定义了一个array容器，int类型一共有10个元素。

array<int,10> ai1 = {10} //ai1数组第一个元素是10 其他9个为0。

array<int,10> newA1 = ai1 //array可以支持复制

assign 不同容器的元素替换

vector<string> v1 = {"A","B","C","D","F"};

deque<string> d1 = {"1","2","3","4","5","6","7","8"};

d1.assign(v1.begin(),v1.end()); //d1目前结果：ABCDF完全替换迭代器中的内容

需要注意的是array是不能使用assign的

使用swap讲两个相同容器的元素掉转，这个速度相当快，因为是直接掉转变量的指向。

vector<string> letter = {"A","B","C","D","F"};

vector<string> number = {“1","2","3","4","5"};

swap(letter,number); // 所有元素交换，与letter.swap(number);等价

获得容器大小，forward_list不能获得容器大小

vector<string> letter = {"A","B","C","D","F"};

cout << letter.size() << endl; //获得容器大小

cout << letter.max_size() << endl; //获得容器最大容量

cout << letter.empty() << endl; //获得容器是否为空

关于容器的运算符

1、如果两个容器的元素不一致，看首个不一致的元素进行对比。

2、如果两个容器的元素都一样，但是元素的数量不一样，数量多的大。

3、如果两个容器的元素和数量都一样则两个容器一样。

vector<int> v1 = {1,3,5,7,8,9};

vector<int> v2 = {1,3,6,7};

vector<int> v3 = {1,3,5,7,8};

vector<int> v4 = {1,3,5,7,8,9};

v2 > v1 // true 因为index 2的元素相对比，发现v2[2] 比 v1[2]要大。

v1 > v3 // true 因为v1和v3的元素基本一致，发现v1的元素大于v3。

v1 == v4 // true 因为v1无论元素和size都和v4一致。

注意：如果vector中的元素类型是自定义类就必须定义><=运算符，否则会产生错误。因为最终他们会使用元素中的对象的运算符。userA > userB 如果无定义>运算符则非法。

元素的增加和删除

push_back 添加元素到尾部,array和 forward_list 不能使用。

vector<string> letter = {"A","B","C","D","F"};

letter.push_back(“G”);

push_front 添加元素到头部，list、forward_list、deque之外不能使用push_front

deque<string> number = {"0","1","2","3","4","5"};

number.push_front(“-1”);

insert插入元素，list、deque、vector、string都支持 insert 函数，forward_list有自己特殊的insert的函数。

deque<string> number = {“0","1","2","3","4","5"};

number.insert(number.begin() + 2 , “1.5”); //开始的迭代器移动向后一定两位（即下标为2）的前面插入字符串“1.5”元素。

使用迭代器插入一组数据

deque<string> number = {"0","1","2","3","4","5"};

vector<string> number2 = {"-2","-1"};

number.insert(number.begin(),number2.begin(),number2.end());

number.insert(number.end(),{“6","7"}); //使用初始化列表插入

insert函数调用后返回新插入元素的迭代器

上面函数改成：

deque<string>::iterator iter = number.insert(number.end(),{“6","7"}); // *iter == “6”

使用emplace函数插入元素，使用emplace函数只需要传入需要添加的元素的构造方法元素即可。

deque<NoDefault> d1 = {NoDefault(0,"first_one")};

d1.emplace_front(-1,”-1"); //对应push_front

d1.emplace_back(1,”1"); //对应push_back

d1.emplace(d1.begin() + 2 ,1,”0.5"); // 对应insert

使用back 和front访问成员

deque<string> d1 = {"1","2","3"};

cout << d1.front() << endl; //每个容器都有front成员

cout << d1.back() << endl; // 除了forward_list容器之外都有back成员

访问成员函数都是返回相应元素的引用

deque<string> d1 = {"1","2","3"};

auto &first = d1.front();

first = “10"; //d1[0] == 10

auto last = d1.back();

last = “30"; //d1[2] == 3 因为这里不是引用，没有打上&

string &second = d1.at(1); //我们可以使用at函数获得元素的应用

second = “20"; // d1[1] == 20

cout << d1[0] << "," << d1[1] << "," << d1[d1.size() - 1] << endl; //同样我们可以使用下标的方式获得元素的引用。

注意：不支持随机访问的容器强制使用会产生异常，forward_list , list不支持随机访问。

容器中删除元素

deque<string> d1 = {“1","2","3","4","5","6"};

d1.pop_back(); //删除最后的一个元素，返回void

d1.pop_front(); //删除最前面的一个元素，返回void

pop_back(); 同样是在forward_list、array中不支持的

pop_front(); 同样是在vector、array中不支持的

同时可以使用erase指定删除元素。

auto iter = d1.erase(d1.begin() + 3); //传入需要删除的迭代器,并返回被删除元素的后个迭代器

cout << *iter << endl; //输出字符串5

可以使用clear 和 erase删除多个元素

auto iter = d1.erase(d1.begin() + 2, d1.end()); //删除除下标为2到容器的尾部，并返回容器的新尾部。

d1.clear(); //清空所有容器中的元素。

forward_list 有很多特殊的函数API下面就介绍一下：

由于forward_list 单向链表的原因，所以在删除或者插入元素都是需要获得插入或者删除的目标的前一个元素，如果我们想在最前面的元素中插入一个元素，那我们就需要获得想end迭代器一样的before_begin迭代器。

forward_list<string> flist = {"1", "2", "3", "4", "5", "6", "7", "8"};

auto prev = flist.before_begin(); //由于删除元素需要获得目标元素的前一个元素

auto curr = flist.begin();

while (curr != flist.end()) {

int itemVal = stoi(*curr);

if (itemVal % 2 == 0) {

curr = flist.erase_after(prev);

} else {

prev = curr;

curr++;

}

同样我们可以使用独特的erase函数

forward_list<string> flist = {"1", "2", "3", "4", "5", "6", "7", "8"};

auto iter = flist.erase_after(++flist.begin()); //此处删除的是字符串3下标为2的元素，但是传入的迭代器是下标为1的迭代器。

cout << *iter << endl; //此处返回4则删除的目标元素后一个位迭代器。

flist.insert_after(++flist.begin(),”2.5”); //添加一个元素到下标为2的后一位。

forward_list<string> flist = {"1", "2", "3", "4", "5", "6", "7", "8"};

flist.erase_after(++flist.begin(),flist.end()); //删除一组范围的元素，剩下1和 2 两个元素。

关于顺序容器的resize函数

vector<string> v1 = {"0","1","2","3","4","5"};

v1.resize(10,”undefine"); //由于函数中有6个元素，v1扩容到10个元素，新增的元素为”undefine”，如果后面的参数不传则使用string的默认构造。

v1.resize(3); //如果resize的元素比原来容器中的元素还要少，则删除后面的元素。剩下 0 1 2 三个元素。

关于对容器操作后，会使得迭代器失效

1、vector、string容器在存储控制重新分配之后迭代器无效，如果在插入元素，在插入元素之前的迭代器仍然有效，如果在插入之后的迭代器则无效。

2、deque在除了首尾插入元素迭代器仍然有效之外，其余插入操作到会导致迭代器失效

3、如果是链表插入数据后，迭代器仍然有效。list和 forward_list 就是链表。

4、删除链表中的元素之后，不是指向被删除的迭代器仍然有效。

5、deque 如果删除除了首尾之外的元素，都会导致迭代器失效，如果删除尾部元素，end迭代器也会失效。

6、vector 被删除的元素前面的迭代器仍然有效，但是注意的是删除元素后end迭代器会失效。

注意：所以如果判读是否为结尾，最好都是本次都调用end函数获得尾部迭代器。

关于vector 的容量管理

vector<string> v1 = {"0", "1", "2", "3", "4", “5"};

cout << v1.capacity() << endl; // 获得在不从新分配空间的情况下可存储个数

v1.reserve(30); // 分配至少可以容纳30个元素的空间

cout << v1.capacity() << endl;

v1.shrink_to_fit(); // 将capacity和 size的容量一致，只要添加元素就会重新分配空间。

cout << v1.capacity() << endl;

String 的实用方法

char *cp = "what the fuck!";

char noNull[] = {'F', 'U', 'C', 'K'};

string s1(cp); //从char指针初始化字符串

string s2(cp + 9, 4); //从char指针移动9位然后截取4个字符结果：fuck

string s3(noNull); //错误因为noNull 最后一个元素没有一个空字符，作为结尾符

char haveNull[] = {'F', 'U', 'C', 'K', ' ‘}; //这个比noNull多了一个空字符做结尾符。

string s4(haveNull); //从字符数组初始化字符串

string s5(noNull, 4); //从字符数组中获得4个字符并初始化

string s6(s1,9); //从字符串中从下标为9到结尾获得字符寸进行初始化

string s7(s1,9,4); //从字符串下标为9开始获取4个字符进行初始化

同时string支持insert erase assign函数。

而且还支持append 和 replace函数进行字符串修改

string s1 = "what the ...";

s1.replace(9,3,”fuck"); //在下标为9开始删除3个字符然后删除的位置添加fuck字符串

cout << s1 << endl; //输出结果 what the fuck

s1.append(“!!!"); //在s1结尾添加 !!!字符串

cout << s1 << endl; //输出结果 what the fuck!!!

string name("TonyYan");

auto pos = name.find(“Tony"); //这个等同于 java的 indexOf

string something("skdkl56akk21dsdf");

string number(“0123456789");

auto index = something.find_first_of(number); //在something字符串中获得number的任意字符位置就是有数字的第一个下标，这里返回5

string something("56dd23232");

string number("0123456789");

auto index = something.find_first_not_of(number); //返回不存在number中的任意字符的下标，结果为2

逆向搜索有:

string sentence = "what the fuck! what going on?";

sentence.rfind(“what");

auto pos1 = sentence.find_last_of(“!,.?");

auto pos1 = sentence.find_last_not_of(“?!,.");

除了使用关系运算符还可以使用类似JAVA的字符串对比方法

string a = "abd";

string b = "abc";

auto result = a.compare(b); //返回1 因为a大于b 如果等于返回0 大于返回大约0的值如果小于返回负数

字符串转换其他类型

int i = 88;

string i_string = to_string(i);

int i = 88;

string i_string = to_string(i);

string snumber_int = "1";

int nunber_int = stoi(snumber_int);

string snumber_double = "23.66";

double number_double = stod(snumber_double);

相应的转型函数都是以sto开头然后结合类型的缩写，例如stold转成 long double。

容器适配器

所谓的容器适配器就是对顺序容器进行进一步的封装

一共有三种容器适配器

stack、queue、priority_queue

同样函数：

empty、size、swap、size_type[size的类型]、value_type[元素类型]、container_type容器实现

栈适配器

stack可以接受底层容器有list vector deque，默认情况下的底层是使用deque

stack<int> s1; //如果需要指定相应的底层容器可以写成 stack<int,vector<int>> s1;

for (size_t ix = 0; ix != 10; ++ix) {

s1.push(ix);

}

while(!s1.empty()){

cout << s1.top() << endl; //获得最后一个元素

s1.pop(); //弹出最后一个元素

}

queue 和 priority_queue

queue 是采用了标准的前进先出策略，而priority_queue使用优先级进行顺序安排的。

priority_queue 默认使用vector实现。

queue相应的比stack多出一下函数可以使用

front 获得首个元素或者尾部元素

back 获得尾部元素，只能在queue使用。

而priority_queue是采用<操作符来判断优先级的。如果是int的话肯定数字越大优先级就越高了。

priority_queue<int> pq;

pq.push(6);

pq.push(2);

pq.push(5);

pq.push(8);

pq.push(1);

while(!pq.empty()){

cout << pq.top() << ends;

pq.pop();

} //输出结果为：86521 数字越大越优先

关于一些不限制容器类型的算法函数，包括查找、排序、唯一排除等。

这些算法函数都是来自两个头文件：

#include <algorithm>

#include <numeric>

find函数，传入开始和结尾迭代器、需要查找的数据，返回结果的迭代器，如果没有查找到相应的元素返回一个结尾迭代器。