第十三章 数组 简单

////////////////////////////////////////////
///什么是数组
/*
关于数组，我可以举一个比较形象的例子，比如某校初三一班有二十名女生，那么我就可以简单说这二十名学生组成了一个数组
为什么这样讲呢?因为这二十名女生她们是一个类型的-都是女性，而且她们所属的班级有一个共同的名字-初三一班
我们看完上面的例子，是不是就可以大致地整亘出数组的含义了?
没错，正如你所说的，数组是一组具有相同名称和类型的变量的集合，这些变量就好比初三一班的女生，为了区分这些女生，我们为她们编了号码，我们编的号码在C++
里有一个称呼，叫做下标，我们通过下标来区别这些女生，这些女生的个数又叫做数组的长度
根据这三点：数组的类型，数组名和下标，我们就可以声明一个数组，这里的下标是指数组中变量的数目，换句话说这是女生的个数，这个数目要用搬号括起来，例如:
int a[20]
int表示声明的数据类型为整型，与例子中二十名女生都是一个类型的---女性是一个道理，a是数组名，相当于初三一班，括号中的20表示数组所包含的变量为20个
我们看到20个数字后马上可以了解到这个数组包含20个变量，但是编译器看到这个数字后，不光要了解这个数组含有20个变量，还要为这个20个主爆裂安排足够的空间来存放
也就是说我们的20个女生每个都要有初三一班有一个座位，而这些具体细节一般都由她们的班主作弄来安排，孩子的家长大可不必操心
*/


////////////////////////////////////////////////
///数组元素
//数组中的变量又叫数组元素，数组元素从0开始，比如说在int a[20]这个例子中，a[0]是第一数组元素，
//换句话说它是编号为0的女生，a[1]是第二个女生，a[2]是第三个，依次类推，直到a[19]也就是第20个女生为止。
//一般来说，a[n]有n个元素，范围从a[0]到a[n-1]之间，并且包括a[0]和a[n-1]这两个元素
//我们用程序来说明一下:

/*
#include <iostream>
using namespace std;
int main()
{
	int s[5];
	for(int i=0; i<5; i++)
	{
	    //cout<<i<<endl;
		s[i] = i;
		cout<<s[i]<<endl;
	}
    return 0;
}*/


// 3数组下标越界
//注意:
//数组元素从0开始算起，而不是自1开始，这是许多新手最容易犯的毛病之一，我们需要记住的是，
//假如你定义了一个数组a[9]，那么它的成员就是从a[0]起到a[8]为止，组对没有a[9]
//数组下标越界

/*
#include <iostream>
using namespace std;
int main()
{
	int s[5];
	//for(int i=0; i<6; i++) 越界啦
	for(int i=0; i<5; i++)
	{
	    //cout<<i<<endl;
		s[i] = i;
		cout<<s[i]<<endl;
	}
    return 0;
}*/


// 4 倒序输出
/*
#include <iostream>
using namespace std;
int main()
{
	int s[5];
	//笨哦，这里都写错了
	for(int i=4; i>=0; i--)
	{
		cout<<i<<endl;

	     s[i] = i;
		 cout<<s[i]<<endl;
	}
    return 0;
}*/


// 5 将数组的下标定义为常量以便于修改

/*
#include <iostream>
using namespace std;
const int number=5;
int main()
{
		int s[number];
		//笨哦，这里都写错了
		for(int i=number-1; i>=0; i--)
		{
			 s[i] = i;
			 cout<<s[i]<<endl;
		}
}*/

// 6 手动操作数组元素
/*
#include <iostream>
using namespace std;
int main()
{
	const int number = 5;
	int s[number];
	int i;
	for(i=0; i<number; i++)
	{
	     cout<<"请输入第"<<i<<"位学生的成绩:"<<endl;
		 cin>>s[i];
	}

	for(i=0; i<number; i++)
	{
		 cout<<"第"<<i<<"位学生的成绩为:"<<s[i]<<endl;
	}
    return 0;
}*/

// 7 数组的初始化
/*
#include <iostream>
using namespace std;
int main()
{
	int s[20] = {22,33,44};
	for(int i=0; i<20; i++)
	{
	   cout<<s[i]<<endl;
	}
    return 0;
}*/

/*
#include <iostream>
using namespace std;
int main()
{
	 s[20] = {0};
	for(int i=0; i<20; i++)
	{
	   cout<<s[i]<<endl;
	}
    return 0;

	int s[] = {11,22,33,44};
	for(int i=0; i<20; i++)
	{
	   cout<<s[i]<<endl;
	}
    return 0;
}*/

// 8 求平均考试成绩
/*
#include <iostream>
using namespace std;
int main()
{
	const int number=10;
	int s[]={11,22,43,55,66,77,88,99,44,99};
	int total=0;
	float p=0.0;
	for(int i=0; i<10; i++)
	{
	    total += s[i];
	}
	cout<<"total:"<<total<<endl;
	p = (float) total/number;
	cout<<"平均值为:"<<p<<endl;
    return 0;
}*/

//9 免子的繁殖问题
/*
#include <iostream>
using namespace std;
int main()
{
	//int i=1;
	int s[13]={1,1};
	for(int j=2; j<=12; j++)
	{
		s[j] = s[j-1] + s[j-2];
		cout<<"第"<<j<<"月兔子的对组为:"<<s[j]<<endl;
	    //cout<<s[j]<<endl;
	}
    return 0;
}*/

// 10 数字排序问题
/*
#include <iostream>
using namespace std;
int main()
{
	int s[6] ={1,34,78,98,32,45};
	int t;
	int lenght = 6;
	for(int i=0; i<lenght - 1; i++)
	{
		cout<<i<<endl;
		for(int j=0; j < lenght - 1 -i; j++)
		{
			cout<<"j"<<j<<endl;
            t = s[j];
			//cout<<"t"<<t<<endl;
			if(s[j] > s[j+1])
			{
				s[j] = s[j+1];
			    s[j+1] = t;
			}
		}
		cout<<endl<<"========"<<endl;
	}
	cout<<"排序好以后"<<endl;
	for(int i=0; i<6; i++)
	{
		cout<<s[i]<<endl;
	}
    return 0;
}*/

　　

// 数组在内存中的分布
/////////////////////////////////////////////////////
///数组在内存中的分布
/*数组元素就象排好队的士兵，他们在内存中也都是按照编号顺序排放的
比如说我们定义了一个由10个元素组成的整型数组a[10]，那么它们在内存中礅放就会如下所示

a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[7] a[8] a[9]

从上图中我们可以看出，每个整型元素都占用一个4字节的内存空羊，并且是按顺序依次排放的，第一个元素的下标(编号)是从0开始，
那么假如我们要给数组中的某个元素赋值，比如说a[8],编译器会怎么做呢?
编译器会首先根据每个元素的大小(类型)和编号(下标来计算该值存放在哪里),
a[8]是第9个元素，编译器自动把偏移量(双叫下标或编号)8与元素的大小(整型为4个字节)相乖，得出结果为32,
那么结果为32,那么它就从数组开头移动32个字节，并且把值写在移动后的位置内
同理，假如你要为a[10]赋值，那么对器该怎么做呢，我们知道数组元素是从0开始的编号的，因此a[10]实际上是不存在的，但是编译器却不管那么多
它照样算出从第一个元素起所要移动的字节数(40),然后不管该位置放的什么组据它均要写入，这简直就是一声灾难
因为这样的错误常常不会被你所发现，它很有可能只是修改了一个程序中不常使用数据
而该数据所引发的错误却会让你的程序彻底崩溃
为了引用读者的重视，我们用一个实例来说明一下:*/
/*
#include <iostream>
using namespace std;
int main()
{
    int a[2];
	int b[10]; //需要也越界了，可能内存不在一块，并没有站用a[0]的位置
	
	b[10] = 99;
	cout<<b[10]<<endl;
	cout<<a[0]<<endl;
	return 0;

}*/

//数组名
/*
#include <iostream>
using namespace std;
int main()
{
	int a[] ={1,2,3,4};
	cout<<a<<endl;
    return 0;
}*/

//13 数组名与函数
/*
#include <iostream>
using namespace std;
void a(int[]); //函数的原型,数组并没有副本一说，传递的都是原型

void b( int *p ); //按地址传递 
int main()
{
	int x[20];
	a(x);
	
	cout<<"a[0]:"<<x[0]<<endl;
	b(x);
	cout<<"a[1]:"<<x[1]<<endl;
    return 0;
}
void a(int a[])
{
	a[0] = 22; //无副本
	cout<<"a[0]:"<<a[0]<<endl;
}

void b(int *p)
{
    p[1] =33;
	cout<<"p[1]:"<<p[1]<<endl;
}*/

//数组因为通常都比较大，所以为了节省内存，C++规定数组在程序中只能有一个原本，由于这个原因，数组在函数中是不可能再创造一个副本的
//那么数组该如何传递值给函数呢?
//从上一节课，我们知道在C++中声明数组中，系统会自动生成一个指向该数组的指针，而该指针通常指向数组第一个元素的内存地址
//因此数组虽然不能将数值传递给函数，但是却能够将内存地址传递给函数，如下图


// 14 传递与接收
/*
#include <iostream>
using namespace std;
int func(int x[])
{
    x[0] = 100;
	return x[0];
}

int func2(int x[22])
{
    x[0] = 100;
	return x[0];
}

int func3(int *x)
{
    x[0] = 100;
	return x[0];
}
int main()
{
	int x[22];
	cout<<"修改后的成绩为:"<<func(x)<<endl;
	
	cout<<"修改后的成绩为:"<<func2(x)<<endl;

	cout<<"修改后的成绩为:"<<func3(x)<<endl;

    return 0;
}*/

// 15 将数组传递给函数
/*
我们用一个计算100到199间所有数的平均值的程序，来演示一下数组如何时在函数中传参
写出该程序不可避免的要用到数组和函数，并且要将数组作为参数传递给函数，前面的课程中我们了解到数组因为通常都比较大
所以为了节省内存，C++规定数组在程序中只能有一个原本，基于这个原因，数组在函数中是不可能再创造一个副本的
因此我们传给函数的数组都是该数组第一个元素的地址，即数组名，这就是我们常说的按地址传递
我们来对比一下按值传递与按址传递数组的区别
按值传递要将整个数组复制一份存放在栈中，然后在函数中接收该数组的拷贝，因此缺点是费内存比较大，优点则是在函数中修改数组的元素不会影响到原始数组
但是为了节省仙存,C++规定数组在程序中只能有一个原本，这样我们就无法实现这种传递方式了，按地址传递了值传递方满期的缺点，在地址传递方法中，传递给函数是指向初始数组中的指针，不用复制数组
因此程序变得简单练，也节省了栈中的内存空间，在地址传递过程中，只需在函数原形中将函数的参数说明为数组，第一个元素的内存地址，即数组名，我们通常都是使用这种方法
*/
/*
#include <iostream>
using namespace std;

float Average(int *, int);

int main()
{
	int a[100];
	float average;
	int num = 100;
	int i;
	for(i=0; i<100; i++, num++)
	{
	     a[i] = num;
	}
	average = Average(a, 100);
	cout<<"100到199的平均值为:"<<average<<endl;
	return 0;
}


float Average(int *p, int total)
{
    
	float b;
	int i;
	int num=0;
	for(i=0; i<total; i++)
	{
	    num += p[i];
	}
	b = (float)num/total;
	return b;
}*/

// 16 求数组所有元素的和
/*
#include <iostream>
using namespace std;
float num(int[], int);
int main()
{
	int a[] = {22,44,55,99,44,77};
	int total = sizeof(a) / sizeof(int);
	cout<<"总数为:"<<num(a,total)<<endl;
    return 0;
}

float num(int s[], int num)
{
    int a=0;
	for(int i=0; i<num; i++)
	{
	    a += s[i];
	}
	return (float)a;
}*/

// 17 用递增法查找数据
//用递增法查找数据
//我们知道数组元素在内存中是按编号依次排列的，困此只要知道了每一个元素的内存地址，那么要获取其它
//元素的地址只需要在第一个元素的内存地址上进行加减操作就可以
/*
#include <iostream>
using namespace std;
int find(int, int[], int);
int main()
{
	int a[]={44,22,11,33,45,66,88,99};
	cout<<"请输入你要查询的值:"<<endl;
	int s;
	cin>>s;
	int check = find(s,a,8); 
	if(check == 8)
	{
	   cout<<"没有查找到数据"<<endl;
	}else{
	   cout<<"查找到的索引值为:"<<check<<endl;
	   cout<<"查找到的位置为:"<<check+1<<endl;
	}
	
	//int f = find();
    return 0;
}
int find(int a, int p[], int total)
{
	for(int i=0; i<total; i++)
	{
		if(p[i] == a){
		    return i;
		}
	}
	return total;
}*/



// 18用二分法来查找数据
/*
#include <iostream>
using namespace std;
int find(int, int[], int);
int main()
{
	int a[]={1,32,55,67,68,70,71,73,82,101,198,200,201};
	int f = find(44,a,13);
	if(f == -1){
	   std::cout<<"没有查找到相应的数据"<<endl;
	}else
	   std::cout<<"查找到的数据为:"<<f+1<<endl;

    return 0;
}
int find(int a, int b[] , int c)
{
	//o为开始位置, h为长度, i为当前位置
	int o=0, h = c-1, i;
	while(o <= h)
	{
	    i = (o + h) / 2;
		cout<<"i:"<<i<<endl;
		if(b[i] == a)
		{
		    return i;
		}
		//向下查找
		if(b[i] < a)
		{
		     o = i + 1; 
		}else{ //向上找查
			 h = i - 1;
		}
	}
	return -1;
}*/

//二分算法在排好序的数组中比递增算法再快速的多，因为假如要对100个数进行查找，递增要进行循环100次
//而二分则保需要100为底的2的对数再加1,2的7次方是128,因此最多只需要8次

//假如还不明白的话，可以想象一下二分算法是将100个数一分为三，（假定这100这数在数组中顺序是从小到大）
/*然后将我们将要查的数据与中间的元素相比较，假如我们的数据小于中间元素
则将查找目标缩定到该数组的前半部分去查找，查找之前先将前半部分一分为二，然后再进行比较
查询数据比中间元素大则将目标锁定后半部分再二分，比它小则锁定到前半部分再二分，认法类推
二分算法的缺点也是显示而易风的，假如该数组中有两个或两个以上相同的元素，即两个或两个以上相同的数字
那么二分算法将不能确定该返回哪些个值，另外二分算法要求数组必须是排列有序的，否则将会返回回一个错误的值
*/


// 判断数组是否按照顺序排列
/*
#include <iostream>
using namespace std;
bool find(int[]);
int main()
{
	int a[] = {2,3,9,22,88};
	cout<<find(a)<<endl;

    return 0;
}

bool find(int a[])
{
	int s = sizeof(a) / sizeof(int);

	for(int i=0; i<s-1; i++)
	{
		if(a[i] > a[i+1])
		{
		    return false;
		}
	}
	return true;
}*/

// 20 判断数组排列方式然后执行不同的函数
/*
#include <iostream>
using namespace std;

bool isResort(int[], int); //判断是否为按顺序排列

int find2(int a[], int, int); //用递增法查找数据

int find(int a[], int, int); //用二分法查找数据



int main()
{
	int a[] = {2,3,9,44,22,88};
	int total = sizeof(a) / sizeof(int);
	//cout<<"total:"<<total<<endl;
	int s=-1;
	cout<<isResort(a, total)<<endl;
	if(isResort(a, total) == 1){
	    s = find(a, 44, total);
	}else{
	    s = find2(a,44, total);
	}
	if(s == -1){
	   cout<<"没有查找到数据位置"<<endl;
	}else
	   cout<<"查找到的位置为:"<<s<<endl;

    return 0;
}

int find(int a[], int b, int total)
{
    //int total = sizeof(a) / sizeof(int); 明白了，这里并不能得到数据长度，因为这里的数组只是一个数据首参数的地址
	int o=0, h = total - 1, i;
	while(o<= h)
	{
	    i = (o + h) / 2;
		if(a[i] == b){
		   return i;
		}
		if(a[i] < b){
		    o = i + 1;
		}else{
		    h = i - 1;
		}
	}
	return -1;
}

int find2(int a[], int f, int total)
{
	//int total = sizeof(a) / sizeof(int); 明白了，这里并不能得到数据长度，因为这里的数组只是一个数据首参数的地址
	for(int i=0; i<total; i++)
	{
		if(a[i] == f)
		    return i;
	}
	return -1;
}


bool isResort(int a[], int total)
{
	//int total = sizeof(a) / sizeof(int); 明白了，这里并不能得到数据长度，因为这里的数组只是一个数据首参数的地址
	//cout<<"total:"<<total<<endl;
	for(int i=0; i<total-1; i++)
	{
		if(a[i] > a[i-1]){
		   return false;
		}
	}
	return true;
}*/

//22 数组在对像中传参
/*
#include <iostream>
using namespace std;

class base
{
public:
	bool isResort(int[], int); //判断是否为按顺序排列
	int find2(int a[], int, int); //用递增法查找数据
	int find(int a[], int, int); //用二分法查找数据
};




int main()
{
	int a[] = {2,3,9,44,22,88};
	int total = sizeof(a) / sizeof(int);
	base s;
	int ss=-1;
	if(s.isResort(a, total) == 1){
	    ss = s.find(a, 44, total);
	}else{
	    ss = s.find2(a,44, total);
	}
	if(ss == -1){
	   cout<<"没有查找到数据位置"<<endl;
	}else
	   cout<<"查找到的位置为:"<<ss<<endl;

    return 0;
}

int base::find(int a[], int b, int total)
{
    //int total = sizeof(a) / sizeof(int); 明白了，这里并不能得到数据长度，因为这里的数组只是一个数据首参数的地址
	int o=0, h = total - 1, i;
	while(o<= h)
	{
	    i = (o + h) / 2;
		if(a[i] == b){
		   return i;
		}
		if(a[i] < b){
		    o = i + 1;
		}else{
		    h = i - 1;
		}
	}
	return -1;
}

int base::find2(int a[], int f, int total)
{
	//int total = sizeof(a) / sizeof(int); 明白了，这里并不能得到数据长度，因为这里的数组只是一个数据首参数的地址
	for(int i=0; i<total; i++)
	{
		if(a[i] == f)
		    return i;
	}
	return -1;
}


bool base::isResort(int a[], int total)
{
	for(int i=0; i<total-1; i++)
	{
		if(a[i] > a[i-1]){
		   return false;
		}
	}
	return true;
}
*/

　　

// 22 数组对像
/*
#include <iostream>
using namespace std;

class Get
{
public:
	int a[5];
};

int main()
{
	Get one[5];
	for(int i=0; i<5; i++)
	{
		//one[i].a[i] = i*i;
		cout<<"请输入第"<<i<<"个对像的值:";
		cin>>one[i].a[i];
	}

	for(int i=0; i<5; i++)
	{
       cout<<"输入的第"<<i<<"个对像的值:";
	   cout<<one[i].a[i];
	}

	return 0;
}*/

// 23 在数组对像中初始化成员变量
/*
上一节是在循环语句里对每一个数组对象的成员变量进行赋值，另外我们也可以直接在声明数组对象的时候初始化它的成员变量
area one[4] = {area(10,10),area(13,34),area(13,23),area(15,44)};
赋值符=在左边是声明的数组对象名以及长度，右边就是初始化的变量，与数组长度相符，也是初始化了四个对象的成员变量，每个成员变量用逗号隔开。
细心的读者会发现每个成员变量前面都有个area,它的作用是调用类中的构造函数来初始化成员变量，由于系统默认的构造函数只有一个默认参数，不能创建带有两个参数数组对象，因此我们要在类中再声明一个构造函数
area(int l, int w){length=l, width=w}
该行语句声明了一个带有两个参数的构造函数，并将这两个参数的值赋给length和width
我们用一个计算面积的小程序来演示一下如何在数组对象中初始化成员变量
*/
//类对象数组的初始化与默认构造函数的关系
//在前面已经说过，不带参数或者所有参数都有默认值的构造函数叫做默认构造函数，如果类中没有构造函数，
//编译器会自动提供一个什么都不做的公共默认构造函数，而这个默认构造函数对于我们这个带有两个参数的类数组对象的初始化毫无作用
//我们需要重新声明一个带有两个参数的构造函数，并且在声明的时候，我们要记住，如果你创建了一个构造函数，那么编译器就不会提供默认构造函数
/*
#include <iostream>
using namespace std;
class area
{
public:
	area(int w, int h):width(w),height(h){ cout<<"调用构造函数设置长宽值, 长:"<<width<<" 宽:"<<height<<endl; };
	void get(){ cout<<"面积为:"<<width*height<<endl; }
	~area(){cout<<"析构函数执行, 长:"<<width<<" 宽:"<<height<<endl;;}
	void set(int w, int h){ width=w; height=h;};

private:
	int width;
	int height;

};
int main()
{
	area a[4] = {area(11,22),area(22,33),area(33,44),area(44,55)};
	a[0].get();
	a[0].set(1,2);
	a[0].get();

    return 0;
}*/

// 24 指针数组
//指针数组
//通常的情况下，我们都明白我们的程序需要几个对象来实现，因此当我们声明一个数组对象并确定对象数量的时候，
//编译器会根据我们声明的对象数量来留出空间，但是有的进修我们也不能精确地判断程序需要使用几个对象，那么我们就需要更高级的数据构造了，在讨论数据结构之前，我们先来理解几个

/*
#include <iostream>
using namespace std;
class area
{
public:
	area(int w=0, int h=0):width(w),height(h){ cout<<"调用构造函数设置长宽值, 长:"<<width<<" 宽:"<<height<<endl; };
	void get(){ cout<<"面积为:"<<width*height<<endl; }
	~area(){cout<<"析构函数执行, 长:"<<width<<" 宽:"<<height<<endl;;}
	void set(int w, int h){ width=w; height=h;};

private:
	int width;
	int height;

};
int main()
{
	//area *one[100]; //声明一个area的one数组指针
	//将area[100] 数组对像的地址赋值给一个area的指针
	area *one = new area[100]; //将该数组的每一个对像的地址赋值给one指针

	for(int i=0; i<100; i++){
		//area *one = new area(11,i*10);
		one[i].set(11,i*10);
		//= new area(11,i*10);
		//cout<<"area["<<i<<"]:";
		//one->get();
		//delete one;
	}
	//one[0].get();
	//one[1].get();
	one->get();
	(one+1)->get();



	//for(int i=0; i<100; i++){
		 //delete(one[i]);
	//}
	//delete []one;

	delete []one; //删除整个数组

    return 0;
}
*/
	/*
数组对象在堆中占用多兴内存
我们知道一个对象在堆中所占用的仙存是根据它所拥有的变量来定义的，假如一个对象拥有4个占4字节的长整型变量和2个占1字节的字符变量，那么该对象则占用18个字节的内存空间，同理，假如一个数组中拥有20个这样的对象，那么该数组对象则占用20乖以18等于360个字节的内存空间
指针在内存中的访问也是根据这个原理，pone是指向one[0]的地址，假设one[0]占用20个字节，那么pone+5就是访问第6个对象
也就是one[5]的地址，我们几乎不费脑筋就可以推算出，one[5]的地址为数组首地址开始的第100个字节，因为单个对象占用内存乖以编号5等于100
*/

// 26 容易混淆的概念

//////////////////////////////////////
//容易混淆的概念
/*
我们来看下面三种声明方式
area one[100]
area *one[100]
area *one=new area[100]
第一种方式是声明了一个由100个area对象组成的数组，数组名叫one
第二种方式声明了一个由100个指向area的指针组成的数组，数组名为one
第三种方式是声明一个指针one,该针指向由100个area对象组成的一个数组
在这里要注意的是：第三种方式的one是一个指向数组的指针，也就是说one保存的是数组第一个元素的地址
*/

// 枚举常量与数组
/*
#include <iostream>
using namespace std;
int main()
{
	enum day{mon, tue, wen, thu, fir, sat, sun}; //sun的值为六
	double tem[sun+1]={33.4,55,35,28.7,88.3,44.2,55.7};
	int day;
	for(day=mon; day <= sun; day ++){
	    cout<<"星期:"<<day+1<<"的最高温度:"<<tem[day]<<"度"<<endl;
	}
    return 0;
}*/

// 多维数组
/*
#include <iostream>
using namespace std;
int main()
{
	int a[3][5]={1,2,3,4,5,6,7,8,9,10,11,12,13,14,15}; //第一种声明方法
	int b[3][5]={{1,2,3,4,5},{6,7,8,9,10},{11,12,13,14,15}}; //第二声明方法

	for(int i=0; i<3; i++)
	{
		for(int j=0; j<5; j++){
		   cout<<"b["<<i<<"]["<<j<<"]:"<<b[i][j]<<endl;
		}
	}


	return 0;

}
*/

// 30 定义字符数组
/*
#include <iostream>
using namespace std;
int main()
{
	//char s[10]={'x','i','d','s','r','v','e','e','g','e'};

	char s[]={'x','i','d','s','r','v','e','e','g','e','\0'};
	
	cout<<s[0]<<endl;
	cout<<s<<endl;

    return 0;
}*/

// 二维数组输出图形
/*
#include <iostream>
using namespace std;
void main()
{
	char a[5][5] = {{' ',' ','*',' ',' '},{' ','*','*','*',' '},
	{'*','*','*','*','*'},{' ','*','*','*',' '},{' ',' ','*',' ',' '}};
	for(int i=0; i<5; i++)
	{
		for(int j=0; j<5; j++){
		   cout<<a[i][j];
		}
		cout<<endl;
	}
}*/

//字符串数组
/*
#include <iostream>
using namespace std;
int main()
{
	char ch[12] = {"hello world"};
	cout<<ch<<endl;
   return 0;
}*/

//字符串的输入问题
/*
#include <iostream>
using namespace std;
void main()
{
     char a[12];
	 cout<<"请输入11个或者11以内的字符:";
	 //gets(a);
	 cin.get(a,12);
	 cout<<"您输入的字符串是:"<<a<<endl;
}*/

// strcat 函数 链接两个字符串的函数，将链接后的字符串保存到第一个字符
/*
#include <iostream>
using namespace std;
int main()
{
	char a[20] = "My name is";
	char b[] = "Xlc";
	strcat(a,b);
	cout<<a<<endl;
    return 0;
}*/

// strcpy 函数 将b拷贝到a中去，
/*
#include <iostream>
using namespace std;
int main()
{
	char a[20] = "My name is";
	char b[] = "Xlc";
	//cout<<strcpy(a,b)<<endl;
	cout<<strcpy(a,"StrCpy")<<endl;
	cout<<a<<endl;

    return 0;
}*/

// strcmp
/*
#include <iostream>
using namespace std;
int main()
{
	char a[20] = "Xlc";
	char b[] = "Xlc";
	int s = strcmp(a,b); //相等时返回0
	cout<<"s:"<<s<<endl;
	if(s == 0){
	   cout<<"他们是相等的!";
	}

    return 0;
}*/

//strups
/*
#include <iostream>
using namespace std;
int main()
{
	//char a[20] = " xiang ling chuan";
	//cout<<strupr(a)<<endl;
	
	
	//char a[20] = " XIANG";
	//cout<<strlwr(a)<<endl;

	char a[20] = " XIANG";
	cout<<strlen(a)<<endl;
    return 0;
}*/

// 40 打印杨辉三角行
/*
#include <iostream>
using namespace std;
int main()
{
	const int n = 10;
	int a[n][n];
	int j, i;
	for(i=0; i<n; i++)
	{
		for(j=0; j<=i; j++){
			if(j==0 || j==i){ //毎一行的第一个无素和最后一个元素设置为0
			   a[i][j] = 1;
			}else{
			   a[i][j] = a[i-1][j-1] + a[i-1][j];
			}
			cout<<a[i][j]<<"\t";
		}
		cout<<endl;
	}
    return 0;
}*/

// 41 重载数组下标操作符
#include <iostream>
using namespace std;
class A
{
public:
	A(int l):length(l){ size = new char[length]; } //定久一个字符长度的指针保存到size
	~A(){ delete []size; } //删除整个数组，记得在前面加上[]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()
{
	A a(6);
	
	char *ch = "hello12";
	for(int i=0; i<=7; i++){
	    a[i] = ch[i];
	}
	cout<<a.GetLength()<<endl;

	for(int j=0; j<=7; j++)
	{
	    cout<<a[j]; //调用对像a的重载运算符函数
	}
	cout<<endl;
    return 0;
}