写给要考c++的同学
貌似大家都对 信息考试/ap计算机 很虚啊，那我撸一篇博客来帮大家复习一下c++的基础操作吧
c++是一种面向对象的语言，但是必修的信息考试不会考面相对象的内容
晚自习撸出来的写得很乱，但都是精华，看不懂的可以评论区私戳我。
手机已经放起来了所以不会及时回复微信和qq的消息。
先复习一下吧
信息考试ak常用框架
#include<iostream>//引入iostream函数库
using namespace std;//定义std命名空间
int main()//主函数
{
//你的代码
}（可能有人不知道/*你要注释的内容*/）
所以我们来谈谈c++的小技巧；
cin>>x;
x可以是int，char，string，long long，double，float类型
可以说是非常好用了，但是cin为了兼容那么多类型，时间上慢了很多，我不知道信息考试有没有程序运行时间限制，如果有的话最好还是用scanf（）函数；
没给数字个数，读入一行数字到结束
这个问题常用于多组数据的时候，可以用while（cin>>x)或while(cin>>a[i++]）解决，一个是用一个变量记录，一个是用数组记录历史信息。
当然用scanf的话就是while（scanf（”你的类型“，&a）！=EOF）或者while（~scanf（”类型“，&a))
死循环
while（1）或while（true）
记住一定要写循环边界，不然程序就卡死了
然后就是，你想要写程序之前，你要先自己把题目给的样例用笔算出答案，然后让程序来模拟你的思考过程，最后自己出一些数据，确保程序的正确性。
以下是给ap计算机的同学的
------------------------------
stl模板
这是个开挂一样的东西
sort
sort用于排序，在数据不同时采取的排序算法也不同。
sort包含在头文件#include<algorithm>
我们要把一个数组a[100]从小到大排序
那么就是sort（a,a+100);运行完之后，a数组就已经被排好续了。
如果要从大到小排，我们常用的方法是吧sort函数的<重载成>号，就是说重载后的sort里，它会认为1比100大，自然就从大到小排序了；
重载后的写法：
bool cmp(int x,int y)//cmp原本为取x和y中的较小值，我们该为最大值
{return x>y;}
sort（a,a+100,cmp);
queue
还在手写队列吗？如果不参加信息学奥赛的省队选拔，那就用stl吧
#include<queue>
queue<int >a;
a.push();放入a
a.pop();出队
a.front();取队首
栈
#include<stack>
stack<int>a;
a.push();
a.pop();
a.top();
还有一个神器，优先队列，priority_queue
#include<queue>
#include<algorithm>
priority_queue<int>a;
a.push();
a.pop();
a.front();
//优先队列不是队列，因为它是个二叉最大堆。。。
被放入优先队列的元素会自动排好序（默认从大到小），并且使用的是堆排序，节约大量时间。
高精度，下面的模板背熟就好了，随便用
struct bign
{
int len, s[MAXN];
bign ()
{
memset(s, 0, sizeof(s));
len = 1;
}
bign (int num) { *this = num; }
bign (const char *num) { *this = num; }
bign operator = (const int num)
{
char s[MAXN];
sprintf(s, "%d", num);
*this = s;
return *this;
}
bign operator = (const char *num)
{
for(int i = 0; num[i] == '0'; num++) ; //去前导0
len = strlen(num);
for(int i = 0; i < len; i++) s[i] = num[len-i-1] - '0';
return *this;
}
bign operator + (const bign &b) const //+
{
bign c;
c.len = 0;
for(int i = 0, g = 0; g || i < max(len, b.len); i++)
{
int x = g;
if(i < len) x += s[i];
if(i < b.len) x += b.s[i];
c.s[c.len++] = x % 10;
g = x / 10;
}
return c;
}
bign operator += (const bign &b)
{
*this = *this + b;
return *this;
}
void clean()
{
while(len > 1 && !s[len-1]) len--;
}
bign operator * (const bign &b) //*
{
bign c;
c.len = len + b.len;
for(int i = 0; i < len; i++)
{
for(int j = 0; j < b.len; j++)
{
c.s[i+j] += s[i] * b.s[j];
}
}
for(int i = 0; i < c.len; i++)
{
c.s[i+1] += c.s[i]/10;
c.s[i] %= 10;
}
c.clean();
return c;
}
bign operator *= (const bign &b)
{
*this = *this * b;
return *this;
}
bign operator - (const bign &b)
{
bign c;
c.len = 0;
for(int i = 0, g = 0; i < len; i++)
{
int x = s[i] - g;
if(i < b.len) x -= b.s[i];
if(x >= 0) g = 0;
else
{
g = 1;
x += 10;
}
c.s[c.len++] = x;
}
c.clean();
return c;
}
bign operator -= (const bign &b)
{
*this = *this - b;
return *this;
}
bign operator / (const bign &b)
{
bign c, f = 0;
for(int i = len-1; i >= 0; i--)
{
f = f*10;
f.s[0] = s[i];
while(f >= b)
{
f -= b;
c.s[i]++;
}
}
c.len = len;
c.clean();
return c;
}
bign operator /= (const bign &b)
{
*this = *this / b;
return *this;
}
bign operator % (const bign &b)
{
bign r = *this / b;
r = *this - r*b;
return r;
}
bign operator %= (const bign &b)
{
*this = *this % b;
return *this;
}
bool operator < (const bign &b)
{
if(len != b.len) return len < b.len;
for(int i = len-1; i >= 0; i--)
{
if(s[i] != b.s[i]) return s[i] < b.s[i];
}
return false;
}
bool operator > (const bign &b)
{
if(len != b.len) return len > b.len;
for(int i = len-1; i >= 0; i--)
{
if(s[i] != b.s[i]) return s[i] > b.s[i];
}
return false;
}
bool operator == (const bign &b)
{
return !(*this > b) && !(*this < b);
}
bool operator != (const bign &b)
{
return !(*this == b);
}
bool operator <= (const bign &b)
{
return *this < b || *this == b;
}
bool operator >= (const bign &b)
{
return *this > b || *this == b;
}
string str() const
{
string res = "";
for(int i = 0; i < len; i++) res = char(s[i]+'0') + res;
return res;
}
};
istream& operator >> (istream &in, bign &x)
{
string s;
in >> s;
x = s.c_str();
return in;
}
ostream& operator << (ostream &out, const bign &x)
{
out << x.str();
return out;
} 搜索模板
dfs（node a）
{
是否搜到终点？-》结束或继续
搜索这个状态能连接的其他状态。
处理这个状态
return ；
}
bfs（）
{
queue<node>a;
a.push(起点）；
while（！a.empty())
{
node now=a.front();
a.pop();
把now能连接到的状态放到a里
处理a的信息
}
}
好了大概就这些，应该不会考更难的东西，祝大家rp++吧，期末AK虐场。
