文章目录

  • 一、文件IO操作之打开与关闭
  • 1.1 文件的I/O操作
  • 1.2 文件的读写
  • 二、C++的容器
  • 2.1 动态数组vector
  • 2.2 链表list
  • 2.3 映射map
  • 2.4 字符串类string


声明：此学习笔记参考VC驿站中的“【实用C++】零基础入门教程”，网址：https://www.cctry.com/forum-140-1.html ，感谢VC驿站提供的帮助。

一、文件IO操作之打开与关闭

1.1 文件的I/O操作

文件操作就是指对文件进行读写操作。输入就是从磁盘上的文件读取到内存中；输出就是讲内存的数据内存写入到磁盘中。
文件的类型分为文本文件（ASCII文件）和二进制文件。文本文件每个字节存放一个ASCII码。二进制文件则是把内存中的数据按照其内存中的存储形式原样写在磁盘上存放。
文件打开与关闭操作：

ofstream fs;
fs.open("文件所在路径")；
fs.close();

判断文件是否成功打开的方法：

  1. 直接用if判断fs对象，成功打开fs为ture,打开失败为false。
  2. 用is_open()判断，成功打开返回ture,否则返回false。

1.2 文件的读写

写操作有： << 、put 、 write等。
'<<'例：

int var = 1000;
fs << var << endl;
fs << "你好" << endl;

'put’例：

fs.put{'a')；

put只能写入单个字符，还有一定的局限性。

write支持文本类型和二进制类型，使用时需要提供内存的地址和要写如的字节数。
例：

char a[10] = "abcde";
fs.write(a,sizeof(a));

读操作有：>> 、 get 、 getline
'>>'例：

int a = 0;
fs >> a;

文本中的值就会赋予a。

'get’例：

int a = fs.get();

getline 为读取文本中一行是数据，也就是读到换行符’\n’。

二、C++的容器

2.1 动态数组vector

vector为向量类型，成员可以为许多数据类型，因此也称为容器，使用vector时不用指定数组大小，有数据直接往里放就行，vector会自己管理内部空间，因此也称动态数组。
使用vector前需要添加头文件#include <vector> 并且添加命名空间stdusing namespace std;vector的定义：

vector<int> arr_int;           //内部元素为int型
vector<char> arr_char;
vector<Cstudent> arr_stu;     //内部元素为Cstudent类型
vector<char*> arr_pchar;      //内部元素为char*型

vector初始化的几种方式：


1. 
vector<int> arr_int1; 　　　　 定义了一个空的int型动态数组。
2. 
vector<int> arr_int2(10) 　　　定义了一个具有十个int型元素的动态数组，没有初始化，其值不确定。
3. 
vector<int> arr_int3(10,100) 　　定义了一个具有十个int型元素的动态数组，值都为100。
4. 
vector<int> arr_int4(arr_int3) 　定义了一个int型动态数组，并用arr_int3初始化。
5. 
vector<int> arr_int5(arr_int3.begin(),arr_int3.end()) 　　使用arr_int3开始的元素到结束的元素初始化。
 6.int a[] = {1,2,3,4}; vector<int> arr_int6(a,a+3);　　 使用数组初始化。

vector的常用函数操作：


1. 
arr_int[idx] 　　　　返回下表为idx元素的值。
2. 
arr_int.size()　　　 返回arr_int数组的大小
3. 
arr_int.front()　　　返回第一个元素的值
4. 
arr_int.back()　　　 返回最后一个元素的值
5. 
arr_int.clear()　　　删除数组所有元素
6. 
arr_int.empty()　　　判断数组是否为空，如果为空则返回true，非空（有元素）则返回false
7. 
arr_int.swap(v1)　 　讲arr_int与v1两个动态数组元素交换

vector的动态插入操作：


1. 
arr_int.push_back(1）　　　　　　　　　　在数组为尾部插入一个值为1的元素。
2. 
arr_int.insert(arr_int.begin()+1, 2)　 　在下标为1的位置前插入一个值为2的元素。
3. 
arr_int.insert(arr_int.begin()+2, 3, 2)　在下标为1的位置前插入3个值为2的元素。

vector的动态删除操作：


1. 
arr_int.pop_back()　　　　　　　　　　　　　　　　　 删除数组最后一个元素。
2. 
arr_int.erase(arr_int.begin()+k）　　　　　　　　　　 删除下标为1的元素。
3. 
arr_int.erase(arr_int.begin()+k, arr_int.end()-r)　　删除下标为[k,end()-r)的元素。

vector 的遍历：

int a[] = {1,2,3,4};
vector<int> arr_int1;
vector<int> arr_int2(a,a + 4);
vector<int>::iterator itor;
for(itor = arr_int2.begin(); itor != arr_int2.end() ; ++itor){
    arr_int1.push_back(*itor);
    }

从文件中读取元素并添加进数组：

ifstream in("文件路径");
vector<int> arr_int;
for(int i = 0 ; in>>i){
    arr_int.push_back(i);
    }

2.2 链表list

与vector的区别：
动态数组vector具有动态数组的基本特性，它的内存是连续了，使得我们可以通过下标索引快速定位某个元素，但是当我们要在vector里面插入一些元素时，因为它内存连续，就会将后面的元素整体往后移，造成效率低下。
链表list的内存是不连续的，其元素是一个一个的节点在内存中离散分布，各节点之间是通过元素内部指针指过去的。所有对于list来说，要快速定位某一个元素是做不到的，只能从头去遍历，一个一个地找，直到找到。而优点就是当往其插入元素时，只需要断开前后两个节点的指针，再跟新插入节点连接上就可以了。

list的定义
使用list前需要添加头文件#include <list> 并且添加命名空间stdusing namespace std;

list<int> arr_int;           //内部元素为int型
list<char> arr_char;
list<Cstudent> arr_stu;     //内部元素为Cstudent类型
list<char*> arr_pchar;      //内部元素为char*型

list初始化的几种方式：


1. 
list<int> arr_int1; 　　　　 定义了一个空的int型动态数组。
2. 
list<int> arr_int2(10) 　　　定义了一个具有十个int型元素的动态数组，没有初始化，其值不确定。
3. 
list<int> arr_int3(10,100) 　　定义了一个具有十个int型元素的动态数组，值都为100。
4. 
list<int> arr_int4(arr_int3) 　定义了一个int型动态数组，并用arr_int3初始化。
5. 
list<int> arr_int5(arr_int3.begin(),arr_int3.end()) 　　使用arr_int3开始的元素到结束的元素初始化。
 6.int a[] = {1,2,3,4}; list<int> arr_int6(a,a+3);　　 使用数组初始化。

list的常用函数操作：


1. 
arr_int.size()　　　 返回arr_int链表的大小
2. 
arr_int.front()　　　返回第一个元素的值
3. 
arr_int.back()　　　 返回最后一个元素的值
4. 
arr_int.clear()　　　删除数组所有元素
5. 
arr_int.empty()　　　判断数组是否为空，如果为空则返回true，非空（有元素）则返回false
6. 
arr_int.swap(v1)　 　讲arr_int与v1两个动态数组元素交换
7. 
list_int.reverse()  　 把list中的元素顺序倒转
8. 
list_int.sort() 　　　给list排序正序
9. 
list_int.splice(list_int.begin(), list_2) 两个链表合并

list插入操作：


1. 
arr_int.push_back(1）　　　　　　　　　　在链表尾部插入一个值为2的元素。
2. 
arr_int.push_front(2)　　　　　　　　　　在链表头部插入一个值为2的元素。
3. 
arr_int.insert(arr_int.begin()+1, 2)　 　在下标为1的位置前插入一个值为2的元素。
4. 
arr_int.insert(arr_int.begin()+2, 3, 2)　在下标为1的位置前插入3个值为2的元素。

list删除操作：


1. 
arr_int.pop_back()　　　　　　　　　　　　　　　　　 删除链表最后一个元素。
2. 
arr_int.erase(arr_int.begin()+k）　　　　　　　　　　删除下标为k的元素。
3. 
arr_int.erase(iort)　　　　　　　　　　　　　　　　　删除之到itor的元素。
4. 
arr_int.erase(iort, arr_int.end())　　　　　　　　 　删除指到itor到结尾的元素。

list 的遍历：
list不是数组，因此无法使用下标遍历，只能通过迭代器遍历。

int a[] = {1,2,3,4};
list<int> arr_int1;
list<int> arr_int2(a,a + 4);
list<int>::iterator itor;
for(itor = arr_int2.begin(); itor != arr_int2.end() ; ++itor){
    arr_int1.push_back(*itor);
    }

2.3 映射map

map提供的是一种键值对的容器，里面的元素是成对出现的，即key-value，在之到key的情况下能够快速的找到value。它们是一一对应的关系。

map的定义：
使用前先包含头文件与命名空间：

#include <map>
using namespace std;
map<int,chat> stud_map;

map的使用：

stud_map[10010] = 'm';                 //赋值
int m_size = stud_map.size();          //返回容器的元素个数
bool is_emty = stud_map.emty();        //判断容器是否为空
int is_count = stud_map.count(10013)   //判断容器是否存在某个元素

map的删除：

stud_map.erase(10010);
stud_map.erase(stud_map.begin())

map的遍历：
map不是数组，因此遍历要使用迭代器。

map<int,char> :: iterator itor;
for(itor = stud_map.begin();itor != stud_map.end();++itor){
    int key = itor->first;
    char value = itor->second;

2.4 字符串类string

string 的定义：
使用前包含头文件 string

string str(const char *s);        //用字符串s初始化str
string str1(int n,char c);        //用n各字符c初始化str1
string str2 = "abcd";

string 从常用操作：

string str = "abcde";
char ch1 = str.at[0];                //返回下标为0的字符
char ch2 = str[0];                   //返回下标为0的字符
char *p = str.c_str();               //用string对象得到一个char* 指针
int s_size = str.size();             //返回str长度
bool s_empty = str.empty()           //判断str是否为空

assign的几种用法：

string str;
str.assign("abcde")                 //直接将abcde赋值给str
srt.clean();  
const char *p = "abcde fghijk";
str.assign(p);                      //将abcde fghijk 赋值给str
str.clean();
str.assign(p,5);                    //将前5个字符赋值给str
str.clean();
str.assign(p,6,11);                 //将第6个字符到第11个字符赋值给str

string 连接的几种操作：

string str = "1234"

"+="操作：

str += "567"                     //str = "1234567"

“append()操作：”

str.append("aa")                //str = "1234aa"
str.append(int n,char c)        //在结尾插入n个字符c
str.append(char *p ， int n)    //在结尾插入字符串p的前n个字符

string 取字串的操作：

string str = "abcdefg";
string str_sub = str.substr(4);           //str_sub = "efg"
string str_sub = str.substr(2,2)          //str_sub = "cd" ，第二个2表示取多少个字符

string 查找操作：

string str = "abcdefg";
int is_pos = str.find("def");             //如果查找到返回"def"的第一个字符的位置，否则返回-1
int is_pos = str.find("def",2);           //表示从位置2开始查找

string 替换操作：

string str = "hello abcdef";
str.replace(0,5,zhangsan);               //str = "zhangsan abcdef" zhangsan替换第0~第5个字符

string 插入操作：

string str = "hello abcdef";
str.insert(0,"zhangan ")                 //str = "zhangsan hello abcdef"
str.insert(0,3,a);                      //str = "aaa zhangsan hello abcdef"

string 删除操作：

string str = "hello abcdef";
str.erase(2,3)                          //str = "he abcdef"    位置，删除几个