此博客只是为了快捷转变语言，从上手角度描写，没有描述细节内容。

简单的文件处理

stream文件读入
ifstream fin(“输入流文件名”);
ofstream fout(“输出流文件名”);
fin>>变量名; / fout<<变量名;
fin.close(); / fout.close();
file文件读入
freopen(“输入流文件名”,“r (只读)”,stdin);
freopen(“输出流文件名”,“w (只写)”,stdout);
样例

#include<stdio.h>
int main()
{
    int i, n, s;
    freopen("a.txt", "r", stdin);//"r"只读 ,stdin以标准方式读入
    freopen("b.tet", "w", stdout);//"w"只输出，stdout以标准方式输出 
    while (~scanf("%d", &n))
    {
        s = 0;
        for (i = 1; i <= n; i++)
            s = s + i;
        printf("%dn", s);
    }
    return 0;
}

c++的头文件

#include<stdio.h> -->> #include<cstdio>//其他同理
#include<bits/stdc++.h>//万能头文件，并不是所有的oj都支持
using namespace std; //使用标准命名空间

[具体说明] :
所谓namespace,是指标识符的各种可见范围。C++标准程序库中的所有标识符都被定义于一个名为std的namespace中当使用<iostream.h>,相当于在C中调用库函数，使用的是圣局命名空间，也就是早期的C+ +实现;当使用的时候，该头文件没有定义全局命名空间，必须使用namespace std;这样才能正确使用cout、cin和endl。

输入输出

printf / scanf-- >> cin / cout
ios::sync_ with_ stdio(false);

很多C++的初学者可能会被这个问题困扰，经常出现程序无故超时，最终发现问题处在cin和cout上，在C++中，cin和cout要与stdio同步，中间会有一个缓冲，所以导致cin，cout语句输入输出缓慢，这时就可以用这个语句，取消cin，cout与stdio的同步，说白了就是提速，效率基本与scanf和printf一致。然后就可放心的使用cin，cout了。

例1 已知一位小朋友的电影票价是10元，计算x位小朋友的总票价是多少?

#include<iostream>
using namespace std;
int main()
{
    ios::sync_ with_ stdio(false);
    int x, y;
    cout << "Input x=";//输出注意箭头方向
    cin >> x;//箭头是输入输出流 
    y = 10 * x;
    cout << "total=" << y << endl;//endl相当于回车 
    return 0;
}

其他注意

Dev C++版本注意事项
在5.0版本DevC++中， 不是万能库
1.在c++中需要调用：getchar(), stdin, stdout, freopen(), fclose(), scanf(), printf()
2.在c++中需要调用：memset()
3.在c++中 需要调用：qsort(), exit()
4. < algorithm > 中的STL

c++中的常用操作

sort（默认以非降序排序）

sort(begin, end, cmp)
其中begin为指向待sort()的数组的第一个元素的指针，
end为指向待sort()的数组的最后一个元素的下一个位置的指针，
cmp参数为排序准则，如果没有的话，默认以非降序排序。

string

string相比char a[]类型更加简便，可以进行s1=s2;操作

类型的定义与初始化

#include<string>
using namespace std;
......
string s1;            //定义一个字符串s1,并初始化为空
string s2(s1);        //用s1初始化s2
string s3("value");   //将s3初始化为"value"
string s4(n, 'c');     //将s4初始化为字符'c'的n个副本

string对象的读写

#include<iostream>
#include<string>
using namespace std;
int main()
{
    int T;
    cin >> T;
    getchar();
    /*如果没有这个getchar()那么s首先会把我们按空格给s，要注意:
     cin是不会这样,同样的是gets()也会和getline()出现一样的情况*/
    while (T--)
    {
        string s;
        getline(cin, s);/*getline读入一行,cin是读入流，
                        s是字符串，存放读入的东西*/
        cout << s << endl;
    }
    return 0;
}

string类型的操作

注意点“+”操作:

string s1("hello ");//等价于strings1="hello”;
string s2("worldn");
s1 += s2;//等价于s1=s1+s2，此时s1="hello worldn'
字符串"+"操作符的左右操作数必须有一个为字符串类型。
strings1 = "hello";
string s2 = "world";
strings3 = s1 + ",";//合法
string s4 = "hello " + "world"; //非法
string s5 = s1 + "," + "world";//合法，根据从左至右的结合法则
//s1+","变成一个字符串类型，然后再与”world"相连。
string s6 = "hello" + "," + s2; //非法， 因为"hello"与","都是字符数组类型

字符串的下标操作:

string str="2+2=4";
cout<<str[1]<<end;//将输出’+’
str[1]='*';//现在str[1]变成了'*'

其它一些常用操作:

#include<string>
#include<iostream>
using namespace std;
int main()
{
    string s1 = "1234", s2 = "4321";
    int a, b;
    sscanf(s1.c_str(), "%d", &a);//sscanf()的作用是从字符数组中读入
    sscanf(s2.c_str(), "%d", &b);
    cout << a + b << endl;//输出的是5555 
    return 0;
}

栈(STACK）

栈示意图：先进后出的结构

#include<stack>
......
stack<int > s；
/*中间尖括号里是栈的类型，可以是string,char,etc.
  s是变量名*/

empty()//堆栈为空则返回真
pop()//移除栈顶元素
push()/*在栈顶增加元素  为保险起见，通常限制栈的大小
        .......
        #define STACK_SIZE 100//限制栈的容量为100
        .......
            if(s.size()<STACK_SIZE)
                s.push(68);
        .......*/
size()//返回栈中元素数目
top()//返回栈顶元素

FIFO队列和优先队列

FIFO队列示意图（先进先出的结构）：

#include<queue>
//定义FIFO队列
queue<类型名>变量名
queue<int> que//定义que为一个int类型的FIFO队列
queue<char>a//定义a为一个char类型的FIFO队列
queue<data>c/*定义c为一个data类型的FIFO队列其
中data为自定义的数据类型，可以为结构体*/

FIFO队列的状态：
1.队空:队列中没有任何元素。
2.队满:队列空间已全被占用。
3.溢出:当队列已满，却还有元素要入队,就会出现“上溢(overflow) ”;
当队列已空，却还要做“出队”操作，就会出现“下溢(underflow) ”。
两种情况合在一起称为队列的“溢出。

循环队列

动态数组（vector）

为了节省空间，有时我们会使用动态数组vector

#include <vector>
vector<类型名>变量名
vector<int>que //定义que为一个int类型的动态数组
vector<char>a  //定义a为一个char类型的动态数组
vector<data>c  // 其中data为自定义的数据类型，可以为结构体

利用C++动态数组实现的排序代码:

#include <iostream>
#include <cstdio>
#include <vector>
#include <algorithm>
using namespace std;
int main()
{
    vector<int> a;//动态数组
    int n;
    scanf("%d", &n);
    for (int i = 1; i <= n; i++)
    {
        int tmp;
        scanf("%d", &tmp);
        a.push_back(tmp);
    }
    sort(a.begin(), a.end());
    for (int i = 0; i < a.size(); i++)printf("%d ", a[i]);
    printf("n");
    return 0;
}

map

在实际应用中，我们可以使用map容器来作为一个有序的映射表，可以将其看做是一个下标可以是任何类型的数组。对map单次操作的时间复杂度O(lgn)。
定义map

map<类型1，类型2>变量名;
map<string, int> ma; // 定义ma为一个从string到int的一个映射

访问map中的元素

map<string, int> ma;//定义ma
ma[“abc"]=2;//将字符串”abc"映射到整数”2”上
cout << ma["abc"] << endl; //屏幕上将输出整数2

同时，map中的类型可以是自己定义的结构体，此时结构体中应该有重载小于符号