1.vector 容器
/***** vector 构造函数讲解 ***********************************
*vector() 无参构造
*vector(const vector &stl); 拷贝构造
*vector(Iterator begin,Iterator end); 区间赋值构造
*vector(int count,Type value); N个值赋值
*经常用的构造: 无参 和 区间赋值构造
* **************************************************/
/************** 操作相关 **************
*赋值:
* =号赋值运算符重载
* assign()函数 ------- 支持区间 与拷贝函数差不多
*容量和大小:
* empty()判断容器是否为空
* capacity()容器的容量
* size()当前容器的元素个数
* resize()重新指定容器的长度
*插入和删除:
* push_back()尾部插入
* pop_back()尾部删除
* insert()任意插入 ----- 支持区间
* erase()任意删除
* clear()清空容器
*数据存取:
* at() 返回下表数据
* []号取值运算符重载
* front()第一个元素
* back()最后一个元素
*
*记住:可以支持区间操作,其他容器只要支持迭代子遍历都可以支持区间赋值
* ***********************************/
/*********** vector容器的容量变化 ****************************
*发现结果: 数据容量成指数增长,
* 缺点:①照成空间浪费 ②每次增长浪费时间
* 解决方案:开局就超神 <-> 提前分配空间
*
*通过学习Vector总结:
* 优点: 访问快,尾删和尾增快
* 缺点: 非尾删和非尾增效率低,增加元素需要申请新空间并拷贝,浪费效率
* 不适合(排序等需要改变的算法)
* ********************************************************/
代码：
#include <iostream>
/**** STL 的头文件名与类名相同 ****/
#include <vector> /* 单端数组 */
#include <algorithm> /* 通用算法库 */
using namespace std; /* 引入标准命名空间 */
/***** 构造函数讲解 ***********************************
*vector() 无参构造
*vector(const vector &stl); 拷贝构造
*vector(Iterator begin,Iterator end); 区间赋值构造
*vector(int count,Type value); N个值赋值
*经常用的构造: 无参 和 区间赋值构造
* **************************************************/
void test0()
{
vector<int> v1; /* 无参构造 */
vector<int> v2(v1); /* 拷贝构造 */
vector<int> v3(v1.begin(),v1.end()); /* 区间赋值构造 */
vector<int> v4(10,3);/* N个值赋值 */
/**** 普通迭代子 ********/
vector<int>::iterator it;
for(it = v4.begin() ; it != v4.end() ; it++) // *it = int 类型
{
cout << *it << ",";
}
cout << endl;
/**** 使用 for_each ************************
* _func => void func(Type value)
* 注意事项:一般算法库,策略函数参数,传参类型都是 Type 变量类型
* ****************************************/
void Print_int(int value); /*函数内部声明*/
for_each(v4.begin(),v4.end(),Print_int);
cout << endl;
}
void Print_int(int value)
{
cout << value << ",";
}
/************** 操作相关 **************
*赋值:
* =号赋值运算符重载
* assign()函数 ------- 支持区间
*容量和大小:
* empty()判断容器是否为空
* capacity()容器的容量
* size()当前容器的元素个数
* resize()重新指定容器的长度
*插入和删除:
* push_back()尾部插入
* pop_back()尾部删除
* insert()任意插入 ----- 支持区间
* erase()任意删除
* clear()清空容器
*数据存取:
* at() 返回下表数据
* []号取值运算符重载
* front()第一个元素
* back()最后一个元素
*
*记住:可以支持区间操作,其他容器只要支持迭代子遍历都可以支持区间赋值
* ***********************************/
void test1()
{
vector<int> v;
/***** 插入 和 删除 *****/
for(int i = 0; i < 10;i++)
{
v.push_back(i);
}
/* 数据: 0,1,2,3,4,5,6,7,8,9 */
v.insert(v.end(),50);
v.insert(v.begin(),600);
v.insert(++v.begin(),900);
/* 数据: 600,900,0,1,2,3,4,5,6,7,8,9,50 */
/* 赋值操作 */
vector<int> temp; /*建立一个空的 容器 */
temp = v;
temp.assign(v.begin(),--v.end());
/* 删除 */
v.pop_back(); /* 尾部删除 50 */
v.erase(v.begin()); /* 指定迭代子位置删除 */
v.erase(v.begin(),v.end()); /*迭代子区间删除 <==> clear() 清空操作 */
/* 容量和大小 */
cout << "容量:" << v.capacity() << endl;
cout << "当前元素个数:" << v.size() << endl;
cout << "当前是否为空:" << (v.empty() == true ? "空" : "非空") << endl;
/* 遍历元素 */
for(size_t i = 0; i < v.size() ; i++)
{
cout << v[i] << ","; /* 通过 []运算符重载取值 */
//cout << v.at(i) << ","; /* 通过 at获取下标对应元素值 */
}
cout << endl;
if(v.empty() == false)
{
cout << "第一个元素:" << v.front() << endl;
cout << "最后一个元素:" << v.back() << endl;
}
/***** 打印temp临时容器的数据 *****/
for(size_t i = 0; i < temp.size() ; i++)
{
//cout << temp[i] << ","; /* 通过 []运算符重载取值 */
cout << temp.at(i) << ","; /* 通过 at获取下标对应元素值 */
}
cout << endl;
}
/*********** vector容器的容量变化 ****************************
*容量和大小:
* empty()判断容器是否为空
* capacity()容器的容量
* size()当前容器的元素个数
* resize()重新指定容器的长度
* reserve()预留空间 < ----- > 非常有必要
*
*发现结果: 数据容量成指数增长,
* 缺点:①照成空间浪费 ②每次增长浪费时间
* 解决方案:开局就超神 <-> 提前分配空间
*
*通过学习Vector总结:
* 优点: 访问快,尾删和尾增快
* 缺点: 非尾删和非尾增效率低,增加元素需要申请新空间并拷贝,浪费效率
* 不适合(排序等需要改变的算法)
* ********************************************************/
void test2()
{
vector<int> v;
/**** 开始时指定开辟空间长度 *****/
//v.resize(10);
v.reserve(10001);
cout << "指定长度后:元素个数:" << v.size() << "\t容量:" << v.capacity() << endl;
/**** 循环插入数据,探讨容量变化 ****/
for(int i = 0; i < 10000;i++)
{
v.push_back(i);
cout << "元素个数:" << v.size() << "\t容量:" << v.capacity() << endl;
}
cout << "**** 遍历容器 ****" << endl;
for(size_t i = 0; i < v.size();i++)
{
cout << v.at(i) << ",";
}
cout << endl;
}
int main()
{
test2();
return 0;
}
2.deque（双端数组）
/***** 讨论构造 *****
*deque() 无参构造
*deque(const deque &)拷贝构造
*deque(iterator begin,iterator end)区间构造
*deque(int count,Type value) N个值赋值构造
* ****************/
/************** 操作相关 **************
*赋值:
* =号赋值运算符重载
* assign()函数 ------- 支持区间
*容量和大小:
* empty()判断容器是否为空
* size()当前容器的元素个数
* resize()重新指定容器的长度
*插入和删除:
* push_back()尾部插入
* push_front()头部插入
* pop_back()尾部删除
* pop_front()头部删除
* insert()任意插入 ----- 支持区间
* erase()任意删除
* clear()清空容器
*数据存取:
* at() 返回下表数据
* []号取值运算符重载
* front()第一个元素
* back()最后一个元素
*
*记住:可以支持区间操作,其他容器只要支持迭代子遍历都可以支持区间赋值
*所以:
* deque 和 vector 差不多
* 增加了: 头部操作
* 删除了: 容量相关操作
* ***********************************/
代码：
#include <iostream>
#include <vector> /*单端数组 */
#include <deque> /*双端数组 */
#include <algorithm>/*通用算法库*/
using namespace std;/*引入标准命名空间 */
/***** 讨论构造 *****
*deque() 无参构造
*deque(const deque &)拷贝构造
*deque(iterator begin,iterator end)区间构造
*deque(int count,Type value) N个值赋值构造
* ****************/
//void Print(deque<int> &v)
//{
// deque<int>::iterator it;
// for(it = v.begin(); it != v.end() ;it++)
// {
// cout << *it << ",";
// }
// cout << endl;
//}
//void Print(vector<int> &v)
//{
// vector<int>::iterator it;
// for(it = v.begin(); it != v.end() ;it++)
// {
// cout << *it << ",";
// }
// cout << endl;
//}
template <class Type>
void Print(Type &v)
{
/**** auto 是自动根据 = 返回值类型做生成 ****/
for(auto it = v.begin(); it != v.end();it++)
{
cout << *it << ",";
}
cout << endl;
}
void test0()
{
/****** vector 容器 ****/
vector<int> v_temp(10,5); /* 数据:5,5,5,5,5,5,5,5,5,5 */
/****** deque 容器****/
deque<int> v1; /* 无参构造 */
deque<int> v2(v1);/*拷贝构造*/
deque<int> v3(v1.begin(),v1.end());/*区间构造*/
deque<int> v4(10,3);/*N个值赋值构造*/
/****** 套路区间构造,可以支持不同容器:只要支持双向迭代器 *****/
deque<int> v5(v_temp.begin(),v_temp.end());
/****** 打印数据 *****/
Print(v_temp);
Print(v4);
// deque<int>::iterator it;
// for(it = v5.begin(); it != v5.end() ;it++)
// {
// cout << *it << ",";
// }
// cout << endl;
/****** 容器也是一个类型 ****/
}
/************** 操作相关 **************
*赋值:
* =号赋值运算符重载
* assign()函数 ------- 支持区间
*容量和大小:
* empty()判断容器是否为空
* size()当前容器的元素个数
* resize()重新指定容器的长度
*插入和删除:
* push_back()尾部插入
* push_front()头部插入
* pop_back()尾部删除
* pop_front()头部删除
* insert()任意插入 ----- 支持区间
* erase()任意删除
* clear()清空容器
*数据存取:
* at() 返回下表数据
* []号取值运算符重载
* front()第一个元素
* back()最后一个元素
*
*记住:可以支持区间操作,其他容器只要支持迭代子遍历都可以支持区间赋值
*所以:
* deque 和 vector 差不多
* 增加了: 头部操作
* 删除了: 容量相关操作
* ***********************************/
void test1()
{
deque<int> v;
cout << "***** 插入数据 ****" << endl;
for(int i = 0; i < 10;i++)
{
v.push_back(i); /*尾部插入 */
v.push_front(i); /*头部插入 */
}
/****** 插入后数据: 9,8,7,6,5,4,3,2,1,0,0,1,2,3,4,5,6,7,8,9 ****/
v.insert(v.begin(),3,600);
/****** 插入后数据: 600,600,600,9,8,7,6,5,4,3,2,1,0,0,1,2,3,4,5,6,7,8,9 ****/
Print(v);
cout << "删除数据:" << endl;
v.pop_back(); /*尾部删除*/
v.pop_front(); /*头部删除*/
/****** 删除后数据: 600,600,9,8,7,6,5,4,3,2,1,0,0,1,2,3,4,5,6,7,8 ****/
Print(v);
v.erase(++v.begin(),--v.end()); /* 指定删除 */
/****** 删除后数据: 600,8 ****/
Print(v);
cout << "元素个数:" << v.size() << endl;
cout << "是否为空:" << (v.empty() == true ? "空" : "非空") << endl;
/***** 访问 ****/
for(size_t i = 0; i < v.size() ;i++)
{
//cout << v[i] << ","; /* [] 运算符重载 ***/
cout << v.at(i) << ","; /* at 下标访问 *****/
}
cout << endl;
}
/********* 关于算法库的sort排序 *****************
*void sort(首迭代子,尾迭代子) ->排序规则:默认升序,使用 >或< 运算符重载
*void sort(首迭代子,尾迭代子,二元谓词) ->排序规则:默认升序
* ******************************************/
void test2()
{
deque<int> v;
cout << "**** 插入数据****" << endl;
for(int i = 0; i < 10;i++)
{
v.push_front(i);
}
cout << "***** 使用排序sort(首迭代子,尾迭代子) ********" << endl;
sort(v.begin(),v.end());
bool cmp_int(int value1,int value2); /*函数内部声明*/
sort(v.begin(),v.end(),cmp_int);
/**** 定义仿函数策略 ***/
class CMP_INT
{
public:
bool operator()(int value1,int value2) /*二元谓词策略*/
{
return value1 > value2;
}
};
//CMP_INT temp;sort(v.begin(),v.end(),temp);
sort(v.begin(),v.end(),CMP_INT()); /* 匿名对象: 用完就销毁 */
cout << "**** 打印数据 ****" << endl;
Print(v);
}
/**** 回调函数机制 ****/
bool cmp_int(int value1,int value2)
{
return value1 < value2;
}
/********* 自定义类型插入容器,调用 sort排序算法 *******/
class People
{
public:
People(string name = "",int age = 0) : m_name(name),m_age(age){} /*构造函数 */
/***** 常对象只能调用常量成员函数 ****/
bool operator <(/*this*/const People &value) const /* 让常对象可以访问调用 */
{
return this->m_age < value.m_age;
}
int age() const;
protected:
/**** 注意实现类的时候:最好给外部访问提供接口 ****/
string m_name; /*姓名*/
int m_age; /*年龄*/
private:
friend ostream &operator <<(ostream &out,People value)
{
out << "姓名:" << value.m_name << "\t年龄:" << value.m_age << endl;
return out;
}
};
void test3()
{
/*** 建立一个自定义类型People 的deque容器对象 ****/
deque<People> v;
/*** 插入数据 ****/
string names[] = {"张三","李四","王五"};
int ages[] = {18,20,17};
for(int i = 0; i < 3;i++)
{
People people(names[i],ages[i]);
v.push_back(people);
}
/*** 排序 ***/
sort(v.begin(),v.end()); /*默认升序,使用 < 比较运算符重载*/
class CMP_People
{
public:
bool operator()(People value1,People value2)
{
/***** 最好方式使用接口方式 ******/
return value1.age() < value2.age();
}
};
sort(v.begin(),v.end(),CMP_People()); /*使用自定义策略：二元谓词*/
/*** 打印 ***/
Print(v);
}
int main()
{
test3();
return 0;
}
int People::age() const
{
return m_age;
}
3.list （链表）
/*************************
* 函数名:find(首迭代子,尾迭代子,参考变量)
* 功能:查找第一个匹配的元素,并返回当前迭代子
* 返回值:
* 找到:返回非 end尾迭代子
* 未找到: end尾迭代子
* 注意:需要 == 判断运算符重载
* ***********************/
/******************************************************
* 函数名: find_end 功能:找到最后一个匹配的元素
* 函数名: find_first_of 功能:找到第一个匹配的元素
* 函数名: find_if 功能:找到第一个匹配一元谓词的元素
* 函数名: find_if_not 功能:找到第一个匹配的一元谓词的元素
* ***************************************************/
代码：
people.h
#ifndef PEOPLE_H
#define PEOPLE_H
#include <iostream> /*标准库*/
using namespace std; /*标准命名空间*/
/******** 自己的 人类结构体 **********/
class People
{
public:
People(string name = "",int age = 0,string sex = "女",int height = 0); /*构造函数*/
public: /* 接口函数 */
/* 函数参数列表后跟 const ,称之为 常函数,由于常对象只能调用常函数,所以得提供方案 */
string name() const;
void setName(const string &name);
int age() const;
void setAge(int age);
string sex() const;
void setSex(const string &sex);
int height() const;
void setHeight(int height);
public: /*运算符重载 */
bool operator <(/*this*/ const People &people) const
{
return this->m_age < people.m_age;
}
bool operator ==(/*this*/ const People &people) const
{
return this->m_name == people.m_name;
}
protected:
string m_name; /*姓名*/
int m_age; /*年龄*/
string m_sex; /*性别*/
int m_height; /*身高*/
private:
/****** 高级的 ostream 的 << 左移运算符重载 *******/
friend ostream &operator <<(ostream &out,const People &people)
{
out << people.m_name << "\t" << people.m_age << "\t" << people.m_sex << "\t" << people.m_height;
return out;
}
};
#endif // PEOPLE_H
people.cpp
#include "people.h"
People::People(string name, int age, string sex, int height)
:m_name(name),m_age(age),m_sex(sex),m_height(height) /*初始化列表*/
{
}
string People::name() const
{
return m_name;
}
void People::setName(const string &name)
{
m_name = name;
}
int People::age() const
{
return m_age;
}
void People::setAge(int age)
{
m_age = age;
}
string People::sex() const
{
return m_sex;
}
void People::setSex(const string &sex)
{
m_sex = sex;
}
int People::height() const
{
return m_height;
}
void People::setHeight(int height)
{
m_height = height;
}
main.cpp
#include <iostream>
#include <vector> /*单端数组*/
#include <deque> /*双端数组*/
#include <list> /*链表：引入 STL标准容器中的 list 双向循环链表容器 */
#include <algorithm>/*通用算法库*/
using namespace std;/*引入 标准命名空间 */
#include "people.h" /*引入自己的 People 人类头文件 */
/*************************************
* list自带 sort 排序,有两个
* void sort();
* void sort(二元谓词);
* **********************************/
int main()
{
/* 1.实例化 People 人类的 list 容器 */
list<People> v;
/* 2.容器插入数据 */
string names[] = {"张三","李四","王五","赵六","蕾蕾"};
int ages[] = {18,29,31,18,30};
string sexs[] = {"男","女","男","男","女"};
int heights[] = {160,175,183,159,165};
for(int i = 0; i < 5;i++)
{
v.push_back(People(names[i],ages[i],sexs[i],heights[i])); /*匿名对象 : 用了就释放空间,节省空间*/
}
/* 3.打印数据 << 重载 */
list<People>::iterator it; /*定义迭代器*/
for(it = v.begin(); it != v.end() ; it++) /* 自己推出 *it <=> People */
{
cout << *it << endl;
}
/* 4.排序 */
v.sort(); /*list 自带排序规则: 使用 < 运算符重载*/
cout << "——————5.打印排序后的数据——————" << endl;
for(it = v.begin(); it != v.end() ; it++) /* 自己推出 *it <=> People */
{
cout << *it << endl;
}
cout << "——————6.打印反转后的数据——————" << endl;
v.reverse(); /*链表反转 */
for(it = v.begin(); it != v.end() ; it++) /* 自己推出 *it <=> People */
{
cout << *it << endl;
}
cout << "——————7.自带的仿函数策略的排序————————" << endl;
class CMP_People
{
public:
bool operator()(const People &people1,const People &people2)
{/* 可以发现,我使用的是常对象参数,所以只能调用常函数 */
if(people1.age() == people2.age()) //年龄相同
{
return people1.height() < people2.height(); //比较身高
}
return people1.age() < people2.age();
}
};
v.sort(CMP_People()); /*需要的是一个二元谓词*/
for(it = v.begin(); it != v.end() ; it++) /* 自己推出 *it <=> People */
{
cout << *it << endl;
}
cout << "———————8.查找函数find————————" << endl;
/*************************
* 函数名:find(首迭代子,尾迭代子,参考变量)
* 功能:查找第一个匹配的元素,并返回当前迭代子
* 返回值:
* 找到:返回非 end尾迭代子
* 未找到: end尾迭代子
* 注意:需要 == 判断运算符重载
* ***********************/
it = find(v.begin(),v.end(),People("张三")); /*找姓名为张三的*/
if(it != v.end())
{
cout << "_____找到了____" << endl;
cout << *it << endl;
}
else
{
cout << "_____未找到____" << endl;
}
cout << "——————9.查找函数find_if—————" << endl;
/******************************************************
* 函数名: find_end 功能:找到最后一个匹配的元素
* 函数名: find_first_of 功能:找到第一个匹配的元素
* 函数名: find_if 功能:找到第一个匹配一元谓词的元素
* 函数名: find_if_not 功能:找到第一个匹配的一元谓词的元素
* ***************************************************/
class CMP_People1
{
public:
bool operator()(const People &people)
{
/***** 性别为男的 *****/
return people.sex() == "男";
}
};
/******* 后期引入 lamdb 函数 -> 匿名函数 ******/
for(it = v.begin(); it != v.end() ; it++)
{
it = find_if(it,v.end(),CMP_People1());
if(it != v.end())
{
cout << *it << endl;
}
else
{
break;
}
}
return 0;
}
class Student
{
public:
Student(string name,int age):m_name(name),m_age(age){}
protected:
string m_name;
int m_age;
friend ostream &operator <<(ostream &out,Student stu);
friend Student &operator <<(Student &stu,int number);
};
/**** 给 osteam 类重载 << 运算符 ****/
ostream &operator <<(ostream &out,Student stu)
{
out << stu.m_name << "\t" << stu.m_age;
return out;
}
/**** 给 Student 类重载 << 运算符 *****/
Student &operator <<(Student &stu,int number)
{
stu.m_age <<= 1;
}
4.string
/***** 构造 *****************************************************************************
* string() 无参
* string(const string& __str) 拷贝构造
* string(const string& __str, size_type __pos, size_type __n = npos) 指定位置个数拷贝{区间}
* string(const _CharT* __s) C字符指针
* string(size_type __n, _CharT __c) 多个字符
* string(_InputIterator __beg, _InputIterator __end) 迭代子区间
* ************************************************************************************/
/******* 赋值 ***********
*
*
* =号赋值: 类似C字符串库的 strcpy
* string&operator=(const string& __str) C++风格
* string&operator=(const _CharT* __s) C风格
* string&operator=(_CharT __c) 单字符
*
*
*
* assign赋值: 类似C字符串库的 strncpy
* string&assign(_InputIterator __first, _InputIterator __last) 区间
* string&assign(const string& __str) C++风格
* string&assign(const basic_string& __str, size_type __pos, size_type __n) 类似 strncpy C++格式
* string&assign(const _CharT* __s, size_type __n) 类似 strncpy C格式
* string&assign(const _CharT* __s) 类似 strcpy C格式
* string&assign(size_type __n, _CharT __c) 多字符
* ********************/
/************** string转换 ************
* 类似于C库中的转换形式 atoi , atol , itoa ,ltoa, dtoa
*
*数值转string:
* string to_string(double);
* string to_string(flaot);
* string to_string(int);
* string to_string(long);
* string to_string(long long);
* string to_string(long double);
* string to_string(unsigned long);
* string to_string(unsigned long long);
*string转数值:
* double stod();
* flaot stof();
* int stoi();
* long stol();
* long double stold();
* long long stoll();
* unsigned long stoul();
* unsigned long long stoull();
*string转char*指针:
* 内部.data()
* ************************************/
代码：
mian.cpp
#include <iostream>
#include <vector> /*单端数组*/
#include <string> /*引入 string 容器： C++风格字符串 */
using namespace std;/*引入 标准命名空间 */
/************* 构造 ************/
void test0()
{
/***** 构造 *****************************************************************************
* string() 无参
* string(const string& __str) 拷贝构造
* string(const string& __str, size_type __pos, size_type __n = npos) 指定位置个数拷贝{区间}
* string(const _CharT* __s) C字符指针
* string(size_type __n, _CharT __c) 多个字符
* string(_InputIterator __beg, _InputIterator __end) 迭代子区间
* ************************************************************************************/
string str1; /*无参构造*/
string str2(str1); /*拷贝构造*/
string str3("hello world"); /*C字符指针*/
string str4(str3,1,2); /*指定位置个数拷贝{区间}*/
string str5(10,'A'); /*多个字符*/
vector<char> v(str3.begin(),str3.end());
string str6(v.begin(),v.end());
string str7(str3.begin(),str3.end());
cout << "str3 = " << str3 << endl;
cout << "str4 = " << str4 << endl;
cout << "str5 = " << str5 << endl;
cout << "str6 = " << str6 << endl;
cout << "str7 = " << str7 << endl;
}
/******* 赋值 ***********
*
*
*
* =号赋值: 类似C字符串库的 strcpy
* string&operator=(const string& __str) C++风格
* string&operator=(const _CharT* __s) C风格
* string&operator=(_CharT __c) 单字符
*
*
*
* assign赋值: 类似C字符串库的 strncpy
* string&assign(_InputIterator __first, _InputIterator __last) 区间
* string&assign(const string& __str) C++风格
* string&assign(const basic_string& __str, size_type __pos, size_type __n) 类似 strncpy C++格式
* string&assign(const _CharT* __s, size_type __n) 类似 strncpy C格式
* string&assign(const _CharT* __s) 类似 strcpy C格式
* string&assign(size_type __n, _CharT __c) 多字符
* ********************/
void test1()
{
string str("王老师");
string str1;
cout << "——————=号赋值: 类似C字符串库的 strcpy——————" << endl;
str1 = str; /* C++风格 */
cout << "str1 = " << str1 << endl;
str1 = "王无敌";/*C风格*/
cout << "str1 = " << str1 << endl;
str1 = 'N'; /* 单字符 */
cout << "str1 = " << str1 << endl;
cout << "——————assign赋值: 类似C字符串库的 strncpy——————" << endl;
str1.assign(str.begin(),str.end());
cout << "区间 = " << str1 << endl;
str1.assign(str);
cout << "C++风格 = " << str1 << endl;
str1.assign(str,0,2);
cout << "C++风格strncpy = " << str1 << endl;
str1.assign("hello wrold",5);
cout << "C风格strncpy = " << str1 << endl;
str1.assign("hello wrold");
cout << "C风格strcpy = " << str1 << endl;
str1.assign(100,'6');
cout << "多字符 = " << str1 << endl;
}
/************** string转换 ************
* 类似于C库中的转换形式 atoi , atol , itoa ,ltoa, dtoa
*
*数值转string:
* string to_string(double);
* string to_string(flaot);
* string to_string(int);
* string to_string(long);
* string to_string(long long);
* string to_string(long double);
* string to_string(unsigned long);
* string to_string(unsigned long long);
*string转数值:
* double stod();
* flaot stof();
* int stoi();
* long stol();
* long double stold();
* long long stoll();
* unsigned long stoul();
* unsigned long long stoull();
*string转char*指针:
* 内部.data()
* ************************************/
#include <string.h>
void test2()
{
cout << "———————————— string 转数值 ————————————————" << endl;
int value_int = stoi(string("-10"));
double value_double = stod(string("15.6"));
cout << "value_int = " << value_int << endl;
cout << "value_double = " << value_double << endl;
cout << "———————————— 数值转string —————————————————" << endl;
string str;
str = to_string(165);
cout << "int 转为string = " << str << endl;
str = to_string(165.56);
cout << "double 转为string = " << str << endl;
cout << "———————————— string 转char *——————————————" << endl;
char buf[128];
strcpy(buf,str.data());
cout << "buf = " << buf << endl;
}
/************* 拼接 **************
* += 运算符重载 类似 strcat
* append() 类似 strncat 和 strcat
* 理解形式就与 assign的重载参数差不多
* *******************************/
void test3()
{
string str;
str += 'A';
str += string("张三");
str += "王老师";
cout << "str = " << str <<endl;
/********** append函数 *************/
str.append(str.begin(),str.end()); /*区间*/
str.append(10,'A');
str.append("王老师");
cout << "str = " << str <<endl;
}
/******* 查找和替换和子串 **********
*查找:find 类似C库的 strchr(char) 和 strstr(char *)
* 返回值:下表
* 未找到:-1
* 找到:!= -1
*替换:replace *插入式覆盖 又是类似于 assign 的参数,增加下标
*子串: string substr(); ,操作类似strncpy + strstr
* *************************/
void test4()
{
string str("hello world HQYJ xxxx");
cout << "数据：" << str << endl;
/********* 查找 *********/
int index = 0;
index = str.find('P');
cout << "index = " << index << endl;
int index_head = str.find("world");
cout << "index_head = " << index_head << endl;
int index_end = str.find("xxxx");
cout << "index_end = " << index_end << endl;
/******** 替换 ***********/
//str.replace(0,5,"网啊时代峻峰拉三等奖菲拉斯开发的机构");
cout << "数据:" << str << endl;
/******** 子串 ************/
index_head += strlen("world");
string v = str.substr(index_head,index_end-index_head);
cout << "子串:" << v << endl;
/******** 访问 ************/
string::iterator it;
for(it = v.begin(); it != v.end() ;it++)
{
cout << *it;
}
cout << endl;
for(unsigned int i = 0; i < v.size() ; i++)
{
cout << v.at(i);
}
cout << endl;
}
int main()
{
test4();
return 0;
}
扫一扫
1804
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
