写给要考c++的同学

貌似大家都对 信息考试/ap计算机 很虚啊，那我撸一篇博客来帮大家复习一下c++的基础操作吧

c++是一种面向对象的语言，但是必修的信息考试不会考面相对象的内容

晚自习撸出来的写得很乱，但都是精华，看不懂的可以评论区私戳我。

手机已经放起来了所以不会及时回复微信和qq的消息。

先复习一下吧

信息考试ak常用框架

#include<iostream>//引入iostream函数库
using namespace std;//定义std命名空间
int main()//主函数
{
//你的代码
}

/*可能有人想问我ak是什么，我们学信竞的，每天都要写题，题目提交在oj（online judge）上面，评判对错，对了就是accept，简称AC。有时候一条代码调了一个下午，一天，一个星期，经过无数次wrong之后终于能accept了，就会说AC，有时候AC一道题激动到忘记吃饭也是日常。在模拟赛的时候，我们会有四道题限时四个小时。在经过四个小时的掉头发之后，评测结果出来，四道题全部AC（当然这种情况极少发生），那我们就说那个人AK了。大概就是拿着一把AK47自动步枪突突突突突突把所有题秒杀了。*/

（可能有人不知道/*你要注释的内容*/）

所以我们来谈谈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虐场。