数组

二分二分法查找数据

前提是数组中的值是从小到大依次排列的：

 

#include <iostream>
using namespace std;
int find(int,int[],int);
int main()
{
	int a[]={1,32,55,66,77,88,99,110,115,120,125,130};
	cout<<"32在数组a中的位置是："<<find(32,a,12)<<endl;
	cout<<"32在数组a中的位置是："<<find(125,a,12)<<endl;
	return 0;
}
int find(int m,int a[],int n)
{
	//o代表第一个元素的编号，h代表最后一个元素的编号，i代表当前正在查找的元素的编号
	int o=0,h=n-1,i;
	while(o<=h)
	{
		i=(o+h)/2;        //取中元素的编号
		if(a[i]==m)       
			return i;
		if(a[i]<m)        //假如该编号元素的值小于索要查的数据
			o=i+1;        //将该元素的编号加1赋给o，也就是在后半部分搜索
		else                     //加1和减1的原因是i已经查过了
			h=i-1;        //将该元素的编号减1赋给h，也就是在后半部分搜索
	}
	return n;             //搜索不到，返回数组长度。
}

判断数组的排列方式后执行不同的函数

假如数组是按照顺序排列的话，那么使用二分算法；假如不是按顺序排列，那么使用递增法：

#include <iostream>
using namespace std;
int find(int,int[],int);    //二分法
int find2(int,int[],int);   //递增法
bool check(int a[],int n);
int main()
{
	return 0;
}
int find(int m,int a[],int n)
{
	//o代表第一个元素的编号，h代表最后一个元素的编号，i代表当前正在查找的元素的编号
	int o=0,h=n-1,i;
	while(o<=h)
	{
		i=(o+h)/2;        //取中元素的编号
		if(a[i]==m)       
			return i;
		if(a[i]<m)        //假如该编号元素的值小于索要查的数据
			o=i+1;        //将该元素的编号加1赋给o，也就是在后半部分搜索
		else                     //加1和减1的原因是i已经查过了
			h=i-1;        //将该元素的编号减1赋给h，也就是在后半部分搜索
	}
	return n;             //搜索不到，返回数组长度。
}
int find2(int m,int a[],int n)
{
	for (int i=0;i<n;i++)
	{
		if (a[i]==m)
			return i;
	}
	return n;
}
bool check(int a[],int n)
{
	for (int i=1;i<n;i++)
		if (a[i]<a[i-1])
			return false;
	return true;
}

 

在对象数组中初始化成员变量

 

#include <iostream>
using namespace std;
class area
{
public:
	area(int l,int w){length=l;width=w;cout<<"调用构造函数设置长和宽的值"<<endl;}
	~area(){cout<<"调用析构函数释放内存"<<endl;}
	int get(){return length*width;}
	void set(int l,int w){length=l;width=w;}
private:
	int length;
	int width;
};
int main()
{
	area one[4]={area(10,10),area(20,20),area(30,30),area(40,40)};
	cout<<one[0].get()<<endl;
	one[0].set(12,13);
	cout<<one[0].get()<<endl;
	cout<<one[1].get()<<endl;
	cout<<one[2].get()<<endl;
	return 0;
}

指针数组

#include <iostream>
using namespace std;
class area
{
private:
	int length;
	int width;
public:
	//由于本里没有对对象初始化，因此不需要声明构造函数。
	//area(int l,int w){length=l;width=w;}
	~area(){cout<<"调用析构函数释放内存"<<endl;}
	int get()const{return length*width;}
	void set(int l,int w){length=l;width=w;}
};
int main()
{
	area*one=new area[10000];
	int i;
	for (i=0;i<10000;i++)
	{
		one[i].set(i,i*2);
		cout<<"area["<<i<<"]:";
		cout<<one[i].get()<<endl;
		system("pause");
	}
	delete []one;          //删除数组中的每个对象
	return 0;
}

 

枚举数组

 enum day{mon,tue,wen,thu,fri,sat,sun};

enum first[]={mon,tue,wen};

 

用gets函数接受字符时，不会放过任何一个字符，包括空格。

#include <iostream>
using namespace std;
int main()
{
	char a[12];
	cout<<"请输入11个或11个以内的字符：";
	gets(a);                              //不会出现输入空格而导致空格后面的字符收不到。 输入字符串时应注意定义字符数组个数然后减1个字符，因为最后一个数组成员要保存结束符。      用cin.get(a,12)就会把多余的忽略。
	cout<<"请输入字符为："<<a<<endl;	return 0;
}

 多维数组实例：杨辉三角形

#include <iostream>
using namespace std;
int main()
{
	const int n=10;
	int a[n][n];
	int i,j;
	for (i=0;i<=n-1;i++)
	{
		for (j=0;j<=i;j++)
		{
			if (j==0||j==i)
				a[i][j]=1;
			else
				
				a[i][j]=a[i-1][j-1]+a[i-1][j];
			cout<<a[i][j]<<"\t";
		}
		cout<<"\n\n";
	}
}

重载数组下标操作符：

 

#include <iostream>
using namespace std;
class A
{
public:
	A(int l)
	{
		Length=l;
		Size=new char[Length];
	}
	~A(){delete []Size;}
	int GetLength(){return Length;}
	char&operator[](int i)
	{
		if (i>=0&&i<Length)
			return Size[i];
		else
		{
			cout<<"\n超出范围";
			return Size[Length-1];
		}
	}
private:
	int Length;
	char *Size;
};
int main()
{
	int i;
	A a(6);
	char*ch="hellosdss";
	for (i=0;i<8;i++)
	{
		a[i]=ch[i];
		cout<<a[i];
	}
	cout<<"\n";
	for (i=0;i<8;i++)
		cout<<a[i];

	cout<<"\n";
	cout<<a.GetLength()<<endl;
	return 0;
}

 

使用operator[]下表函数的优点：

（1）不用将数组的长度定义为一个常量。

（2）可避免数组越界。

在重载下标运算符函数时应注意：

（1）由于下标运算符函数的参数即是数组的下标，因此该数组只能带一个参数，不可带多个参数。

（2）由于下标运算符函数只限于本类的对象使用，因此不得将下标运算符函数重载为友元类函数，并且是非static成员函数。