本质:string
是C++风格的字符串,而string的本质是一个类
string
与char*
的区别:
char*
是一个指针;string
是一个类,类内部封装了char*
,管理这个字符串,是一个char*型的容器;特点:
构造函数原型:
string();
//创建一个空字符串,例如:string strstring(const char* s);
//使用字符串s初始化;string(const string& str);
//使用一个string对象的初始化另一个string对象string(int n,char ch);
//使用n个字符ch初始化函数原型:
string& operator=(const char * s);
//char*类型字符串 赋值给当前的字符串;string& operator=(const string &s);
//把字符串s赋给当前的字符串string& operator=(char c);
//字符赋值给当前的字符串string& operator=(const char * s);
//把字符串s赋给当前的字符串string& operator=(const char * s,int n);
//把字符串s的前n个字符赋给当前字符串string& operator=(const string &s);
//把字符串s赋值给当前字符串string& operator=(int n, char c);
//把n个字符赋值给当前字符串函数原型:
string& operator+=(const char * s);
string& operator+=(const string &s);
string& operator+=(char c);
string& append(const char * s);
string& append(const char * s,int n);
//连接前n个string& append(const string &s);
string& append(int n, char c);
string& append(const string &s,int pos,int n)
//将字符串s从pos位置开始截取n个;#include
#include
using namespace std;
void test01() {
string str = "abcdefg";
str.replace(1, 3, "00000");
//从1号位置其,将其三个字符替换为00000
cout << str;
}
int main() {
test01();
return 0;
}
/*
a00000efg
*/
=
返回 0
;>
返回 1
;<
返回 -1
;void compare(const string &s) const;
void compare(const char * s) const;
char& operator[](int n);
char& at(int n);
string& insert(int pos,const char* s);
//插入字符串string& insert(int pos,const string& str);
//插入字符串string& insert(int pos,int n,char c);
//在指定位置插入单个字符string& erase(int pos,int n = npos);
//删除从pos开始的n个字符string substr(int pos = 0,int n = npos) const;
vector v;
//采用模板创建一个vector容器,使用默认构造;vector(v.begin(),v.end());
//将[v.begin(),v.end())区间中的元素拷贝给本身;vector(n,elem);
//构造函数将n个elem拷贝给本身;vector(const vector &vec);
//拷贝构造函数;vector& operator=(const vector &vec;)
//重载等号操作符;assign(begin,end);//将[begin,end)
区间中的数据拷贝赋值给本身;assign(n,elem);
//将n个elem拷贝赋值给本身;empty();
//判断容量是否为空 – 返回true为空,否则非空;capacity();
//容器的容量;size();
//返回容器中元素的个数;resize(int num);
//重写指定容器的长度为num,若容器变长,则默认值(0)填充新位置。如果容器变短,则末尾超粗容器长度的元素被删除。resize(int num,elem);
//重新指定容器的长度为num ,若容器变长,则以elem值填充新位置;如果容器变短,则末尾超出容器长度的元素被删除;push_back(ele);
//尾部插入元素ele;pop_back();
//删除最后一个元素;insert(const_iterator pos,ele);
//迭代器指向位置pos插入元素ele;insert(const_iterator pos,int count,ele)
;//迭代器指向位置为pos插入count个元素ele;erase(const_iterator pos);
//删除迭代器指向的元素;erase(const_iterator start,const_iterator end);
//删除迭代器从start到end之间的元素;clear();
//删除容器中所有的元素; at(int idx); //返回索引idx所指的数据;-- v.at(idx);
operator[]; //返回索引idx所指的数据;
front(); //返回容器中第一个数据元素;
back(); //返回容器中最后一个数据元素;
swap(vec);
//将vce容器与本身的元素进行交换;
resize();
重新指定大小的时候,容器的容量不会改变,会造成内存浪费,这时可以利用swap();来收缩内存;vector(v).swap(v);
resize();
重新指定大小的容器;vector(v)
是利用创建匿名对象;原理:利用swap()交换对象元素之后,预期得到的v容器将容量缩小到和大小一样,而匿名对象由于C++的语法机制,在执行完当前行代码之后,操作系统会帮我们直接释放掉该匿名对象的空间,防止内存浪费;
reserve(int len);
//容器预留 len 个元素长度,预留位置不初始化,元素不可访问;#include
#include
using namespace std;
void test01() {
vector<int> v;
int num = 0;
int *p = NULL;
for(int i = 0; i<10000; i++) {
v.push_back(i);
if(p != &v[0]) {
p = &v[0];
num++;
}
}
cout<<"未预留空间:"<<endl;
cout<<num<<endl;
}
void test02() {
vector<int> v;
//预留空间
v.reserve(10000);
int num = 0;
int *p = NULL;
for(int i = 0; i<10000; i++) {
v.push_back(i);
if(p != &v[0]) {
p = &v[0];
num++;
}
}
cout<<"预留空间:"<<endl;
cout<<num<<endl;
}
int main() {
test01();
test02();
return 0;
}
/*
未预留空间:
15
预留空间:
1
*/
deque容器基本概念
deque deqT;
//默认构造函数;deque(d1.begin(),d1.end());
//构造函数将[begin,end)区间中的 元素拷贝给本身;deque(n,elem);
//构造函数将n个elem拷贝给本身;deque(const deque &deq);
//拷贝构造函数deque& operator=(const deque &deq);
//重载等号操作符assign(d1.begin(),d1.end())
//将该区间中的数据拷贝赋值给本身;assign(n,elem);
//将n个elem拷贝赋值给本身;deque.empty();
//判断容器是否为空;deque.size();
//返回容器中元素的个数;deque.resize(num);
//重新指定容器的长度为num,若容器变长,则以默认值填充新位置;如果容器变短,则末尾超出长度的元素被删除;deque.resize(num,elem)
; //重新指定容器的长度,若容器的长度变长,则以elem值填充;长度变短,则删除超过容器长度的元素;push_back(elem);
//在容器尾部添加一个元素;push_front(elem);
//在容器头部添加一个元素;pop_back();
//删除容器最后一个元素;pop_front();
//删除容器第一个元素;insert(pos,elem);
//在pos位置插入一个elem元素的拷贝 并返回新数据的位置;insert(pos,n,elem);
//在pos位置插入n个elem数据,无返回值insert(pos,beg,end);
//在pos位置插入区间数据,无返回值;clear();
//清空容器数据;erase(beg,end);
//删除区间数据,返回下一个数据的位置;erase(pos);
//删除pos位置的数据,返回下一个数 据的位置;at(int idx);
//返回索引idx所指的数据;-- d.at(idx);
operator[];
//返回索引idx所指的数据;front();
//返回容器中第一个数据元素;back();
//返回容器中最后一个数据元素;概念:stack是一种先进后出(First in Last Out,FILO)的数据结构,它只有一个出口;
栈中只有栈顶的元素可以被外界使用,因此栈不允许有遍历行为;
可以判断是否为空;
可以返回元素个数 – 进一个元素,计数一次;
stack stk;
//stack采用模板类实现,stack对象的默认构造形式;stack(const stack &stk);
//拷贝构造函数stack& operator=(const stack &stk);
//重载等号操作符push(elem);
//向栈顶添加元素pop();
//从栈顶移除元素top();
//返回栈顶元素empty();
//判断堆栈是否为空size();
//返回栈大小Queue是一种先进先出(first in first out)的数据机构,它有两个出口;
队列容器允许从一端新增元素,从另一端移除元素。
队列只有队头和队尾才可以被外界使用,因此队列不允许有遍历行为;
队列中进数据称为 – 入队push
队列中出数据称为 – 出队pop
queue que;
//queue采用模板类实现,queue对象的默认构造形式queue(const queue &que);
//拷贝构造函数queue& operator=(const queue &que);
//重载等号操作符push(elem);
//往队尾添加元素pop();
//从队头移除一个元素back();
//返回最后一个元素front();
//返回第一个元素empty();
//判断堆栈是否为空size();
//返回栈的大小功能:对数据进行链式存储;
说明:
链表中的迭代器
由于链表的存储方式是非连续,因此链表list中的迭代器只支持前移后移;
属于双向迭代器;
链表的优点:
list l;
//list采用模板类实现,对象的默认构造形式list(beg,end);
//构造函数将该区间内中的元素拷贝给本身list(n,elem);
//构造函数将n个elem元素拷贝给本身list(const list &l);
//拷贝构造函数assign(beg,end);
//将区间中的数据拷贝赋值给本身assign(n,elem);
//将n个elem拷贝赋值给本身list& operator=(const list &list);
//重载等号操作符swap(list);
//将list与本身的元素互换size();
//返回容器中元素的个数empty();
//判断容器是否为空resize(num);
//重新指定容器的长度为num,若容器变长,则以默认 值填充新位置;如果容器变短,则末尾超出容器长度 的元素被删除resize(num,elem);
//重新指定容器的长度为num,容器变长时用elem填 充;变短时则删除超出部分;push_back(elem);
//尾插元素pop_back();
//尾删元素push_front();
//头插元素pop_front();
//头删元素insert(pos,elem);
//在pos位置插入elem元素,并返回新数据位置insert(pos,n,elem);
//在pos位置插入n个elem元素,无返回值insert(pos,beg,end);
//在pos位置插入该区间的元素clear();
//清空链表erase(beg,end);
//擦除该区间内的数据erase(pos);
//擦除该位置的数据remove(elem);
//删除容器中所有与elem值匹配的元素front();
//返回第一个元素back();
//返回最后一个元素reverse();
//反转链表sort();
//链表排序
• 简介:所有元素都会在插入时自动被排序;
• 本质:set/multiset属于关联式容器,底层结构是用二叉树实现
• set和multiset的区别:
o set不允许容器中有重复的元素;
o multiset允许容器中有重复的元素;
• set容器插入数据只有s.insert()方法;
• 构造:
o set
//类模板默认构造
o set(const set
//拷贝构造
• 赋值:
o set& operator=(const set
//重载等号操作符
• size();
//返回容器中元素的数目
• empty();
//判断容器是否为空
• swap(s);
//交换两个集合容器
• insert(elem);
//在容器中插入元素
• clear();
//清空容器
• erase(pos);
//删除pos迭代器所指的元素,返回下一个元素的迭代器
• erase(beg,end);
//删除区间内部所有的迭代器,返回下一个元素的迭代器
• erase(elem);
//删除容器中值为elem的所有元素
• find(key);
//查找key是否存在,若存在则返回该key的元素位置,不存 在则返回 set.end();
• count(key);
//统计key的元素个数
• 功能描述:成对出现的数据,利用对组可以返回两个数据;
• 两种创建方式:
o pair
o pair
#include
#include
using namespace std;
void test01() {
pair<string,int> p("Chris",20);
cout<<"访问对组的内容:"<<endl;
cout<<"姓名:"<<p.first<<endl;
cout<<"年龄:"<<p.second<<endl;
}
void test02() {
pair<string,int>p2 = make_pair("Song",19);
cout<<"访问对组的内容:"<<endl;
cout<<"姓名:"<<p2.first<<endl;
cout<<"年龄:"<<p2.second<<endl;
}
int main() {
test01();
cout<<endl;
test02();
return 0;
}
/*
访问对组的内容:
姓名:Chris
年龄:20
访问对组的内容:
姓名:Song
年龄:19
*/
• 目标:利用仿函数,可以改变排序顺序规则;
o 仿函数 – 重载“()”运算符。
#include
#include
using namespace std;
void printSet(const set<int> &s) {
for (set<int>::const_iterator it = s.begin(); it != s.end(); it++) {
cout << *it << ' ';
}
cout << endl;
}
void test01() {
set<int> s1;
s1.insert(1);
s1.insert(3);
s1.insert(5);
s1.insert(4);
s1.insert(2);
s1.insert(6);
printSet(s1);
}
//改变容器的排序方式
class MyCompare {
public:
bool operator()(int a, int b) const
{
return a > b;
}
};
void test02() {
set<int, MyCompare> s2;
s2.insert(1);
s2.insert(3);
s2.insert(5);
s2.insert(4);
s2.insert(2);
s2.insert(6);
//printSet(s2);
for (set<int>::const_iterator it = s2.begin(); it != s2.end(); it++) {
cout << *it << ' ';
}
cout << endl;
}
int main() {
test01();
test02();
return 0;
}
/*
1 2 3 4 5 6
6 5 4 3 2 1
*/
• map 中所有元素都是 pair(对组);
• pair 中第一个元素为 key(键值),起到索引的作用,第二个元素为value(实值);
• 所有元素都会根据元素的键值自动排序;
• 本质:
o map/multimap属于关联式容器,底层结构是用二叉树实现的;
• 优点:可以根据key值快速找到value值;
• map/multimap区别:
o map 不允许容器中有重复key值元素;
o multimap 允许容器中有重复 key 值元素;
• 构造:
o map
//类模板默认构造
o map(const map &m);
//拷贝构造函数
• 赋值:
o map& operator=(const map &m);
//重载等号运算符
• size();
//返回容器中元素的数目
• empty();
//判断容器是否为空
• swap(m);
//交换两个集合容器
• insert(elem);
//在容器中插入元素
• clear();
//清楚所有元素
• erase(beg,end);
//删除区间中的所有元素,返回下一个元素的迭代器
• erase(pos);
//删除pos迭代器所指的元素,返回下一个元素迭代器
• erase(key);
//删除容器中值为key的元素
• find(key);
//查找key是否存在,返回该键元素的迭代器,否则返回end();
• count(key);
//统计key的元素个数
• 主要利用仿函数改变排序规则
#include
#include
using namespace std;
//降序规则
class myCompare {
public:
bool operator()(int a, int b) const {
return a > b;
}
};
void printMap01(const map<int, int>& m) {
for (map<int, int>::const_iterator it = m.begin(); it != m.end(); it++) {
cout << "the key is:\t" << it->first << endl;
cout << "the value is:\t" << it->second << endl;
}
}
void printMap02(const map<int, int,myCompare>& m) {
for (map<int, int,myCompare>::const_iterator it = m.begin(); it != m.end(); it++) {
cout << "the key is:\t" << it->first << endl;
cout << "the value is:\t" << it->second << endl;
}
}
void test01() {
map<int, int> m;
m.insert(make_pair(2, 10086));
m.insert(make_pair(1, 10010));
m.insert(make_pair(3, 10000));
printMap01(m);
}
void test02() {
map<int, int, myCompare> m;
m.insert(make_pair(2, 10086));
m.insert(make_pair(1, 10010));
m.insert(make_pair(3, 10000));
printMap02(m);
}
int main() {
test01();
cout << endl;
test02();
return 0;
}
/*
the key is: 1
the value is: 10010
the key is: 2
the value is: 10086
the key is: 3
the value is: 10000
the key is: 3
the value is: 10000
the key is: 2
the value is: 10086
the key is: 1
the value is: 10010
*/