C++常用操作总结

/*
1、数组
2、向量
3、字符串
4、栈
5、队列
6、双端队列
7、链表
8、字典
9、集合
10、文件读写
11、异常处理
*/
#include<iostream>
#include<fstream>
#include<string>
#include<vector>
#include<stack>
#include<queue>
#include<list>
#include<map>
#include<set>

using namespace std;

int arr[5];    //全局数组，默认值为0；局部数组默认值不为0（参见array_Operator）

template<class T>
int length(T& arr)
{
return sizeof(arr)/sizeof(arr[0]);
}

void array_Operator()
{
////////////////////////////// 数组的定义和初始化 ///////////////////////////////

//int cnt = 42;
//int arr[cnt];         错误：cnt不是常量表达式
const int cnt = 5;
int arr[cnt];           //默认值不为0
int *arr_1[cnt];        //含有42个整型指针的数组
int arr_2[cnt] = {};    //初始化为0

/////////////////////////////// 不允许拷贝和赋值 ////////////////////////////////

int a[] = {1, 2, 3, 4, 5};
//int a1[] = a;        错误：不允许使用数组初始化数组
int *a2 = new int[cnt];
a2 = a;
//int a3[cnt];
//a3 = a;        错误：a2是一个指针变量，可以赋值；a3是一个固定的内存地址，不可变，不可赋值

/////////////////////////////// 字符数组的特殊性 ////////////////////////////////

char c1[] = {'C', '+', '+'};          //列表初始化，没有空字符，数组大小为3
char c2[] = {'C', '+', '+', '\0'};    //列表初始化，含有显式的空字符，数组大小为4
char c3[] = "C++";                    //自动添加表示字符串结束的空字符，数组大小为4
//char c4[3] = "C++";                 错误：没有空间可存放空字符

///////////////////////////////// 指针和数组 ////////////////////////////////////

string nums[] = {"One", "Two", "Three"};
string *p = &nums[0];          //p指向nums的第一个数组
string *p2 = nums;             //等价于 p2 = &nums[0]
string *p3 = ++p2;             //p3指向nums[1]

///////////////////////////////// 获取数组长度 //////////////////////////////////

//方法一
int length1 = end(nums) - begin(nums);    //C++11。 begin：指向首元素的指针；end：指向尾元素下一个位置的指针

//方法二:使用模板定义一个length函数（参见代码开头）
int length2 = length(nums);

////////////////////////////////// 多维数组 /////////////////////////////////////

int ia[3][4] = {{1,2,3,4}, {5,6,7,8}, {9,10,11,12}};
int ia1[3][4] = {{1}, {2}, {3}};    //初始化每一行的首元素
int ia2[3][4] = {1, 2, 3, 4};       //初始化第一行
/*
for(auto &row : ia)     //使用引用，为了避免数组被自动转成指针
{
for(auto col : row)
{
cout << col << " ";
}
cout << endl;
}
*/

/////////////////////////////////// 动态数组 ////////////////////////////////////

//静态数组在声明时分配内存，方括号中的大小必须是常量表达式
//动态数组在编译时分配内存，方括号中的大小必须是整型，但不必是常量
int n = 5;
int *pia = new int
;               //n个未初始化的int
int *pia1 = new int
();            //n个值初始化为0的int
int *pia2 = new int[0];              //合法
string *psa = new string
;         //n个空string
string *psa1 = new string
();      //n个空string

delete [] pia;
delete [] pia1;
delete [] pia2;
delete [] psa;
delete [] psa1;

//二维数组
int m = 4;
int ** b = new int*[m];
for(int i=0; i<m; i++)
{
b[i] = new int
();
}

for(int i=0; i<m; i++)
{
delete [] b[i];
}
}

void vector_Operator()
{
///////////////////////////// 定义和初始化vector对象 ////////////////////////////

vector<int> ivec;                   //初始状态为空
vector<int> ivec2(ivec);            //把ivec的元素拷贝给 ivec2
vector<int> ivec3 = ivec;           //把ivec的元素拷贝给 ivec3
//vector<string> svec = ivec;       错误：vector的类型必须相同

//vector<string> s{"One", "Two", "Three"};        //列表初始化  C++11，VS2012不支持
vector<string> s(10, "hi");                       //10个string类型对象，每个都赋值为"hi"
vector<int> v1(10);                               //10个元素，每个都初始化为0
vector<string> s1(s.begin(), s.begin()+3);        //将a向量中从第0个到第2个(共3个)作为向量b的初始值

int arr[] = {1,2,3,4,5};
vector<int> v2(arr, arr+5);             //将数组arr的前5个元素作为向量v2的初值
vector<int> v3(&arr[0], &arr[5]);       //将arr[0] - arr[5]范围内的元素(不包括arr[5])作为向量a的初值

//////////////////////////////// vector基本操作 /////////////////////////////////

vector<int> iv1;
iv1.push_back(1);     //尾端添加一个值为1的元素
iv1.empty();
iv1.size();
iv1[0];               //返回iv1中第0位置上元素的引用
iv1 = v2;             //拷贝
iv1 == v2;
iv1 != v2;
iv1 > v2;             //以字典顺序进行比较

iv1.insert(iv1.begin(), 1000);                     //将1000插入到向量iv1的起始位置前
iv1.insert(iv1.begin() + 3, 3, 1000) ;             //在iv1的位置3前出入三个1000
iv1.insert(iv1.end(), 1000);                       //尾端插入1000
iv1.insert(iv1.begin(), v2.begin(), v2.begin() + 3);        //将以v2.begin()开始的3个元素插入到b.begin()前

iv1.erase(iv1.begin() + 3);                     //删除第3个位置的元素
iv1.erase(iv1.begin(), iv1.begin() + 3);        //删除位置0到位置3（不包括位置3）的元素
iv1.pop_back();                                 //删除容器的末元素，并不返回该元素

iv1.swap(v2);        //iv1与v2进行交换

iv1.clear();        //清空向量中的元素

}

void string_Operator()
{
//////////////////////////////// 定义和初始化 ///////////////////////////////////
string s1;                  //默认初始化，s1是一个空字符串
string s2 = "hello";        //s2是该字符串字面值的副本，等价于 s2("hello")
string s3 = s2;             //s3是s2的副本，等价于 s3(s2)
string s4(10, 'a');         //把s4初始化为由连续10个字符a组成的串

////////////////////////////////// 基本操作 /////////////////////////////////////

string str1 = "hello ";
string str2 = "world";
str1.empty();            //判断是否为空字符串
str1.size();             //返回str1中字符的个数，同 str1.length()
str1[3];                 //返回str1中第n个字符的引用
str1 + str2;             //返回str1和str2连接后的结果
str1 == str2;            //对大小写敏感
str1 != str2;            //对大小写敏感
str1 < str2;             //利用字符在字典中的顺序进行比较，对大小写敏感

//s.substr(pos, n) 返回一个子字符串，包含s中从pos开头的n个字符的拷贝
//pos默认值为0，n的默认值为s.size() - pos
str1.substr(1, 3);        //得到一个从位置1到位置4的子字符串
str1.substr();            //得到一个从位置0到结尾的子字符串
str1.substr(0, 100);      //得到一个从位置1到结尾的子字符串

str1.insert(6, "world");                 //在位置6前面插入 “world”
str1.insert(str1.size(), 3, '!');        //在末尾插入3个 '!' (注意是字符不是字符串)
str1.insert(0, str2, 1, 2);              //在str1[0]之前插入str2中从位置1开始的2的字符

str1.erase(0, 2);         //删除从位置0开始的2个字符

str1.append("hai");       //等价于 str1.insert(str1.size(), "hai")

str1.replace(str1.size() - 3, 3, "good bye");        //将倒数第3个以后的3个字符替换成 "good bye"

str1.find("world");            //返回 "world"在str1中第一次出现的位置
str1.rfind("world");           //返回 "world"在str1中最后一次出现的位置

str1.compare(str2);            //与str2比较大小，等于返回0，大于返回正数，小于返回负数
str1.compare(0, 3, str2, 0, 5);        //比较str1中0位置开头的3个字符与str2中0位置开头的5个字符

/////////////////////////////// 字符数组与字符串的转换 //////////////////////////
char chas[20] = {'h', 'e', 'l', 'l', 'o', '\0'};        //注意要加 '\0'
char chas1[] = "world";
string str3 = chas;        //str3.length() = 5
string str4 = str3 + chas1;        //可以直接连接

char chas2[20];
strcpy(chas, str4.c_str());

///////////////////////////////// 数字与字符串的转换 ////////////////////////////
double i = 100.5;
string str = to_string(i);
int a = stoi(str);
double b = stod(str);
long c = stol(str);
long long d = stoll(str);
unsigned long e = stoul(str);
unsigned long long f = stoull(str);

/*
string str3, str4;
while(cin >> str3 >> str4)
{
if(str3 == str4) break;
cout << str3 << " " << str4<< endl;
}
*/
}

void stack_Operator()
{
stack<int> s;
s.push(1);        //将1压入栈顶
s.top();          //返回栈顶的元素，但不会删除
s.pop();          //删除栈顶的元素，但不会返回
s.size();
s.empty();
}

void queue_Operator()
{
queue<int> q;
q.push(1);        //将1压入队列尾部
q.front();        //返回队首元素，但不删除
q.back();         //返回队尾元素，但不删除
q.size();         //返回队列中元素的个数
q.pop();          //删除队首元素，但不返回
q.empty() ;       //检查队列是否为空，如果为空返回true，否则返回false
}

void deque_Operator()
{
deque<int> deq;
deq.push_back(1);           //尾部插入元素
deq.push_front(2);          //首部插入元素
deq.back();                 //返回最后一个元素
deq.front();                //返回第一个元素
deq.pop_back();             //删除最后一个元素，不返回
deq.pop_front();            //删除第一个元素，不返回
deq.size();                 //返回元素的个数
deq.empty();                //判断是否为空
deq.clear();                //清空
}

void list_Operator()
{
////////////////////////////////// 定义和初始化list /////////////////////////////

list<int> lis;               //创建空list
int arr[] = {1,2,3,4,5};
list<int> lis1(&arr[0], &arr[4]+1);        //链表的初始化是使用指针的，所以使用的是数组的地址
list<int> lis2(lis1);        //使用lst1初始化lst2
list<int> lis3(lis2.begin(), lis2.end());        //同lis2
list<int> lis4(5);           //创建含有5个元素的list

/////////////////////////////////// list基本操作 ////////////////////////////////

lis.assign(lis2.begin(), lis2.end());        //赋值新的内容给容器，替换当前的内容，视条件改变容器的大小
lis.push_back(1);              //尾插
lis.pop_back();                //删除最后一个元素
lis.push_front(2);             //首部插入
lis.back();                    //返回尾部元素
lis.pop_front();               //删除首元素
lis.front();                   //返回首元素
lis.erase(lis.begin());        //删除指定节点
lis.remove(2);                 //删除指定值
lis.reverse();                 //反转链表
lis.sort();                    //排序
lis.unique();                  //去除链表中相邻的重复元素
lis.splice(lis.end(), lis1);        //在指定list的迭代器位置上拼接另一个链表中另一个迭代器或者另一个迭代器指定的区间的数据
lis.sort();
lis2.sort();
lis.merge(lis2);               //融合两个排序的list(必须已经排序，否则vs2012报错)，融合的list依然是排序的
lis.size();                    //获取list大小
lis.empty();                   //判断是否为空
lis.swap(lis2);                //交换两个list
lis.insert(lis.begin(), 5);    //在指定位置插入元素

//遍历list
list<int> ::iterator it;
//特别注意list的迭代器是双向迭代器，而不是vector那样的随机迭代器，双向迭代器没有偏移能力，只能++ --，不能+2等
for(it = lis.begin(); it != lis.end(); it++)
{
//cout << *it << ends;
}

}

void map_Operator()
{
map<int, string> m;
m.insert(pair<int, string> (1, "hello world"));        //插入一个元素
m[1] = "hello world";     //插入一个元素
map<int, string> ::iterator it;
it = m.find(1);           //查找某个元素，返回一个iterator对象,不存在则返回m.end()
m.count(2);               //判断某元素是否存在（返回指定元素出现的次数）
m.erase(1);               //删除指定元素
m.clear();                //删除所有元素
m.size();                 //返回map中元素的个数
m.empty();                //判断是否为空

//遍历map
m[1] = "who ";
m[2] = "are ";
m[3] = "you?";
map<int, string> ::iterator it_1 = m.begin();

/*
while(it_1 != m.end())
{
cout << it_1->first << ends;        //打印key
cout << it_1->second << endl;       //打印value
it_1++;
}
*/
}

void set_Operator()
{
set<int> se;
//insert(value)             插入一个元素
//insert(&pos, value)       在pos位置插入一个元素
//insert(&first, &last)     将迭代区间[&first, &last)内所有的元素，插入到set容器
se.insert(1);
se.insert(se.end(), 2);
int arr[] = {1,2,3,4,5};
se.insert(&arr[0], &arr[4]+1);

se.count(1);           //判断某元素是否存在（返回指定元素出现的次数）

set<int> ::iterator it;
it = se.find(1);       //查找元素，返回一个iterator对象,不存在返回se.end()

//erase(value)        删除一个元素
//erase(&pos)         删除pos位置上的元素
//erase(&first, &last)    移除迭代区间[&first, &last)内的元素
se.erase(1);
se.erase(se.begin());
se.erase(se.begin(), se.end());

se.size();         //返回set中元素的个数
se.empty();        //判断是否为空
se.clear();        //清空set

//遍历set
se.insert(arr, arr+4);
set<int> ::iterator it_1=se.begin();
/*
while(it_1 != se.end())
{
cout << *it_1 << endl;
it_1++;
}
*/

}

void fileIO_Operator()
{
/*
文件模式
in         以读方式打开，ofstream对象不可用
out        以写方式打开，ifstream对象不可用
app        每次写操作前均定位到文件末尾
ate        打开文件后立即定位到文件末尾
trunc      截断文件（清空文件），out也被设定时才可以用
binary     以二进制方式打开IO
*/

/////////////////////////////////// 读取文件 ////////////////////////////////////

ifstream in;                //构造一个ifstream对象
in.open("test.txt");        //或者直接 ifstream in("test.txt");
if(!in)        //如果文件打开失败
{
cerr << "Open file error!" << endl;    //cout 会将输出信息先写入缓存，而cerr会将消息直接输出到console
}
char ch;                //用于保存读取的字符
while(!in.eof())        //如果文件到达末尾，eof()返回非零值
{
//in.read(&ch, 1);        从流文件中读入一个字符
in.get(ch);         //从流文件中读入一个字符
//cout << ch;
}
in.close();

/////////////////////////////////// 写入文件 ////////////////////////////////////

ofstream out("test_Output.txt", ofstream::out | ofstream::app);
out << "hello" << ends;
out.close();

/////////////////////////////////// 读写文件 ////////////////////////////////////

fstream io("test.txt", ios::in | ios::out | ios::ate);        //读写
io << "hello world!!!" << endl;

char cha;

io.seekg(ios::beg);        //把内置指针定位到开头
//io.seekg(ios::end);        把内置指针定位到结尾
//io.seekg(-5);        从当前位置向前跳五个单位，向后跳为正数

//逐字符读取
//while(!io.eof())
//{
//  io.get(cha);
//  cout << cha;
//}

char line[100];

while(!io.eof())
{
io.getline(line, 100);        //逐行读取，100是数组大小
//cout << line << endl;
}

io.close();
}

bool isNum(string str)
{
for(int i=0; i<str.size(); i++)
{
if(!isdigit(str[i]))
{
return false;
}
}
return true;
}

void exception_handling()
{
//throw抛出异常
//try...catch...处理异常
//举例:输入一个0~100的整数，如果输入的不是数，抛出exception异常
//如果输入的数不在该范围内抛出range_error异常
string s;
cout << "please input a integer from 1 to 100~" << endl;
while(cin >> s)
{
try
{
if(!isNum(s))
{
throw exception("Not a number!");
}
if(stoi(s) < 0 || stoi(s) > 100)       //字符串转数字
{
throw range_error("The number that you input out of range!");
}
cout << "Input succeed!" << endl;
break;
}
catch(range_error err)
{
cout << err.what() << endl;        //返回异常初始化的字符串
cout << "Try Again? Enter y or n." << endl;
char c;
cin >> c;
if(c == 'n')
{
break;
}
else if(c == 'y')
{
continue;
}
}
catch(exception ex)
{
cout << ex.what() << endl;
cout << "Try Again? Enter y or n." << endl;
char c;
cin >> c;
if(c == 'n')
{
break;
}
else if(c == 'y')
{
continue;
}
}
}

}

int main()
{
array_Operator();
vector_Operator();
string_Operator();
stack_Operator();
queue_Operator();
deque_Operator();
list_Operator();
map_Operator();
set_Operator();
fileIO_Operator();
exception_handling();
system("pause");
return 0;
}