常用函数库（补充中...）

2017-06-26

cctype

　　头文件：
　　　#include<cctype>
　　　 cctype图示

二维数组动态创建与删除

　（1）动态创建
　　　思路：先创建行指针，随后为行指针在创建数组，也就是先创建行数组，然后再创建列数组，先纵后横。
　　　

1
2
3

　　　char * *ss = new char*[m];
	　　for(int i=0;i<n;i++)
	  　　ss[i] = new char[n];

　（2）动态删除
　　　思路：与创建相反，先释放列数组，再释放行数组
　　　

1
2
3

　　　for(int i=0;i<n;i++)
  　　　delete [] ss[i];
　　　delete [] ss;

　上述创建的动态数组每行是连续的，但是不同行是不连续的，连续指内存分配。
　　　

　　　int **p1 = new int *[x];  
　　　*p1 = new int[x*y];  
　　　for (int i = 0; i < y; i++)  
　　　p1[i] = *p1 + i*y;  

　　　#include <iostream>
　　　using namespace std;
　　　int main() {
　　　　　int* a[]={
　　　　　　　　　NULL,
　　　　　　　　　new int[6],
　　　　　　　　　new int[6],
　　　　　　　　　new int[6]
　　　　　};
　　　　　*a[2]=123;
　　　　　a[3][5] =456;
　　　　　if(!a[0])
　　　　　{
　　　　　　　cout<<*a[2]<<","<<a[3][5];
　　　　　}
　　　　　return 0;
　　　}

数组初始化

　（1）memset方法
　　头文件：
　　　#include<string>
　　说明：
　　　按照字节填充某字符，所以一般memset只能用来填充char型数组，因为（只有char型占一个字节）；如果填充int型数组，除了0和-1，其他不能填充，因为只有00000000=0，-1同理，如果我们把数组都填充“1”，则导致编程填充如“11111111”。
　　使用方法：
　　　

1 2	char s[n]; 　　　memset(s,'a',sizeof(s));

　（2）fill方法
　　头文件：
　　　#include<algorithm>
　　说明：
　　　按照单元赋值，将一个区间的元素都赋同一个值。
因此fill函数可以赋值任何，而且使用方法特别简便。*
　　　

　　　int a[n]
　　　fill(a,a+sizeof(a),x);
　　　vecotr&lt;int> b;
　　　...
　　　fill(v.begin(),v.end(),x);

　（3）两者综述
　　fill比memset更加简便实用，然而两者都只能给一维数组初始化，二维数组则需要给每一行的行数组循环初始化以达到二维数组初始化的目的。
　　　

　　　char * *ss = new char*[n];
	　　for(int i=0;i<n;i++){
	  　　　ss[i] = new char[col];
	  　　　memset(ss[i], 'a', col);
	  　　　/*fill(ss[i],ss[i]+col,'0');*/
	　　}

array

　与数组一样，array对象的长度也是固定的，也是用栈，而不是自由存储区，因此其效率与数组相同，但更方便，更安全。
　头文件：
　#include<array>

　array<int,5> ai;
　array<int,4> ad={1.2,2.1,3.43,4.3}
　array<typename,n_elem> arr;
　n_elem不能是变量

　可以将一个array对象赋值给另一个array变量，这时与数组的区别。

valarray

　头文件：
　#include<valarray>
　valarray<int> va;
　valarray<int> va(10,2); //设置两个元素，初始化为10，这与vector刚好相反
　类方法：
　\*operator[](): 让能够访问各个元素，此类没有迭代器
　size(): 返回包含的元素数
　sum(): 返回所有元素的总和
　max(): 返回最大的元素
　min(): 返回最小的元素
　valarray重载了所有算术运算符*

pair

　标准库模板定了多参数的类pair，可通过first()和second()方法访问其值。
　

　template<class T1,class T2>
　class Pair{
　　　private:
　　　　　T1 a;
　　　　　T2 b;
　　　public:
　　　　　T1 & first();
　　　　　T2 & second();
　　　　　T1 first() const{return a};
　　　　　T2 second() const{return b};
　　　　　Pair(const T1 & ava1,const T2 & bval) : a(aval),b(bval){}
　　　　　Pair(){}
　}
　template<class T1,class T2>
　T1 & Pair<T1,T2>::first(){
　　return a;
　}
　template<class T1,class T2>
　T2 & Pair<T1,T2>::second(){
　　return b;
　}

c_str()

语法:
const char *c_str();
c_str()函数返回一个指向正规C字符串的指针, 内容与本string串相同.
这是为了与c语言兼容，在c语言中没有string类型，故必须通过string类对象的成员函数c_str()把string 对象转换成c中的字符串样式。
注意：一定要使用strcpy()函数 等来操作方法c_str()返回的指针
比如：
最好不要这样:
char* c;
string s="1234";
c = s.c_str(); //c最后指向的内容是垃圾，因为s对象被析构，其内容被处理
应该这样用：
char c[20];
string s="1234";
strcpy(c,s.c_str());
这样才不会出错，c_str()返回的是一个临时指针，不能对其进行操作
再举个例子
c_str() 以 char* 形式传回 string 内含字符串
如果一个函数要求char*参数，可以使用c_str()方法：
string s = "Hello World!";
printf("%s", s.c_str()); //输出 "Hello World!"

大整数类

a.加法
分块加法，继而进位
b.减法
分块减法，继而借位
c.乘法
乘积是逐位相乘，也就是aibj，结果加入到积C的第i+j位，最后处理进位即可
例如：
A =17 = 1×10 + 7 = （7,1）最后是十进制的幂表示法，幂次是从低位到高位，以下同。
B=25 = 2×10 + 5 = (5, 2);
C = A × B = (7 × 5, 1 × 5 + 2 × 7, 1 × 2) = (35, 19, 2) = (5, 22, 2) = (5, 2, 4)=425
d.除法
作减法，最后为余数，减法次数为商

程序：

/*
	Copyright(c)2017,Louris
	All rights reserved.

	文件名称：BigInteger.h
	摘    要：
		大整数类
		利用longlong型和string类型对大数进行基本算术运算，包括比较运算符、四则运算。


	修改内容：
		1.1 处理2*obj此类问题
		1.2 处理细节
			①strlen等函数需要"cstring"头文件
			②匹配Dev和VS，注释转换即可。（例如sscanf和sscanf_s）
			③修复各类特殊情况诸如(+0)+(-0)
			④其他bug
	版本：1.0
	完成日期：2017.07.13

	版本：1.1
	完成日期：2017.07.29

	当前版本：1.2
	作    者：Louris
	参考书目：《算法竞赛入门经典》
	完成日期：2017.08.28
*/

//======================================DECLARATION=============================
#ifndef BIGINTEGER
#define BIGINTEGER

#include<iostream>
#include<vector>
#include<string>
#include<algorithm>
#include<cstring>
#include<cctype>
using namespace std;
class BigInteger
{
private:
	static const int BASE = 100000000;
	static const int WIDTH = 8; //截取数组元素长度
	char sign_bit;  //符号位
	vector<long long> s;
public:
	//构造函数
	BigInteger();//默认构造函数
	BigInteger(const string &str); //string类参数构造函数
	BigInteger(const long long &num); //longlong型参数构造函数
	BigInteger(const BigInteger &b); //复制构造函数

	//赋值元素运算符重载
	BigInteger & operator = (const long long &num); //针对longlong型参数的赋值运算符重载
	BigInteger & operator = (const string &str); //针对string类参数的赋值运算符重载
	BigInteger & operator = (const BigInteger &b); //赋值运算符重载

	~BigInteger() {}; //析构函数

	//输入、输出流重载
	friend ostream & operator << (ostream &out, const BigInteger &x);
	friend istream & operator >> (istream &in, BigInteger &x);

	//重载四则运算
	BigInteger operator + (const BigInteger &b) const;
	BigInteger operator - (const BigInteger &b) const;
	BigInteger operator * (const BigInteger &b) const;
	BigInteger operator / (const BigInteger &b) const;

	//重载四则运算，友元函数实现，以处理 2 * obj 的情况
	friend BigInteger operator + (const long long &a, const BigInteger &b);
	friend BigInteger operator - (const long long &a, const BigInteger &b);
	friend BigInteger operator * (const long long &a, const BigInteger &b);
	friend BigInteger operator / (const long long &a, const BigInteger &b);

	BigInteger & operator += (const BigInteger &b);
	BigInteger & operator -= (const BigInteger &b);
	BigInteger & operator *= (const BigInteger &b);
	BigInteger & operator /= (const BigInteger &b);


	//自增、自减运算符重载
	//前置重载
	BigInteger & operator ++ ();
	BigInteger & operator -- ();
	//后置重载
	BigInteger operator ++(int x);
	BigInteger operator --(int x);

	//关系运算符重载
	bool operator < (const BigInteger &b) const;
	bool operator > (const BigInteger &b) const;
	bool operator <= (const BigInteger &b) const;
	bool operator >= (const BigInteger &b) const;
	bool operator != (const BigInteger &b) const;
	bool operator == (const BigInteger &b) const;

	//其他衍生运算
	friend BigInteger & operator - (BigInteger &b);  //负号
	BigInteger operator % (const BigInteger &b) const; //求余
	int Abs(const BigInteger &b) const; //绝对值比较,-1,0,1分别表示小于、等于、大于

};

//=======================================END=====================================



//===================================DEFINITION==================================

//默认构造函数
BigInteger::BigInteger()
{
	long long num = 0;
	*this = num;
	sign_bit = '+';
}

//string类参数构造函数
BigInteger::BigInteger(const string &str)
{
	//验证数据有效性第一位除外
	for (unsigned int i = 1; i < str.length(); i++)
	{
		if (!isdigit(str[i]))
		{
			abort();//字符串非法
		}
	}
	if (str[0] == '-')
	{
		string s = str.substr(1, s.size());
		*this = s;
		sign_bit = '-';
	}
	else if (str[0] == '+')
	{
		string s = str.substr(1, s.size());
		*this = s;
		sign_bit = '+';
	}
	else
	{
		if (!isdigit(str[0]))
		{
			abort();
		}
		*this = str;
		sign_bit = '+';
	}
}

//longlong型参数构造函数
BigInteger::BigInteger(const long long &num)
{
	if (num < 0)
	{
		*this = -num;
		sign_bit = '-';
	}
	else
	{
		*this = num;
		sign_bit = '+';
	}
}

//复制构造函数
BigInteger::BigInteger(const BigInteger &b)
{
	for (unsigned int i = 0; i < b.s.size(); i++)
	{
		this->s.push_back(b.s[i]);
	}
	sign_bit = b.sign_bit;
}

//针对longlong型参数的赋值运算符重载
BigInteger & BigInteger::operator = (const long long &num)
{
	long long gross;
	if (num < 0)
	{
		sign_bit = '-';
		gross = -num;
	}
	else
	{
		sign_bit = '+';
		gross = num;
	}
	s.clear();
	do {
		s.push_back(gross % BASE);
		gross /= BASE;
	} while (gross > 0);
	return *this;
}

//针对string类参数的赋值运算符重载
BigInteger & BigInteger::operator = (const string &str)
{
	string ss;
	for (unsigned int i = 1; i < str.length(); i++)
	{
		if (!isdigit(str[i]))
		{
			abort();//字符串非法
		}
	}
	if (str[0] == '-')
	{
		ss = str.substr(1, s.size());

		sign_bit = '-';
	}
	else if (str[0] == '+')
	{
		ss = str.substr(1, s.size());
		sign_bit = '+';
	}
	else
	{
		if (!isdigit(str[0]))
		{
			abort();
		}
		ss = str;
		sign_bit = '+';
	}
	s.clear();
	long long x;
	int len = (ss.length() - 1) / WIDTH + 1;
	for (int i = 0; i < len; i++)
	{
		int end = ss.length() - i*WIDTH;
		int start = max(0, end - WIDTH);
		sscanf_s(ss.substr(start, end - start).c_str(), "%lld", &x);
		//sscanf(ss.substr(start, end - start).c_str(), "%lld", &x);
		s.push_back(x);
	}
	sign_bit = '+';
	return *this;
}

//针对BigInteger类的赋值运算符重载
BigInteger & BigInteger::operator = (const BigInteger &b)
{
	s.clear(); //默认构造函数会给s添加数据
	for (unsigned int i = 0; i < b.s.size(); i++)
	{
		this->s.push_back(b.s[i]);
	}
	sign_bit = b.sign_bit;
	return *this;
}

//重载<<运算符
ostream & operator << (ostream &out, const BigInteger &x)
{
	if (x.sign_bit == '-'&&x != 0)
	{
		out << x.sign_bit;
	}
	//最高一段未必有八位
	out << x.s.back();
	for (int i = x.s.size() - 2; i >= 0; i--) //不能用unsigned int哦！！！i初值为负数gameover
	{
		char buf[20];
		sprintf_s(buf, "%08lld", x.s[i]);
		//sprintf(buf, "%08lld", x.s[i]);
		for (unsigned int j = 0; j < strlen(buf); j++)
		{
			out << buf[j];
		}
	}
	return out;
}

//重载>>运算符
istream & operator >> (istream &in, BigInteger &x)
{
	string s;
	if (!(in >> s)) return in;
	x = s;
	return in;
}

//负号运算符重载
BigInteger & operator - (BigInteger &b) //负号
{
	b.sign_bit == '+' ? b.sign_bit = '-' : b.sign_bit = '+';
	return b;
}

//重载 + 运算符
BigInteger BigInteger::operator + (const BigInteger &b) const
{
	BigInteger c;
	c.s.clear();
	if (sign_bit == b.sign_bit)  //两者同号
	{
		//核心代码
		long long g = 0;
		for (unsigned int i = 0; ; i++)
		{
			if (g == 0 && i >= s.size() && i >= b.s.size()) break;
			long long x = g; //进位
			if (i < s.size()) x += s[i];
			if (i < b.s.size()) x += b.s[i];
			c.s.push_back(x % BASE);
			g = x / BASE;
		}
		c.sign_bit = sign_bit;
	}
	else
	{
		if (sign_bit == '+')
		{
			BigInteger d = b;
			d.sign_bit = '+';
			(this->Abs(b) >= 0) ?
				(c = *this - d, c.sign_bit = '+')
				:
				(c = d - *this, c.sign_bit = '-');
		}
		else
		{
			BigInteger d = *this;
			d.sign_bit = '+';
			(this->Abs(b) >= 0) ?
				(c = d - b, c.sign_bit = '-')
				:
				(c = b - d, c.sign_bit = '+');
		}
	}
	return c;
}

//重载 - 运算符
BigInteger BigInteger::operator - (const BigInteger &b) const //减号
{
	BigInteger c;
	c.s.clear();
	if (sign_bit == b.sign_bit)
	{
		if (sign_bit == '+')
		{
			(this->Abs(b) >= 0) ? (c.sign_bit = '+') : (c.sign_bit = '-');
		}
		else
		{
			(this->Abs(b) >= 0) ? (c.sign_bit = '-') : (c.sign_bit = '+');
		}
	}
	else
	{
		if (sign_bit == '+')
		{
			BigInteger d = b;
			d.sign_bit = '+';
			c = *this + d;
			c.sign_bit = '+';
			return c;
		}
		else
		{
			BigInteger d = *this;
			d.sign_bit = '+';
			c = d + b;
			c.sign_bit = '-';
			return c;
		}
	}
	BigInteger max, min;
	(this->Abs(b) >= 0) ? (max = *this, min = b) : (max = b, min = *this);

	//核心代码
	long long g = 0;
	for (unsigned int i = 0;; i++)
	{
		if (g == 0 && i >= max.s.size() && i >= min.s.size()) break;
		long long x = max.s[i] - g; //借位
		if (i < min.s.size()) x -= min.s[i];
		if (x >= 0)
		{
			g = 0;
		}
		else
		{
			g = 1;
			x = x + BASE;
		}
		c.s.push_back(x);
	}
	return c;
}

//重载 * 运算符
BigInteger BigInteger::operator * (const BigInteger &b) const
{
	BigInteger c;
	c.s.clear();
	long long *temp = new long long[s.size() + b.s.size()];  //longlong型防止八位int型乘积越界
	fill(temp, temp + s.size() + b.s.size(), 0);  //数组初始化
	if (this->Abs(0) == 0 && b.Abs(0) == 0)
	{
		c.sign_bit = '+';
	}
	else
	{
		(sign_bit == b.sign_bit) ? (c.sign_bit = '+') : (c.sign_bit = '-');
	}

	for (unsigned int i = 0; i < s.size(); i++)
	{
		for (unsigned int j = 0; j < b.s.size(); j++)
		{
			temp[i + j] = s[i] * b.s[j];
		}
	}
	for (unsigned int i = 0; i < s.size() + b.s.size(); i++) //进位
	{
		temp[i + 1] += temp[i] / BASE;
		temp[i] %= BASE;
		c.s.push_back(temp[i]);
	}
	for (unsigned int i = s.size() + b.s.size() - 1; i >= 0; i--) //剔除前导0位
	{
		if (c.s[i] != 0 || c.s.size() == 1) //预防乘积为0的情况
		{
			break;
		}
		c.s.pop_back();
	}
	delete[]temp;
	return c;
}

//重载 / 运算符
BigInteger BigInteger::operator / (const BigInteger &b) const
{
	if (b == 0) abort(); //除数不能为0
	BigInteger c;
	c.s.clear();
	if (this->Abs(b) < 0)
	{
		c = 0;
		c.sign_bit = '+';
		return c;
	}
	BigInteger d = b;
	c = *this;
	c.sign_bit = d.sign_bit = '+';
	for (int i = 1;; i++)
	{
		if (c < d)
		{
			c = i - 1;
			break;
		}
		c -= d;
	}
	sign_bit == b.sign_bit ? c.sign_bit = '+' : c.sign_bit = '-';
	return c;
}

BigInteger operator + (const long long &a, const BigInteger &b)
{
	return b + a;
}

BigInteger operator - (const long long &a, const BigInteger &b)
{
	BigInteger temp = (b - a);
	return -temp;
}

BigInteger operator * (const long long &a, const BigInteger &b)
{
	return b * a;
}

BigInteger operator / (const long long &a, const BigInteger &b)
{
	if (b == 0) abort();
	BigInteger c = a;
	return c / b;
}

//重载 += 运算符
BigInteger & BigInteger::operator += (const BigInteger &b)
{
	*this = *this + b;
	return *this;
}

//重载 -= 运算符
BigInteger & BigInteger::operator -= (const BigInteger &b)
{
	*this = *this - b;
	return *this;
}

//重载 *= 运算符
BigInteger & BigInteger::operator *= (const BigInteger &b)
{
	*this = *this*b;
	return *this;
}

//重载 /= 运算符
BigInteger & BigInteger::operator /= (const BigInteger &b)
{
	*this = *this / b;
	return *this;
}

//重载前置 ++ 运算符
BigInteger & BigInteger::operator ++ ()
{
	BigInteger x = 1;
	*this += x;
	return *this;
}

//重载前置 -- 运算符
BigInteger & BigInteger::operator -- ()
{
	BigInteger x = 1;
	*this -= x;
	return *this;
}

//重载后置 -- 运算符
BigInteger BigInteger::operator ++(int x)
{
	BigInteger c = *this;
	x = 1;
	*this += x;
	return c;
}

//重载后置 -- 运算符
BigInteger BigInteger::operator --(int x)
{
	BigInteger c = *this;
	x = 1;
	*this -= x;
	return c;
}

//重载 < 运算符
bool BigInteger::operator < (const BigInteger &b) const
{
	//处理特殊情况 +0 -0
	if (b.Abs(0) == 0 && this->Abs(0) == 0) return false; //切不可*this==b，死循环~
	//符号位不同
	if (sign_bit != b.sign_bit) return sign_bit == '+' ? false : true;

	//符号位相同
	if (sign_bit == '+')
	{
		if (this->Abs(b) >= 0)
			return false;
		else
			return true;
	}
	else
	{
		if (this->Abs(b) >= 0)
			return true;
		else
			return false;
	}
}

//重载 > 运算符
bool BigInteger::operator > (const BigInteger &b) const
{
	return b < *this;
}

//重载 <= 运算符
bool BigInteger::operator <= (const BigInteger &b) const
{
	return !(b < *this);
}

//重载 >= 运算符
bool BigInteger::operator >= (const BigInteger &b) const
{
	return !(*this < b);
}

//重载 != 运算符
bool BigInteger::operator != (const BigInteger &b) const
{
	return b < *this || *this < b;
}

//重载 == 运算符
bool BigInteger::operator == (const BigInteger &b) const
{
	return !(b < *this) && !(*this < b);
}

BigInteger BigInteger::operator % (const BigInteger &b) const
{
	BigInteger c;
	c.s.clear();
	c = *this - (*this / b)*b;
	return c;
}

int BigInteger::Abs(const BigInteger &b) const
{
	int flag = 0;
	if (s.size() != b.s.size()) //长度不等则比较长度即可
	{
		s.size() > b.s.size() ? flag = 1 : flag = -1;
		return flag;
	}

	//长度相同比较各位大小
	for (int i = s.size() - 1; i >= 0; i--)
	{
		if (s[i] != b.s[i])
		{
			s[i] > b.s[i] ? flag = 1 : flag = -1;
			return flag;
		}
	}
	return flag; //相等
}
//=======================================END===============================
#endif // !BIGINTEGER

效率有待日后再来！

memcpy函数

函数原型:
void \*memcpy(void \*dest, const void \*src, size_t n);
功能:
由src指向地址为起始地址的连续n个字节的数据复制到以destin指向地址为起始地址的空间内。
头文件:
#include<string.h>
#include<cstring>
返回值:
函数返回一个指向dest的指针。
说明
1.source和destin所指内存区域不能重叠，函数返回指向destin的指针。
2.与strcpy相比，memcpy并不是遇到'\0'就结束，而是一定会拷贝完n个字节。
memcpy用来做内存拷贝，你可以拿它拷贝任何数据类型的对象，可以指定拷贝的数据长度；
例：
char a[100], b[50];
memcpy(b, a,sizeof(b)); //注意如用sizeof(a)，会造成b的内存地址溢出。
strcpy就只能拷贝字符串了，它遇到'\0'就结束拷贝；例：
char a[100], b[50];
strcpy(a,b);
3.如果目标数组destin本身已有数据，执行memcpy（）后，将覆盖原有数据（最多覆盖n）。如果要追加数据，则每次执行memcpy后，要将目标数组地址增加到你要追加数据的地址。
//注意，source和destin都不一定是数组，任意的可读写的空间均可。

*max_element()和*min_element()

头文件：#include&lt;algorithm>
作用：返回容器中最小值和最大值。
*max_element(a,a+n);
*min_element(a,a+n);
*max_element(v.begin(),v.end());
*min_element(v.begin(),v.end());

_itoa,atoi,atof

_itoa

　功能:把一整数转换为字符串
　用法:char * _itoa(int value, char * string, int radix);
　详细解释: _itoa是英文integer to array(将int整型数转化为一个字符串,并将值保存在数组string中)的缩写.其中value为要转化的整数, radix是基数的意思,即先将value转化为radix进制的数,之后再保存在string中.
备注:该函数的头文件是"stdlib.h"

程序例:

#include <stdlib.h>
#include <stdio.h>
int main()
{
　int number = 123456;
　char string[25];
　_itoa(number, string, 10);
　printf("integer = %d string = %s\n", number, string);
　return 0;
}

atoi函数

原型：
int atoi( const char * string );
ASCII to integer
作用：将字符串转为integer类型
**atof函数**
原型：
double atof( const char * string );
ASCII to float
作用：将字符串转为double类型

sscanf和sprintf

①sscanf
功能:
把格式化的数据输出到某个字符串能缓冲区
头文件:
stdio.h
原型:
int sscnaf( const char * buffer, const char * format, [ argument] … );
参数列表:
buffer：char型指针，指向将要写入的字符串的缓冲区。
format：格式化字符串。
[argument]...：可选参数，可以是任何类型的数据。
②sprintf
功能:
把格式化的数据写入某个字符串缓冲区。
头文件:
include&lt;stdio.h>
原型:
int sprintf( char * buffer, const char * format, [ argument] … );
参数列表:
buffer：char型指针，指向将要写入的字符串的缓冲区。
format：格式化字符串。
[argument]...：可选参数，可以是任何类型的数据。

memset

void * memset(void * s, int ch, size_t n);
函数解释：将s中当前位置后面的n个字节 （typedef unsigned int size_t ）用 ch 替换并返回 s 。
memset：作用是在一段内存块中填充某个给定的值，它是对较大的结构体或数组进行清零操作的一种最快方法
注意：只能赋值0或-1

sort()

头文件：#include<algorithm>
sort(a,a+n) //默认从小到大排序
sort(v.begin(),v.end())
自定义比较规则
bool cmp(int a,int b)
{
  return a>b;//降序排序
}
sort(a,a+n,cmp)
bool cmp(vecotr<int> a,vector<int> b)
{
  return a>b;
}
sort(v.begin(),v.end(),cmp);
头文件：#inlcude<functional>
sort(a,a+n,less<int>());
sort(a,a+n,greater<int>());

to_string()和stoi()

std::string to_string( int value ); (1) （C ++11起）
std::string to_string( long value ); (2) （C ++11起）
std::string to_string( long long value ); (3) （C ++11起）
std::string to_string( unsigned value ); (4) （C ++11起）
std::string to_string( unsigned long value ); (5) （C ++11起）
std::string to_string( unsigned long long value ); (6) （C ++11起）
std::string to_string( float value ); (7) （C ++11起）
std::string to_string( double value ); (8) （C ++11起）
std::string to_string( long double value ); (9) （C ++11起）

string str;
int i=stoi(str)

MyString

#include <cstdlib>
#include <iostream>
using namespace std;
int strlen(const char * s)
{	int i = 0;
  for(; s[i]; ++i);
  return i;
}
void strcpy(char * d,const char * s)
{
  int i = 0;
  for( i = 0; s[i]; ++i)
    d[i] = s[i];
  d[i] = 0;

}
int strcmp(const char * s1,const char * s2)
{
  for(int i = 0; s1[i] && s2[i] ; ++i) {
    if( s1[i] < s2[i] )
      return -1;
    else if( s1[i] > s2[i])
      return 1;
  }
  return 0;
}
void strcat(char * d,const char * s)
{
  int len = strlen(d);
  strcpy(d+len,s);
}
class MyString
{
  private:
    char *str;
public:
MyString(){
  str="";
}
MyString(const char * s)
{
  str=new char[strlen(s)+1];
  strcpy(str,s);
}
MyString(const MyString &s)
{
  str=new char[strlen(s.str)+1];
  strcpy(str,s.str);
}
MyString & operator = (const MyString &s)
{
  str=new char[strlen(s.str)+1];
  strcpy(str,s.str);
  return *this;
}

MyString  operator + (const MyString &s)
{
  MyString temp=*this;
  strcpy(temp.str+strlen(temp.str),s.str);
  return temp;
}
MyString& operator +=(const MyString &s)
{
  strcpy(str+strlen(str),s.str);
  return *this;
}
char& operator [] (int i)
{
  return str[i];
}
friend ostream & operator <<(ostream &out,const MyString &s)
{
  out<<s.str;
  return out;
}
friend MyString operator +(const char *p,const MyString &s)
{
  MyString temp=p;
  strcpy(temp.str+strlen(temp.str),s.str);
  return temp;
}
bool operator < (const MyString &s)
{
  if(strcmp(str,s.str)==-1)
  {
    return true;
  }
  return false;
}
bool operator ==(const MyString &s)
{
  if(strcmp(str,s.str)==0)
  {
    return true;
  }
  return false;
}
bool operator >(const MyString &s)
{
  if(strcmp(str,s.str)==1)
  {
    return true;
  }
  return false;
}
char* operator ()(int index,int len)
{
  char *temp=new char[len+1];
  for(int i=0;i<len;i++)
  {
    temp[i]=str[index+i];
  }
  return temp;
}
};


int CompareString( const void * e1, const void * e2)
{
  MyString * s1 = (MyString * ) e1;
  MyString * s2 = (MyString * ) e2;
  if( * s1 < *s2 )
  return -1;
  else if( *s1 == *s2)
  return 0;
  else if( *s1 > *s2 )
  return 1;
}
int main()
{
  MyString s1("abcd-"),s2,s3("efgh-"),s4(s1);
  MyString SArray[4] = {"big","me","about","take"};
  cout << "1. " << s1 << s2 << s3<< s4<< endl;
  s4 = s3;
  s3 = s1 + s3;
  cout << "2. " << s1 << endl;
  cout << "3. " << s2 << endl;
  cout << "4. " << s3 << endl;
  cout << "5. " << s4 << endl;
  cout << "6. " << s1[2] << endl;
  s2 = s1;
  s1 = "ijkl-";
  s1[2] = 'A' ;
  cout << "7. " << s2 << endl;
  cout << "8. " << s1 << endl;
  s1 += "mnop";
  cout << "9. " << s1 << endl;
  s4 = "qrst-" + s2;
  cout << "10. " << s4 << endl;
  s1 = s2 + s4 + " uvw " + "xyz";
  cout << "11. " << s1 << endl;
  qsort(SArray,4,sizeof(MyString),CompareString);
  for( int i = 0;i < 4;i ++ )
  cout << SArray[i] << endl;
  //s1的从下标0开始长度为4的子串
  cout << s1(0,4) << endl;
  //s1的从下标5开始长度为10的子串
  cout << s1(5,10) << endl;
  return 0;
}

#include <cstdlib>
#include <iostream>
#include <string>
#include <algorithm>
using namespace std;
class MyString:public string
{
public:
  MyString(){
  }
  MyString(const char *s):string(s)
  {

  }
  MyString(const MyString &s):string(s)
  {

  }
  MyString& operator = (const MyString &s)
  {
    string::operator=(s);
    return *this;
  }
  MyString operator + (const MyString &s)
  {
    MyString temp=*this;
    temp+=s;
    return temp;
  }
  MyString& operator += (const MyString &s)
  {
    string::operator+=(s);
    return *this;
  }
  MyString operator + (const char *s)
  {
    MyString temp=s;
    MyString result=*this;
    return result+temp;
  }
  char& operator [](int i)
  {
    return string::operator [](i);
  }
  friend MyString operator + (const char *p,const MyString &s)
  {
    MyString temp=p;
    return temp+s;
  }
  char * operator ()(int index,int len)
  {
    char *temp=new char[len+1];
    for(int i=0;i<len;i++)
    {
      temp[i]=string::operator[](index+i);
    }
    temp[len]='\0';
    return temp;
  }
};


int main()
{
  MyString s1("abcd-"),s2,s3("efgh-"),s4(s1);
  MyString SArray[4] = {"big","me","about","take"};
  cout << "1. " << s1 << s2 << s3<< s4<< endl;
  s4 = s3;
  s3 = s1 + s3;
  cout << "2. " << s1 << endl;
  cout << "3. " << s2 << endl;
  cout << "4. " << s3 << endl;
  cout << "5. " << s4 << endl;
  cout << "6. " << s1[2] << endl;
  s2 = s1;
  s1 = "ijkl-";
  s1[2] = 'A' ;
  cout << "7. " << s2 << endl;
  cout << "8. " << s1 << endl;
  s1 += "mnop";
  cout << "9. " << s1 << endl;
  s4 = "qrst-" + s2;
  cout << "10. " << s4 << endl;
  s1 = s2 + s4 + " uvw " + "xyz";
  cout << "11. " << s1 << endl;
  sort(SArray,SArray+4);
  for( int i = 0;i < 4;i ++ )
  cout << SArray[i] << endl;
  //s1的从下标0开始长度为4的子串
  cout << s1(0,4) << endl;
  //s1的从下标5开始长度为10的子串
  cout << s1(5,10) << endl;
  return 0;
}

STL的unique去重函数

类属性算法unique的作用是从输入序列中“删除”所有相邻的重复元素。
该算法删除相邻的重复元素，然后重新排列输入范围内的元素，并且返回一个迭代器（容器的长度没变，只是元素顺序改变了），表示无重复的值范围得结束
只是覆盖重复元素而已，而后顺序不变。

#include<iostream>
#include<string>
#include<algorithm>
#include<vector>
using namespace std;
int main()
{
    int a[]={1,2,2,2,3,3,3,4,5,6};
    int nCount;
    nCount=unique(a,a+10)-a;
    for(int i=0;i< /*10 */ nCount;i++)
    {
    	cout<<a[i];
	}
    return 0;
}

结果：123456
注释结果：1234563456

getchar输入，putchar输出

getchar和putchar分别用来输入和输出单个字符

1 2	char ch=getchar(); putchar(ch);

gets输入，puts输出

gets用来输入一行字符串（以换行符为结束，与getline类似，但是不将换行符保留在缓冲中）,将换行符保留在缓冲中

1
2
3

char str[20];
gets(str);
puts(str);

string.h

strlen()

返回字符数组中第一个\0前的字符的个数

1 2	char str[10]; int len=strlen(str);

strcmp()

strcmp函数返回两个字符串大小的比较结果，比较原则是按字典序
strcmp(字符数组1，字符数组2)
①如果字符数组1<字符数组2，则返回一个负整数（不同编译器处理不同，不一定是-1）
②如果字符数组1==字符数组2，则返回0
③如果字符数组1>字符数组2，则返回一个正整数（不同编译器处理不同，不一定是+1）

strcpy()

strcpy函数可以把一个字符串复制给另一个字符串
strcpy(字符数组1，字符数组2)
注：把字符数组1复制给字符数组1，包括\0

1
2
3

char str1[50],str2[50];
gets(str2);
strcpy(str1,str2);

strcat()

strcat函数可以把一个字符串接到另一个字符串后面
strcat(字符数组1，字符数组2)
注：把字符数组2接到字符数组1后面

char str1[50],str2[50];
gets(str1);
gets(str2);
strcat(str1,str2);

strchr()

strchr是计算机的一个函数，
原型为extern char * strchr(const char * s,char c)，
可以查找字符串s中首次出现字符c的位置。

char str[20];
gets(str);
cin.get();//剔除回车
char ch=getchar();
int x=strchr(str,ch);

stdio.h

scanf()和printf()

int n; scanf("%d",&n);
char ch; scanf("%c",&ch);
char str[N]； scanf("%s",str); //注意这里，不需要&取地址符
long long lln; scanf("%lld",&lln);
float f; scanf("%f",&f);
double db; scanf("%lf",&db);

int n; printf("%d",n);
char ch; printf("%c",ch);
char str[N]； printf("%s",str);
long long lln; printf("%lld",lln);
float f; printf("%f",f);
double db; printf("%lf",db);

三种实用的输出格式

%md

设置m字符宽度，不足m位的int型变量以m位进行右对齐输出，其中高位用空格补齐；如果变量本身超过m位，则保持原样。

%0md

与上一不同的地方在于补0而不是空格

%.mf

可以让浮点数保留m位小数输出，四舍五入。

sscanf()和sprintf()

scanf("%d",&n);
printf("%d",n);
表示成如下样子：
scanf(screen,"%d",&n); //把screen的内容输入到n中
printf(screen,"&d",n); //把n中的内容输入到screen中

char str[100] = "123";
sscanf(str,"%d",&n); //将char数组str的内容输入到n中
printf(str,"%d",n); //将n的内容输入到str中

//更进一步
int n;
double db;
char str[100] = "2048:3.14,hello";
sscanf(str,"%d:%lf,%s")

char str2[100];
sprintf(str2,"%d,%s",n,str)

iostream

cin与cout

cin.get()与cin.getline()

两者都是能够读取空格，以换行符为输入结束，而区别是cin.get()会将换行符保留在缓冲中，而cin.getline()自动剔除，
详见《C++ Primer plus》

char str[100];
cin.getline(str,100);//长度不够自动截断，长度超过不限制

string ss;
getline(cin.ss);