c语言转向c++

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

简单的文件处理

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("%d\n", 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类型的操作

操作	说明
s. empty ()	如果s为空串，则返回true,否则返回false
s. size()	返回s中字符的个数，s.length()用 法与s.size()相同
s[n]	返回s中位置为o的字符，位置从0开始计数(可将值赋给s[u])
s1+s2	把s1和s2连接成个新字符由，返回新生成的字符串
s1=s2	把s 1内容替换为s2的副本
s1==s2	比较s1与s2的内容，相等则返回true，否则返回false
!=, <, <=, >和>=	保持这些操作符惯有的含义

注意点“+”操作:

strings1("hello ");//等价于strings1="hello”;
string s2("world\n");
s1 += s2;//等价于s1=s1+s2，此时s1="hello world\n'
字符串"+"操作符的左右操作数必须有一个为字符串类型。
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]变成了'*'

其它一些常用操作:

操作	说明
s. insert (pos, s2)	在s下标为pos的元素前插入string类型s2
s. substr (pos, len)	返回一个string类型，它包含s中下标为pos起的1en个字符
s. erase (pos, len)	删除s中下标为pos开始的len个字符
s. replace(pos, len,s2)	删除s中下标为pos的len个字符，并在下标为pos处插入s2
s. find(s2, pos)	在s中以pos位置起查找s2第一次出现的位置，若查找不到返回string::nops
s. c_ str()	返回一个与s字面值相同的C风格的字符串临时指针

#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) ”。
两种情况合在一起称为队列的“溢出。

操作	说明
q. empty ()	如果队列为空，则返回true,否则返回false
q. size ()	返回队列中元素的个数
q. pop ()	删除队首元素，但不返回其值
q.front()	返回队首元素的值，但不删除设元素(仅适用于FIFO队列)
q. back ()	返回队尾元素的值，但不删除该元素(仅适用于FIFO队列)
q. top ()	返回具有最高优先级的元素的值，但不删除该元素(仅适用于优先队列)
q. push()	对于queue,在队尾压入一个新元素 ；对于priority_ queue,在基于优先级的适当位置插入新元素

循环队列

动态数组(vector)

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

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

操作	说明
a[i]	返回动态数组中的第i个元素
a.empty()	若动态数组为空，则返回true,否则返回false
a.size()	返回动态数组中元素的个数
a.resize()	修改动态数组大小
a.push_ back()	向动态数组尾部插入一个元素
a.pop_ back()	删除动态数组尾部的一个元素
a.begin()	返回指向vector头部的迭代器(指针)
a.end()	返回指向vector尾部元素的后一个元素的迭代器( 指针)

利用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中的类型可以是自己定义的结构体，此时结构体中应该有重载小于符号