一些小方法诸如：交换值，排序，查找等等

#include<iostream>
#include<windows.h>
//#include"c:\Users\Administrator\Desktop\dd\aaa.h"
//------strlen 没有结束符，sizeof 有结束符
int a = 1;
int b = 2;
int arr[] ={1,2,6,4,8,9,11,55,23};
int mu[5]={23,24,65,76,98};
int shan[10]={3,4,87,23,8,90,20,54,26,94};
int shui[5]={67,45,34,78,37};
/*
1  交换2个变量的值 void ExChange(int* a, int* b);
void ExChange(int& a, int& b);	
*/
void ExChange(int *a,int *b)
{
	int c = *a;
	*a = *b;
	*b = c;
}
/*
2  返回数组中最大的数据 int GetMax(int* arr,int len);
当只返回一个数据的时候通常用返回值返回出去！
*/
void ExChange1(int &a,int &b)
{
	int c = a;
	a = b;
	b = c;
}
/*
3  同时返回数组中最大值 void GetMax(int* arr,int len);
*/
int GetMax(int *arr,int len)
{
	if(len == 1) return arr[0];
	for(int i =0 ; i < len-1; ++ i)
	{
		if(arr[i]>arr[i+1])
		{
			int a = arr[i];
			arr[i] = arr[i + 1];
			arr[i+1] = a;
		}
	}
	return arr[len - 1];
}
/*
3  同时返回数组中最大值和最小值 
void GetMaxAndMin(int* arr,int len,int* max,int* min);
一般要返回多个值都是通过形参返回出去！
*/
void GetMx(int *arr,int len,int* max,int* min)
{
	if(len == 1) 
	{
		*min = arr[0];
		*max = arr[0];
	}
	for(int i =0 ; i < len-1; ++ i)
	{
		if(arr[i]>arr[i+1])
		{
			int a = arr[i];
			arr[i] = arr[i + 1];
			arr[i+1] = a;
		}
	}
	*max = arr[len - 1];
	for(int i =0 ; i < len-1; ++ i)
	{
		if(arr[i] < arr[i+1])
		{
			int a = arr[i];
			arr[i] = arr[i + 1];
			arr[i+1] = a;
		}
	}
	*min = arr[len - 1];
}
/*
4  数组升序排列 void Sort(int* arr,int len);      
注意循环次数！
*/
void Sort(int *arr,int len)//升序排列
{
	for(int i = 0 ; i < len ;++i)
	{
		for(int j = i + 1 ; j < len ;++j)
		{
			if( arr[i] > arr [j])
			{
				int a = arr[i];
				arr[i] = arr[j];
				arr[j] = a ;
			}
		}
	}
}

/*
5  用折半查找的方法返回数据在升序数组中的下标，无则返回-1 
*/
int ZBchazhao(int *arr,int len,int data)//折半查找，升序或降序数组
{
	int a = 0;
	int b = len-1;
	while(a <= b)
	{
		int m = (a+b)/2;
		if(data < arr[m])
			b = m - 1 ;
		else if(data > arr[m])
			a = m + 1 ;
		else
			return m ;
	}
	return -1;
}
/*
6  strlen("abc")和sizeof("abc") 到底算不算结束符？strlen算长度不算结束符，sizeof算结束符
7  计算一个字符串的长度  int Strlen(const char* s);
*/
int Strlen(const char*s)
{
	int len = 0 ;
	while(s[len])len++;
	return len;
}
/*
8  字符串拷贝功能,返回拷贝之后的字符串  char* Strcpy(char* dest,const char* src);
*/
char*Strcpy(char*dest,const char*src)
{
	int len = 0 ;
	while(src[len])dest[len] = src[len++];
	dest[len] = 0;
	return dest;
}
/*
9  字符串连接功能，返回链接之后的字符串  char* Strcat(char* dest, const char* src);
*/
char*Strcat(char*dest,const char*src)
{
	int len = 0 ;
	int len1 = 0 ;
	while(dest[len])len++;
	while(src[len1])dest[len+len1] = src[len1++];
	dest[len+len1] = 0 ;
	return dest ;
}
/*
10 字符串比较功能，相等返回0，第一个大于第二个返回1，
	第一个小于第二个返回-1	int Strcmp(const char* s1,const char* s2);
*/
int Strcmp(const char*s1,const char *s2)
{
	int len = 0 ;
	while(s1[len] || s2[len])
	{
		if(s1[len] > s2[len])
			return 1;
		else if(s1[len] < s2[len])
			return -1;
		len++;
	}
	return 0 ;
}
/*
11 字符串s1中查找字符串s2,返回第一个找到的首地址
	const char* Strstr(const char* s1, const char* s2);  
	注意返回的是地址，不是下标！
*/
const char* Strstr(const char*s1,const char *s2)
{
	int len1 = 0 ;
	int len2 = 0 ;
	while(s1[len1])len1++;
	while(s2[len2])len2++;
	bool T = true;
	for(int i = 0 ; i < len1 - len2 ; ++i )
	{
		for(int j = 0 ; j < len2 ; ++j )
		{
			if(s1[i+j] != s2[j])
			{
				T = false;
				break;
			}
			else T = true;
		}
		if(T)
		{
			return &s1[i];
		}
	}
	return 0;
}
/*
12 字符串数组排序,交换s中的数据 char s[5][128]; 
*/
void strpaixu(char**arr,int a)
{
	for(int i=0;i<a-1;++i)
	{
		for(int j= i+1;j<a;++j)
		{
			if(Strcmp(arr[i],arr[j]) > 0)
			{
				char *a = arr[i];
				arr[i] = arr[j];
				arr[j] = a;
			}
		}
	}
}
/*
13 字符串数组排序,s中的数据不变，通过交换p中数据，
	通过输出p得到升序排列的5个字符串 char s[5][128]; 
	char* p[5]={s[0],s[1],s[2],s[3],s[4]};
*/
void strpaixu_zhizhen(char**arr,char**p,int a)
{
	for(int i=0;i<a;++i)
		p[i] = arr[i];
	for(int i=0;i<a-1;++i)
	{
		for(int j= i+1;j<a;++j)
		{
			if(Strcmp(p[i],p[j]) > 0)
			{
				char *a = p[i];
				p[i] = p[j];
				p[j] = a;
			}
		}
	}
}
/*
14 字符串转整数,如果s是非法的字符串则返回假  bool Atoi(const char* s,int* i);
*/
bool Atoi(const char* s,int* a)
{
	int len = 0 ;
	*a = 0 ;
	while(s[len])len++;
	if(s[0] == '-' || s[0] == '+')
	{
		for(int i = 1 ; i  < len ;++i)
		{
			if(s[i] >= '0' && s[i] <= '9')
				*a = *a * 10 + s[i]-'0';
			else
				return false;
		}
		if(s[0] == '+')
			*a = *a;
		else if(s[0] == '-')
			*a = -*a;	
		return true;
	}
	else
	{
		for(int i = 0 ; i  < len ;++i)
		{
			if(s[i] >= '0' && s[i] <= '9')
				*a = *a * 10 + s[i]-'0';
			else
				return false;
		}
		return true;
	}
}
/*
15 	int shan[10]={3,4,87,23,8,90,20,54,26,94};//这几个下标位置绘制'山'
	int shui[5]={67,45,34,78,37};//这几个下标位置绘制'水'
	int mu[5]={23,24,65,76,98};//这几个下标位置绘制'木'
	地图宽高是10*10，如果同个位置既是山也是水或者木，按照木》山》水 的优先级绘制,完成绘制函数
	void Draw();
*/
//int * h;static int mm = 120202;h = &mm;
void draw()
{
	int map[100]={};
	for(int i = 0 ; i < 100 ; ++i)
	{
		for(int j = 0 ; j < 10 ; ++j)
		{
			if(i == mu[j] && j < 5 )		  map[i] = 1 ;
			else if(i == shan[j] && map[i] != 1) map[i] = 2 ;
			else if(i == shui[j] && j < 5 && map[i] != 1 && map[i] != 2) map[i] = 3 ;
		}
	}
	for(int i = 0 ; i < 100 ;++i)
	{
		switch (map[i])
		{
		case 0:std::cout<<"口";break;
		case 1:std::cout<<"木";break;
		case 2:std::cout<<"山";break;
		case 3:std::cout<<"水";break;
		}
		if(i%10==9)std::cout<<std::endl;
	}
}

void main1()
{	
	
	//draw();
	//char s[]="-230123";
	//int a = 0;
	//bool b=Atoi(s,&a);
	//if(b == false)
	//{
	//	std::cout<<"feifa";
	//	system("pause");
	//}
	//std::cout<<*h<<std::endl;
	//system("pause");


}
/*
16	栈内存区、静态内存区、堆内存区、常量内存区
	1怎么定义？
		栈内存：就是那些由编译器在需要的时候分配，在不需要的时候自动清楚的变量的存储区。
		堆内存区:内存使用new进行分配，使用delete或delete[]释放。如果未能对内存进行正确
			的释放，会造成内存泄漏。但在程序结束时，会由操作系统自动回收。
		静态内存区：静态的内存使用的是栈空间内存，不用程序员自己来分配。因为静态变量占
			用的存储空间对于编译器而言是可预计的，静态内存只需要编程的时候直接声明就可以了。
		常量内存区：存储常量，不允许被修改。
	2是否初始化？
	栈内存：否
	堆内存：否
	静态内存：是
	常量内存：否
	3何时开辟内存？
	栈内存：函数调用时
	堆内存：执行malloc或new时
	静态内存：编译时候
	常量内存：编译时候
	4何时销毁内存？
	栈内存：函数结束
	堆内存：执行free或new时候
	静态内存：程序结束
	常量内存：程序结束
	5写f函数分别返回这4种内存区的地址
	int* f1()
	{
		int a = 10;
		return &a;
	}
	
	int* f2()
	{
		int *p = (int*)malloc(10);
		return p ;
	}
	int* f3()
	{
		static int b = 20 ;
		return &b;
	}
	char* f()
	{
		char *p = "adfsdfsd";
		return p;
	}
//main.cpp 


//int a = 0; 全局初始化区 
//char* p1; 全局未初始化区 
//main() 
//{ 
//int b; 栈 
//char s[] = "abc"; 栈 
//char* p2; 栈 
//char* p3 = "123456"; 123456\0在常量区，p3在栈上。 
//static int c =0； 全局（静态）初始化区 
//p1 = (char*)malloc(10); 
//p2 = (char*)malloc(20); 
//分配得来得10和20字节的区域就在堆区。 
//strcpy(p1, "123456"); 123456\0放在常量区，编译器可能会将它与p3所指向的"123456"优化成一个地方。 


17 生成可执行程序的步骤？每个步骤做的事情？
	1)预编译：宏和包含文件；过后只剩.cpp
	2)编译：定义语句；过后生成.obj
	3)连接：生成.exe


18 static的三种用法和各种功能？
//static 的用法：
//1)修饰局部变量 将局部变量存入静态内存区，程序结束才销毁，操作只能用指针；
//2)修饰全局变量 将全局变量作用域限定在该源文件
//3)修饰函数     将函数调用范围限定在该源文件中

19	全局变量的定义和声明写法是什么？ 
	:都在函数外		定义：int a 或 int a = 10  或 extern int a = 10; 
					声明：extern int a ;
	哪种写法不算声明而算定义？
	: extern int a = 10
	函数的定义和声明写法是什么？
	定义：有函数体   声明：没有函数体
	int fire()				int fire();
	{
		return 0 ;
	}
	局部变量有声明吗？
	:没有，用不着
	局部变量和全局变量可以同名吗？如果可以同名怎么区分？
	：可以，临近原则；

	20 内联函数和普通函数的区别？
	：内联函数只能在当前源文件中调用，普通函数则是整个工程文件都可以
   什么情况下写为内联函数更好？
	：该函数通用度不高
   内联函数的定义和声明是否应该像普通函数那样一个写.h一个写.cpp ？
	：不；

	21	常量指针和指针常量分别怎么定义？
		1）常量指针：指向常量的指针
		2）指针常量：该指针为常量
		以及操作规则是怎样的？
		1）常量指针：不能修改指向内容，可以修改指向
		2）指针常量：不能修改指向，可以修改指向内容
		哪个必须初始化？
		：指针常量必须初始化
		哪种有两种写法？
		：常量指针  如：const int* p  /  int const* p ;


	22	指针函数 和 函数指针 分别指什么？
		用具体代码举例一下。


		22	指针函数 和 函数指针 分别指什么？
		用具体代码举例一下。
		1)指针函数：返回值为指针类型的函数
			int* fun()
			{
				static int a = 90 ;
				return &a ;
			}
		2)函数指针：指向函数的指针
			int fire()
			{
				int (*p)(const char a,const char b);
				p = strcmp ;
				return 0 ;
			}


	23	typedef和引用分别是给什么取别名？
		用具体代码举例一下。
		1）typedef:给类型取别名
			typedef int A ;
			A a = 10 ;// a 为int类型；
		2) 引用：给变量取别名
			int a = 5 ;
			int &b = a ;
			b = 1 ;
			cout<<a<<b;//结果都为1；

		24	完成无限添加整数 
			void Add(int a); 
			void Print(); 
			void Save(const char* filename);
			void Load(const char* filename);
			必须先存整数的个数，再存数据！
*/
int size = 4 ;
int len = 0 ;
int *p = (int*)malloc(4);
char filename[60];
void Add(int a)
{
	p[len++] = a ;
	if(size == 4*len)
	{
		size*=2;
		int *np = (int*)malloc(size);
		for(int i = 0 ; i < len ; ++i)
			np[i] = p[i];
		free (p);
		p = np ;
	}
}
void Print()
{
	for(int i = 0 ; i < len ; ++i )
		std::cout<<p[i]<<"  ";
}
void Save(const char* filename)
{
	FILE *fp ;
	fopen_s(&fp,filename,"wb");
	if(fp == 0)return;
	fwrite(&len,4,1,fp);
	fwrite(p,4,len,fp);
	fclose(fp);
}
void Load(const char* filename)
{
	FILE*fp;
	fopen_s(&fp,filename,"rb");
	fread(&len,4,1,fp);
	p = (int*)malloc(len*4);
	fread(p,4,len,fp);
	fclose(fp);
}
void main2()
{
	while(1)
	{
		system("cls");
		int aa ;
		std::cout<<"请输入1~4，添加/保存/查看/load";
		std::cin>>aa;
		std::cout<<std::endl;
		if(aa == 1) 
		{
			int a;
			std::cin>>a;
			Add(a);
		}
		if(aa == 2)
		{
			std::cout<<"输入文件名";
			std::cin>>filename;
			Save(filename);
		}
		if(aa == 3)
		{
			Print();
			system("pause");
		}
		if(aa == 4)
		{
			std::cout<<"请输入需要的文件";
			std::cin>>filename;
			Load(filename);
		}
	}
}


}