从C到C++简明进阶教程

469次阅读
没有评论

从C到C++简明进阶教程

使⽤C++刷算法的好处

  • 在已经学习过C语⾔的前提下,学习C++并使⽤它刷算法的学习成本⾮常低~只需要⼏个⼩时就可以学会~
  • C++向下兼容C,C语⾔⾥⾯的语法⼤部分都可以在C++⽂件中运⾏,所以学习C++对刷算法时编程语⾔的表达能⼒进⾏扩充有益⽆害,例如C语⾔的输⼊输出( scanf 和 printf )⽐C++快,那么就可以在使⽤C++刷算法同时使⽤ scanf 和 printf 提⾼代码运⾏效率
  • C++拥有丰富的STL标准模版库,这也是PAT甲级、LeetCode等题⽬中经常需要⽤到的,单纯使⽤C语⾔解决问题会⽐C++的STL解决该问题麻烦很多~
  • C++的 string 超级好⽤~⽐C语⾔⾥⾯的char数组好⽤多啦~⽤了就再也不想回去的那种~
  • C++可以在某⼀变量使⽤前随时定义该变量,⾮常⽅便
  • 在解决⼀些较为简单的PAT⼄级题⽬的时候(例如⼀些时间复杂度限制不严格的题⽬), cin 、 cout 输⼊输出⾮常⽅便~⽤过的都说好~ (๑• . •๑)

虽然C++是⼀⻔⾯向对象语⾔,但是对于刷算法这件事⽽⾔,我们并不需要掌握它⾯向对象的部分~只需要掌握刷算法的时候需要⽤到的部分(基本输⼊输出、STL标准模板库、 string 字符串等)就可以啦~C语⾔和C++有很多相似之处,且C++向下兼容C语⾔,所以我没有说的地⽅就直接⽤C语⾔的语法表示就好~以下是正⽂,先来段代码⽅便讲解:

#include <iostream>
using namespace std;
int main() {
  int n;
  cin >> n;
  cout << "hello, world" << n + 1 << endl;
  return 0; 
}

名称空间

这句话是使⽤“std”这个名称空间( namespace )的意思~因为有的时候不同⼚商定义的函数名称彼此之间可能会重复,为了避免冲突,就给所有的函数都封装在各⾃的名称空间⾥⾯,使⽤这个函数的时候就在main函数前⾯写明⽤了什么名称空间,⼏乎在C++中使⽤到的⼀些⽅法如 cin 、 cout 都是在 std 名称空间⾥⾯的,所以可以看到 using namespace std;这句话⼏乎成了我每段C++代码的标配,就和 return 0; ⼀样必须有~其实也可以不写这句话,但是使⽤ std ⾥⾯的⽅法的时候就会麻烦点,要在⽅法名前加上 std:: ,⽐如写成这样:

std::cin >> n;
std::cout << "hello, world" << n + 1 << endl;

 

我觉得这样⽐较丑,所以不管要不要⽤到,直接每道题的代码标配得写 using namespace std; 就好啦~

输入输出

就如同 scanf 和 printf 在 stdio.h 头⽂件中⼀样, cin 和 cout 在头⽂件 iostream ⾥⾯,看名字就知道, io 是输⼊输出 input 和 output 的⾸字⺟, stream 是流,所以这个 iostream 头⽂件⾥包含的⽅法就是管理⼀些输⼊输出流的~

cin 和 cout ⽐较⽅便,不⽤像C语⾔⾥的 scanf 、 printf 那样写得那样繁琐, cin >> n; 和scanf("%d", &n); ⼀样的意思(⽽且⽤ cin 再也不⽤担⼼像 scanf ⼀样忘记写取地址符 & 了耶),注意 cin 是向右的箭头,表示将内容输⼊到 n 中~

同样, cout << n; 和 printf("%d", n); ⼀样的意思,此时 cout 是向左的两个箭头,注意和 cin 区分开来~

⽽且不管 n 是 double 还是 int 或者是 char 类型,只⽤写 cin >> n; 和 cout << n; 这样简单的语句就好,不⽤像C语⾔中需要根据 n 的类型对应地写 %lf 、 %d 、 %c 这样麻烦~

endl 和 "\n" 的效果⼤致相同, endl 的全称是end of line,表示⼀⾏输出结束,然后输出下⼀⾏~(微⼩区别是,使⽤ endl 会⽐使⽤ "\n" 换⾏后多⼀个刷新输出缓冲区的操作,but不必care这些细节…)⼀般如果前⾯是个字符串引号的话直接 "\n" ⽐较⽅便,如果是变量之类的我觉得写 endl 会⽐较好看~想⽤哪个就⽤哪个~

cout << "hello, guy~\n";
cout << n << endl;

 

cin 和 cout 虽然使⽤起来更⽅便,但是输⼊输出的效率不如 scanf 和 printf 快,所以如果是做PAT⼄级⾥⾯那种简单、对时间复杂度要求不⾼的题⽬,直接⽤ cin 和 cout 会觉得写起来⽐较省事⼉;如果题⽬对时间复杂度要求⽐较⾼,全都改成 scanf 和 printf 可以提⾼代码的输⼊输出效率,⽐如有的时候发现⽤ cin 、 cout 做题⽬超时了,改成 scanf 和 printf 就AC了~

头文件

C++的头⽂件⼀般是没有像C语⾔的 .h 这样的扩展后缀的,⼀般情况下C语⾔⾥⾯的头⽂件去掉 .h 然后在前⾯加个 c 就可以继续在C++⽂件中使⽤C语⾔头⽂件中的函数啦~⽐如:

#include <cmath> // 相当于C语⾔⾥⾯的#include <math.h>
#include <cstdio> // 相当于C语⾔⾥⾯的#include <stdio.h>
#include <cctype> // 相当于C语⾔⾥⾯的#include <ctype.h>
#include <cstring> // 相当于C语⾔⾥⾯的#include <string.h>

 

变量声明

C语⾔的变量声明⼀般都在函数的开头,但是C++在⾸次使⽤变量之前声明即可~(当然也可以都放在函数的开头),⽽且⼀般C语⾔⾥⾯会在 for 循环的外⾯定义 i 变量,但是C++⾥⾯可以在 for 循环内部定义~(关于这点, VC++6.0 ⾥⾯可能会发现代码复制进去编译不通过,这是因为这个编译器太⽼啦,建议不要⽤这么上古的编译器啦~)⽽且在 for 循环⾥⾯定义的局部变量,在循环外⾯就失效啦(就是脱离这个局部作⽤域就会查⽆此变量的意思),所以⼀个 main 函数⾥⾯可以定义好多次局部变量 i ,再也不⽤担⼼写的循环太多变量名 i 、 j 、 k 不够⽤啦~

#include <iostream>
using namespace std;
int main() {
    int n;
    cin >> n;
    cout << "hello, liuchuo" << n + 1 << endl;
    int m;
    cin >> m;
    for (int i = 0; i < n; i++) { // 这个i只在for循环⾥⾯有⽤,出了这个for循环就相当于
    不⻅了
    		cout << i;
     }
    for (int i = 0; i < m; i++) { // ⼜可以定义⼀个i啦,和上⾯那个i不会冲突~
    		cout << i + 2;
     }
  return 0;
}

bool变量

bool 变量有两个值, false 和 true ,以前⽤C语⾔的时候都是⽤ int 的 0 和 1 表示 false 和 true的,现在C++⾥⾯引⼊了这个叫做 bool (布尔)的变量,⽽且C++把所有⾮零值解释为 true ,零值解释为 false ~所以直接赋值⼀个数字给 bool 变量也是可以的~它会⾃动根据 int 值是不是零来决定给 bool 变量赋值 true 还是 false ~

bool flag = true;
bool flag2 = -2; // flag2为true
bool flag3 = 0; // flag3为false

 

定义常量

和C语⾔相同,C++⾥⾯可以使⽤ const 这个限定符定义常量,⽐如 int 类型的常量 a 这样定义:

const int a = 99999999; // a为int类型的常量,它的值不可更改

 

string类

以前⽤ char[] 的⽅式处理字符串很繁琐,现在有了 string 类,定义、拼接、输出、处理都更加简单啦~不过 string 只能⽤ cin 和 cout 处理,⽆法⽤ scanf 和 printf 处理:

string s = "hello world"; // 赋值字符串
string s2 = s;
string s3 = s + s2; // 字符串拼接直接⽤+号就可以
string s4;
cin >> s4; // 读⼊字符串
cout << s; // 输出字符串

 

⽤ cin 读⼊字符串的时候,是以空格为分隔符的,如果想要读⼊⼀整⾏的字符串,就需要⽤ getline

s 的⻓度可以⽤ s.length() 获取~(有⼏个字符就是⻓度多少,不存在 char[] ⾥⾯的什么末尾的结束符之类的~)

string s; // 定义⼀个空字符串s
getline(cin, s); // 读取⼀⾏的字符串,包括空格
cout << s.length(); // 输出字符串s的⻓度

 

string 中还有个很常⽤的函数叫做 substr ,作⽤是截取某个字符串中的⼦串,⽤法有两种形式:

string s2 = s.substr(4); // 表示从下标4开始⼀直到结束
string s3 = s.substr(5, 3); // 表示从下标5开始,3个字符

 

结构体

定义好结构体 stu 之后,使⽤这个结构体类型的时候,C语⾔需要写关键字 struct ,⽽C++⾥⾯可以省略不写:

struct stu {
  int grade;
  float score;
};
struct stu arr1[10]; // C语⾔⾥⾯需要写成struct stu
stu arr2[10];// C++⾥⾯不⽤写struct,直接写stu就好了~

 

引用&传值

这个引⽤符号 & 要和C语⾔⾥⾯的取地址运算符 & 区分开来,他们没有什么关系,C++⾥⾯的引⽤是指在变量名之前加⼀个 & 符号,⽐如在函数传⼊的参数中 int &a ,那么对这个引⽤变量 a 做的所有操作都是直接对传⼊的原变量进⾏的操作,并没有像原来 int a ⼀样只是拷⻉⼀个副本(传值),举两个例⼦:

void func(int &a) { // 传⼊的是n的引⽤,相当于直接对n进⾏了操作,只不过在func函数中换了个名字叫a
  a = 99; }
int main() {
  int n = 0;
  func(n); // n由0变成了99
}

 

void func(int a) {// 传⼊的是0这个值,并不会改变main函数中n的值
  a = 99; }
int main() {
  int n = 0;
  func(n);// 并不会改变n的值,n还是0 
}

 

STL

vector

之前C语⾔⾥⾯⽤ int arr[] 定义数组,它的缺点是数组的⻓度不能随⼼所欲的改变,⽽C++⾥⾯有⼀个能完全替代数组的动态数组 vector (有的书⾥⾯把它翻译成⽮量, vector 本身就是⽮量、向量的意思,但是叫做动态数组或者不定⻓数组我觉得更好理解,绝⼤多数中⽂⽂档中⼀般不翻译直接叫它vector~),它能够在运⾏阶段设置数组的⻓度、在末尾增加新的数据、在中间插⼊新的值、⻓度任意被改变,很好⽤~它在头⽂件 vector ⾥⾯,也在命名空间 std ⾥⾯,所以使⽤的时候要引⼊头⽂件 #include <vector> 和 using namespace std;

vector 、 stack 、 queue 、 map 、 set 这些在C++中都叫做容器,这些容器的⼤⼩都可以⽤ .size()获取到,就像 string s 的⻓度⽤ s.length() 获取⼀样~( string 其实也可以⽤ s.size() ,不过对于vector 、 stack 、 queue 、 map 、 set 这样的容器我们⼀般讨论它的⼤⼩ size ,字符串⼀般讨论它的⻓度 length ~其实 string ⾥⾯的 size 和 length 两者是没有区别、可以互换使⽤的。

#include <iostream>
#include <vector>
using namespace std;
int main() {
  vector<int> v1; // 定义⼀个vector v1,定义的时候没有分配⼤⼩
  cout << v1.size(); // 输出vector v1的⼤⼩,此处应该为0
  return 0; 
}

 

vector 可以⼀开始不定义⼤⼩,之后⽤ resize ⽅法分配⼤⼩,也可以⼀开始就定义⼤⼩,之后还可以对它插⼊删除动态改变它的⼤⼩~⽽且不管在 main 函数⾥还是在全局中定义,它都能够直接将所有的值初始化为0(不⽤显式地写出来,默认就是所有的元素为0),再也不⽤担⼼C语⾔⾥⾯出现的那种 int arr[10]; 结果忘记初始化为0导致的各种bug啦~

vector<int> v(10); // 直接定义⻓度为10的int数组,默认这10个元素值都为0
// 或者
vector<int> v1;
v1.resize(8); //先定义⼀个vector变量v1,然后将⻓度resize为8,默认这8个元素都是0
// 在定义的时候就可以对vector变量进⾏初始化
vector<int> v3(100, 9);// 把100⻓度的数组中所有的值都初始化为9
// 访问的时候像数组⼀样直接⽤[]下标访问即可~(也可以⽤迭代器访问,下⾯会讲~) 
v[1] = 2;
cout << v[0];

 

不管是 vector 、 stack 、 queue 、 map 还是 set 都有很多好⽤的⽅法,这些⽅法都可以在官⽅⽹站中直接查询官⽅⽂档,上⾯有⽅法的讲解和代码示例~官⽅⽂档是刷题时候必不可少的好伙伴~如果你⽤的是 Mac OS 系统,下载软件 Dash 然后在⾥⾯下载好C++,平时查⽂档会更⽅便,我平时做开发写算法都在 Dash ⾥⾯查⽂档,内容和官⽅⽂档是⼀样的~)PS:经此教程读者Keil Glay提醒, Windows 下有受 Dash 启发⽽开发的离线⽂档浏览器 Zeal ,和 Dash 的功能⼀样,使⽤ Windows 的⼩伙伴可以下载 Zeal 看离线官⽅⽂档~

⽐如进⼊官⽹搜索 vector ,就会出现 vector 拥有的所有⽅法,点进去⼀个⽅法就能看到这个⽅法的详细解释和代码示例~当然我们平时写算法⽤不到那么多⽅法啦,只有⼏个是常⽤的~以下是⼀些常⽤的 vector ⽅法:

#include <iostream>
#include <vector>
using namespace std;
int main() {
  vector<int> a; // 定义的时候不指定vector的⼤⼩
  cout << a.size() << endl; // 这个时候size是0
  for (int i = 0; i < 10; i++) {
  		a.push_back(i); // 在vector a的末尾添加⼀个元素i
   }
  cout << a.size() << endl; // 此时会发现a的size变成了10
  vector<int> b(15); // 定义的时候指定vector的⼤⼩,默认b⾥⾯元素都是0
  cout << b.size() << endl;
  for (int i = 0; i < b.size(); i++) {
  		b[i] = 15;
   }
  for (int i = 0; i < b.size(); i++) {
  		cout << b[i] << " ";
   }
  cout << endl;
  vector<int> c(20, 2); // 定义的时候指定vector的⼤⼩并把所有的元素赋⼀个指定的值
  for (int i = 0; i < c.size(); i++) {
  		cout << c[i] << " ";
   }
  cout << endl;
  for (auto it = c.begin(); it != c.end(); it++) { // 使⽤迭代器的⽅式访问vector
  		cout << *it << " ";
   } 
  return 0; 
}

 

容器 vector 、 set 、 map 这些遍历的时候都是使⽤迭代器访问的, c.begin() 是⼀个指针,指向容器的第⼀个元素, c.end() 指向容器的最后⼀个元素的后⼀个位置,所以迭代器指针 it 的for循环判断条件是 it != c.end()

访问元素的值要对 it 指针取值,要在前⾯加星号~所以是 cout << *it;这⾥的auto相当于 vector<int>::iterator 的简写,关于 auto 下⽂有讲解~

set

set 是集合,⼀个 set ⾥⾯的各元素是各不相同的,⽽且 set 会按照元素进⾏从⼩到⼤排序~以下是 set 的常⽤⽤法:

#include <iostream>
#include <set>
using namespace std;
int main() {
  set<int> s; // 定义⼀个空集合s s.insert(1); // 向集合s⾥⾯插⼊⼀个1
  cout << *(s.begin()) << endl; // 输出集合s的第⼀个元素 (前⾯的星号表示要对指针取值)
  for (int i = 0; i < 6; i++) {
  		s.insert(i); // 向集合s⾥⾯插⼊i
   }
  for (auto it = s.begin(); it != s.end(); it++) { // ⽤迭代器遍历集合s⾥⾯的每⼀个元素
  		cout << *it << " ";
   }
  cout << endl << (s.find(2) != s.end()) << endl; // 查找集合s中的值,如果结果等于s.end()表示未找到 (因为s.end()表示s的最后⼀个元素的下⼀个元素所在的位置)
  cout << (s.find(10) != s.end()) << endl; // s.find(10) != s.end()表示能找到10这个元素
  s.erase(1); // 删除集合s中的1这个元素
  cout << (s.find(1) != s.end()) << endl; // 这时候元素1就应该找不到啦~
  return 0; 
}

 

map

map 是键值对,⽐如⼀个⼈名对应⼀个学号,就可以定义⼀个字符串 string 类型的⼈名为“键”,学号 int 类型为“值”,如 map<string, int> m; 当然键、值也可以是其它变量类型~ map 会⾃动将所有的键值对按照键从⼩到⼤排序, map 使⽤时的头⽂件 #include <map> 以下是 map 中常⽤的⽅法:

#include <iostream>
#include <map>
#include <string>
using namespace std;
int main() {
  map<string, int> m; // 定义⼀个空的map m,键是string类型的,值是int类型的
  m["hello"] = 2; // 将key为"hello", value为2的键值对(key-value)存⼊map中
  cout << m["hello"] << endl; // 访问map中key为"hello"的value, 如果key不存在,则返
  回0
  cout << m["world"] << endl; m["world"] = 3; // 将"world"键对应的值修改为3 m[","] = 1; // 设⽴⼀组键值对,键为"," 值为1
  // ⽤迭代器遍历,输出map中所有的元素,键⽤it->first获取,值⽤it->second获取
  for (auto it = m.begin(); it != m.end(); it++) {
  		cout << it->first << " " << it->second << endl;
   }
  // 访问map的第⼀个元素,输出它的键和值
  cout << m.begin()->first << " " << m.begin()->second << endl;
  // 访问map的最后⼀个元素,输出它的键和值
  cout << m.rbegin()->first << " " << m.rbegin()->second << endl;
  // 输出map的元素个数
  cout << m.size() << endl;
  return 0; 
}

stack

栈 stack 在头⽂件 #include <stack> 中,是数据结构⾥⾯的栈~以下是常⽤⽤法:

#include <iostream>
#include <stack>
using namespace std;
int main() {
  stack<int> s; // 定义⼀个空栈s
  for (int i = 0; i < 6; i++) {
  		s.push(i); // 将元素i压⼊栈s中
   }
  cout << s.top() << endl; // 访问s的栈顶元素
  cout << s.size() << endl; // 输出s的元素个数
  s.pop(); // 移除栈顶元素
  return 0; 
}

 

queue

队列 queue在头⽂件 #include <queue> 中,是数据结构⾥⾯的队列~以下是常⽤⽤法:

#include <iostream>
#include <queue>
using namespace std;
int main() {
  queue<int> q; // 定义⼀个空队列q
  for (int i = 0; i < 6; i++) {
  		q.push(i); // 将i的值依次压⼊队列q中
   }
  cout << q.front() << " " << q.back() << endl; // 访问队列的队⾸元素和队尾元素
  cout << q.size() << endl; // 输出队列的元素个数
  q.pop(); // 移除队列的队⾸元素
  return 0; 
}

 

unordered_map & unordered_set

unordered_map 在头⽂件 #include <unordered_map> 中, unordered_set 在头⽂件 #include<unordered_set> 中~

unordered_map 和 map (或者 unordered_set 和 set )的区别是, map 会按照键值对的键 key 进⾏排序( set ⾥⾯会按照集合中的元素⼤⼩进⾏排序,从⼩到⼤顺序),⽽ unordered_map (或者 unordered_set )省去了这个排序的过程,如果偶尔刷题时候⽤ map 或者 set 超时了,可以考虑⽤ unordered_map (或者 unordered_set )缩短代码运⾏时间、提⾼代码效率~⾄于⽤法和 map 、 set 是⼀样的~

位运算

bitset ⽤来处理⼆进制位⾮常⽅便。头⽂件是 #include <bitset> , bitset 可能在PAT、蓝桥OJ中不常⽤,但是在LeetCode OJ中经常⽤到~⽽且知道 bitset 能够简化⼀些操作,可能⼀些复杂的问题能够直接⽤ bitset 就很轻易地解决~以下是⼀些常⽤⽤法:

#include <iostream>
#include <bitset>
using namespace std;
int main() {
  bitset<5> b("11"); //5表示5个⼆进位
  // 初始化⽅式:
  // bitset<5> b; 都为0
  // bitset<5> b(u); u为unsigned int,如果u = 1,则输出b的结果为00001
  // bitset<8> b(s); s为字符串,如"1101",则输出b的结果为00001101,在前⾯补0
  // bitset<5> b(s, pos, n); 从字符串的s[pos]开始,n位⻓度
  // 注意,bitset相当于⼀个数组,但是它是从⼆进制的低位到⾼位分别为b[0]、b[1]……的
  // 所以按照b[i]⽅式逐位输出和直接输出b结果是相反的
  cout << b << endl; // 如果bitset<5> b("11"); 则此处输出00011(即正常⼆进制顺序)
  for(int i = 0; i < 5; i++)
  cout << b[i]; // 如果bitset<5> b("11"); 则此处输出11000(即正常⼆进制顺序的倒
  序)
  cout << endl << b.any(); //b中是否存在1的⼆进制位
  cout << endl << b.none(); //b中不存在1吗?
  cout << endl << b.count(); //b中1的⼆进制位的个数
  cout << endl << b.size(); //b中⼆进制位的个数
  cout << endl << b.test(2); //测试下标为2处是否⼆进制位为1 b.set(4); //把b的下标为4处置1 b.reset(); //所有位归零
  b.reset(3); //b的下标3处归零
  b.flip(); //b的所有⼆进制位逐位取反
  unsigned long a = b.to_ulong(); //b转换为unsigned long类型
  return 0; 
}

 

sort函数

sort 函数在头⽂件 #include <algorithm> ⾥⾯,主要是对⼀个数组进⾏排序( int arr[] 数组或者 vector 数组都⾏), vector 是容器,要⽤ v.begin() 和 v.end() 表示头尾;⽽ int arr[] ⽤ arr 表示数组的⾸地址, arr+n 表示尾部~

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
bool cmp(int a, int b) { // cmp函数返回的值是bool类型
  return a > b; // 从⼤到⼩排列
}
int main() {
  vector<int> v(10);
  for (int i = 0; i < 10; i++) {
  		cin >> v[i];
   }
  sort(v.begin(), v.end());// 因为这⾥没有传⼊参数cmp,所以按照默认,v从⼩到⼤排列
  int arr[10];
  for (int i = 0; i < 10; i++) {
  		cin >> arr[i];
   }
  sort(arr, arr + 10, cmp); // arr从⼤到⼩排列,因为cmp函数排序规则设置了从⼤到⼩
  return 0; 
}

 

⾃定义cmp函数

sort 默认是从⼩到⼤排列的,也可以指定第三个参数 cmp 函数,然后⾃⼰定义⼀个 cmp 函数指定排序规则~ cmp 最好⽤的还是在结构体中,尤其是很多排序的题⽬~⽐如⼀个学⽣结构体 stu 有学号和成绩两个变量,要求如果成绩不同就按照成绩从⼤到⼩排列,如果成绩相同就按照学号从⼩到⼤排列,那么就可以写⼀个 cmp 数组实现这个看上去有点复杂的排序过程:

#include <iostream>
using namespace std;
struct stu { // 定义⼀个结构体stu,number表示学号,score表示分数
  int number;
  int score; 
}
bool cmp(stu a, stu b) { // cmp函数,返回值是bool,传⼊的参数类型应该是结构体stu类型
  if (a.score != b.score) // 如果学⽣分数不同,就按照分数从⼤到⼩排列
  	return a.score > b.score;
  else // 如果学⽣分数相同,就按照学号从⼩到⼤排列
  	return a.number < b.number; 
}
// 有时候这种简单的if-else语句我喜欢直接⽤⼀个C语⾔⾥⾯的三⽬运算符表示~
bool cmp(stu a, stu b) {
  return a.score != b.score ? a.score > b.score : a.number < b.number; 
}

 

注意: sort 函数的 cmp 必须按照规定来写,即必须只是 > 或者 < ,⽐如: return a > b; 或 者 return a < b; ⽽不能是 <= 或者 >= ,因为快速排序的思想中, cmp 函数是当结果为 false 的时候迭代器指针暂停开始交换两个元素的位置,当 cmp 函数 return a <= b 时,若中间元素前⾯的元素都⽐它⼩,⽽后⾯的元素都跟它相等或者⽐它⼩,那么 cmp 恒返回 true ,迭代器指针会不断右移导致程序越界,发⽣段错误~

cctype头⽂件函数

刚刚在头⽂件那⼀段中也提到, #include <cctype> 本质上来源于C语⾔标准函数库中的头⽂件 #include <ctype.h> ,其实并不属于C++新特性的范畴,在刷PAT⼀些字符串逻辑题的时候也经常⽤到,但是很多⼈似乎不了解这个头⽂件中的函数,所以在这⾥单独提⼀下~

可能平时我们判断⼀个字符是否是字⺟,可能会写:

char c;
cin >> c;
if (c >= 'A' && c <= 'Z' || c >= 'a' && c <= 'z') {
  cout << "c is alpha"; 
}

 

但是在 cctype 中已经定义好了判断这些字符应该所属的范围,直接引⼊这个头⽂件并且使⽤⾥⾯的函数判断即可,⽆需⾃⼰⼿写(⾃⼰⼿写有时候可能写错或者漏写~)

#include <iostream>
#include <cctype>
using namespace std;
int main() {
  char c;
  cin >> c;
  if (isalpha(c)) {
  	cout << "c is alpha"; 
  }
  return 0; 
}

 

不仅仅能判断字⺟,还能判断数字、⼩写字⺟、⼤写字⺟等~C++官⽅⽂档中对这些函数归纳成了⼀个表格,我列出了官⽹的函数与所属范围总结表,有兴趣的可以看⼀下:https://www.liuchuo.net/archives/2999

总的来说常⽤的只有以下⼏个:

isalpha 字⺟(包括⼤写、⼩写)

islower (⼩写字⺟)

isupper (⼤写字⺟)

isalnum (字⺟⼤写⼩写+数字)

isblank (space和 \t )

isspace ( space 、 \t 、 \r 、 \n )

cctype 中除了上⾯所说的⽤来判断某个字符是否是某种类型,还有两个经常⽤到的函数: tolower和 toupper ,作⽤是将某个字符转为⼩写或者⼤写,这样就不⽤像原来那样⼿动判断字符c是否是⼤写,如果是⼤写字符就 c = c + 32; 的⽅法将 char c 转为⼩写字符啦~这在字符串处理的题⽬中也是经常⽤到:

char c = 'A';
char t = tolower(c); // 将c字符转化为⼩写字符赋值给t,如果c本身就是⼩写字符也没有关系~
cout << t; // 此处t为'a'

 

C++11

C++11是2011年官⽅为C++语⾔带来的新语法新标准,C++11为C++语⾔带来了很多好⽤的新特性,⽐如 auto 、 to_string() 函数、 stoi 、 stof 、 unordered_map 、 unordered_set 之类的~现在⼤多数OJ都是⽀持C++11语法的,有些编译器在使⽤的时候需要进⾏⼀些设置才能使⽤C++11中的语法,否则可能会导致编译器上编译不通过⽆法运⾏,总之C++11的语法在OJ⾥⾯是可以使⽤的~⽽且很多语法很好⽤~以下讲解⼀些C++11⾥⾯常⽤的新特性~

atuo声明

auto 是C++11⾥⾯的新特性,可以让编译器根据初始值类型直接推断变量的类型。⽐如这样:

auto x = 100; // x是int变量
auto y = 1.5; // y是double变量

当然这个在算法⾥⾯最主要的⽤处不是这个,⽽是在STL中使⽤迭代器的时候, auto 可以代替⼀⼤⻓串的迭代器类型声明:

// 本来set的迭代器遍历要这样写:
for(set<int>::iterator it = s.begin(); it != s.end(); it++) {
    cout << *it << " "; 
}
// 现在可以直接替换成这样的写法:
for(auto it = s.begin(); it != s.end(); it++) {
    cout << *it << " "; 
}

 

基于范围的for循环

除了像C语⾔的for语句 for (i = 0; i < arr.size(); i++) 这样,C++11标准还为C++添加了⼀种新的 for 循环⽅式,叫做基于范围(range-based)的for循环,这在遍历数组中的每⼀个元素时使⽤会⽐较简便~⽐如想要输出数组 arr 中的每⼀个值,可以使⽤如下的⽅式输出:

int arr[4] = {0, 1, 2, 3};
for (int i : arr)
  cout << i << endl; // 输出数组中的每⼀个元素的值,每个元素占据⼀⾏

 

i 变量从数组的第⼀个元素开始,不断执⾏循环, i 依次表示数组中的每⼀个元素~注意,使⽤ int i 的⽅式定义时,该语句只能⽤来输出数组中元素的值,⽽不能修改数组中的元素,如果想要修改,必须使⽤ int &i 这种定义引⽤变量的⽅式~⽐如想给数组中的每⼀个元素都乘以 2 ,可以使⽤如下⽅式:

int arr[4] = {0, 1, 2, 3};
for (int &i : arr) // i为引⽤变量
  i = i * 2; // 将数组中的每⼀个元素都乘以2,arr[4]的内容变为了{0, 2, 4, 6}

 

这种基于范围的 for 循环适⽤于各种类型的数组,将上述两段代码中的 int 改成其他变量类型如 double 、 char 都是可以的~另外,这种 for 循环⽅式不仅可以适⽤于数组,还适⽤于各种STL容器,⽐如 vector 、 set 等~加上上⾯⼀节所讲的C++11⾥⾯很好⽤的 auto 声明,将 int 、 double 等变量类型替换成 auto ,⽤起来就更⽅便啦~

// v是⼀个int类型的vector容器
for (auto i : v)
  cout << i << " ";
// 上⾯的写法等价于
for (int i = 0; i < v.size(); i++)
  cout << v[i] << " ";

to_string

to_string 的头⽂件是 #include <string> , to_string 最常⽤的就是把⼀个 int 型变量或者⼀个数字转化为 string 类型的变量,当然也可以转 double 、 float 等类型的变量,这在很多PAT字符串处理的题⽬中很有⽤处,以下是示例代码:

#include <iostream>
#include <string>
using namespace std;
int main() {
  string s1 = to_string(123); // 将123这个数字转成字符串
  cout << s1 << endl;
  string s2 = to_string(4.5); // 将4.5这个数字转成字符串
  cout << s2 << endl;
  cout << s1 + s2 << endl; // 将s1和s2两个字符串拼接起来并输出
  printf("%s\n", (s1 + s2).c_str()); // 如果想⽤printf输出string,得加⼀个.c_str()
  return 0; 
}

 

stoi & stod

使⽤ stoi 、 stod 可以将字符串 string 转化为对应的 int 型、 double 型变量,这在字符串处理的很多问题中很有帮助~以下是示例代码和⾮法输⼊的处理⽅法:

#include <iostream>
#include <string>
using namespace std;
int main() {
  string str = "123";
  int a = stoi(str);
  cout << a;
  str = "123.44";
  double b = stod(str);
  cout << b;
  return 0; 
}

 

stoi如果遇到的是⾮法输⼊(⽐如stoi(“123.4”),123.4不是⼀个int型变量):

  1. 会⾃动截取最前⾯的数字,直到遇到不是数字为⽌(所以说如果是浮点型,会截取前⾯的整数部分)
  2. 如果最前⾯不是数字,会运⾏时发⽣错误

stod如果是⾮法输⼊:

  1. 会⾃动截取最前⾯的浮点数,直到遇到不满⾜浮点数为⽌
  2. 如果最前⾯不是数字或者⼩数点,会运⾏时发⽣错误
  3. 如果最前⾯是⼩数点,会⾃动转化后在前⾯补0

不仅有stoi、stod两种,相应的还有:

stof (string to float)

stold (string to long double)

stol (string to long)

stoll (string to long long)

stoul (string to unsigned long)

stoull (string to unsigned long long)

Dev-Cpp

如果想要在 Dev-Cpp ⾥⾯使⽤C++11特性的函数,⽐如刷算法中常⽤的 stoi 、 to_string 、 unordered_map 、 unordered_set 、 auto 这些,需要在设置⾥⾯让dev⽀持C++11,需要在菜单栏中⼯具-编译选项-编译器-编译时加⼊ -std=c++11 这句命令即可~

迷鹿, lostfawn
版权声明:本站原创文章,由迷鹿, lostfawn2021-02-11发表,共计14477字。
转载提示:除特殊说明外本站文章皆由CC-4.0协议发布,转载请注明出处。
评论(没有评论)
载入中...
召唤伊斯特瓦尔