Lecture 6 数组（中）

引用数组元素的方法

下标法：a[i]  p[i]    a为数组名，p为指针变量

指针法：*(p+i)  *(a+i)

注意：p++可以，a++不可以，因为p++后到下一单元，a相当于常变量，其类型为指针

用数组名代表数组首元素地址，数组名作函数参数，传递的是数组首元素地址

定义：int score[20]

      .void select_sort(int arr[ ],int n)    数组元素个数

调用：select_sort(score,100)

用指针变量做函数形参，也可以接受从实参传递来的数组首元素的地址

定义：void select_sort(int *p,int n)   指针指向的数组首地址

调用：select_sort(score,100)      数组名代表数组首元素地址

选择排序：由小到大排列数组

void select_sort(int *p,int n)

{

int i,j,k;

for(i=0;i<n;i++)

for(j=i+1;j<n;j++)

if(*(p+j)<*(p+i))

{

        k=*(p+i);

            *(p+i)=*(p+j);

*(p+j)=k;

}

}

int main()

{

int a[10],i;

for(i=0;i<10;i++)

cin>>a[i];

select_sort(a,10);

for(i=0;i<10;i++)

cout<<a[i];

return 0;

}

形参和实参可分别为数组和指针，有4种结合方式

实参的数组名a代表一个固定的地址，a的值不可改变

a++   错误

形参数组名是指针变量，并不是一个固定的地址值，值可以改变

.f(int arr[ ],int n)

{

cout<<arr<<endl;     输出arr，即数组的首地址

arr=arr+3;           指针变量arr的值改变，指向arr[3]

cout<<*arr<<endl;     输出arr[3]的值

}

指向指针的指针  **p

二维数组与指针

二维数组是”数组的数组”

int a[3][4]={{},{},{},{ }}

a是二维数组首元素的地址，a的值即第0行的起始地址&a[0]

a+1代表a[1]行的首地址，即&a[1]  跨越了a【0】行4个元素，每个元素4个字节，共16个字节(因为将a[i]看做是元素为一维数组的一维数组)

a[i]代表一维数组，a[i]的值是&a[i][0]，&a[0][1]用指针法表示为a[0]+1，元素的值为*(a[0]+1)

依此类推，a[i][j]的值为*(a[i]+j)或*(*(a+i)+j)

练习：

将二维数组看做是“数组的数组”，相当于“指向指针的指针”

a为二维数组的首地址，即1900H；

*a为一维数组a[0]的首地址，仍为1900H；

a+2为a[2]行的首地址，即1920H；

*a+2为a[0]的首地址向后两个单元的地址，即1908H；

*(a+1)+2为a[1]行的首地址向后两个单元的地址，即1918H；【*(a+1)也可以写为a[1]，即一维数组a[1]的首地址】

**a为a[0][0]的值，即1；

*(*a+9)为a[0]的首地址向后9个单元的值，即1924H地址中的值19；

(a+1)[1]中，将a+1看做b，则b[1]=*(b+1), b=a[1],a[1]+1=a[2], *(a[2])=1920H

可以通过指向数组元素的指针变量将二维数组变为一维数组输出，减少循环级数

指向数组元素的指针变量

int main()

{

int a[3][4]={1,3,5,7,9,11,13,15,17,19,21,23};

int *p;

for(p=a[0];p<a[0]+12;p++)   a[0]为元素为一维数组的一维数组，p=&a[0][0]

cout<<*p<<" ";

cout<<endl;

return 0;

}

不能将p=a[0]写成p=a，因为a是一个二维数组，地址是指向一维数组的指针，而不是指向一个整型值，指针p指向的却是整型值

指向一维数组的指针变量

int (*p)[4];   p是一个指针，指向具有4个元素的数组，数组元素是整型的

等价于int a[4]，定义变量a，是一个具有4个整型元素的数组

区别于 int *p[4]；  自右向左结合，p是一个数组，p有4个元素，每个元素是指向整型的指针，叫做指针数组

int main()

{

int a[3][4]={1,3,5,7,9,11,13,15,17,19,21,23};

int (*p)[4],i,j;   p是指向一维数组的指针

cin>>i>>j;

p=a;

cout<<*(*(p+i)+j); *(p+i)=a[i]的起始地址,a[i]首地址+j=a[i][j]的地址

cout<<endl;

return 0;

}

如果一个指针p指向整型值，则p可以看成一个整型数组（一维数组）

如果一个指针p指向一维数组，则p对应一个二维数组

用指向数组的指针作函数参数

定义：void output(int (*p)[4]);

调用：output(a);   a为二维数组，作为实际参数将值传给指针p，类型相匹配

指针数组：数组中的元素均为指针类型数据

指针数组中每一个元素相当于一个指针变量，它的值都是地址

定义：类型名 *数组名【数组长度】；

例：int *p[4];   p是变量，是具有4个元素的数组，每个元素是指向整型的指针

例：字符串排序

int main()

{

void sort(char *name[],int n);

   void print(char *name[],int n);

char *name[]={"basic","forturn","c++","pascall","cobal"};  指针数组，可直接当做二维数组

int n=5;

sort(name,n);

    print(name,n);

return 0;

}

void sort(char *name[],int n)

{ char *p;

  int i,j;

for(i=0;i<n-1;i++)

for(j=i+1;j<n;j++)

if(strcmp(name[i],name[j])>0)

{ p=name[i];

            name[i]=name[j];

name[j]=p;

        }      定义排序函数，改变指针指向

}

void print(char *name[],int n)

{ int i;

  for(i=0;i<n;i++)

  cout<<name[i]<<endl;   指向字符的指针，一维的字符数组即字符串

}    输出5个字符串

若改为cout<<*name[i]<<endl;    输出5个字符串的首地址

输出二维字符数组：

方法一：

void print1(char *name[],int n)

{ int i;

for(i=0;i<n;i++)

    cout<<name[i]<<endl;

}

方法二：

void print2(char *name[],int n)

{int i=0;

char *p;   p相当于一维数组

p=name[0];

while(i<n)

{p=*(name+i++);    先name+i，再i+1

cout<<p<<endl;

}

}

方法三：

void print3(char *name[],int n)

{int i=0;

char **p;       p相当于二维数组

p=name;

while(i<n)

{cout<<*p<<endl;

*p++;       先*p，再p+1

i++;

}

}

小尝结构体

stu  num  name  sex  age  score  addr

struct Student

{ int num;

  char name[20];

  char sex;

  int age;

  float score;

  char addr[30];

} stu1={10001,"zhang xin",'m',19,90.5,"shanghai"};  声明变量

Student stu2={10002,"wang li",'f',20,98,"beijing"};

应用拓展：数的存储

.struct Node

{ int data;

 .Node *next;

};

Node *header[11];     指针数组

........