{C++善于利用指针与引用（4）}菜大学生C++笔记22

int a[5]; 定义了一个整型数组，共5个元素.a[0]…a[4]
a是数组名，常量。是数组的首地址。

int *p; 定义了一个整型指针，接收整型变量地址。加1走过一个整数

int *p[4] 定义了一个指针数组。P是常量，4个元素。每个元素都是一个指针变量。

char *s; 定义了一个字符指针。变量。

当字符指针未指向数组时，不允许修改部分内容。

char *s[3] 定义了一个字符指针数组。3个元素,s是常量。数组名。 S[0] s[1] s[2]每个元素都是一个指针变量

int (*p)[4] 定义了一个指针变量。与int *p;定义不同。
此处为一个行指针。 一步走过4个整数
int f(); 声明了一个函数，函数名为f
int *p(); 指针函数。 返回值为整型指针。
int (*p)() 函数指针。 用来指向函数的指针。用函数名给p赋值。
int **p 二级指针，指针的指针。

有关指针的数据类型
变量定义
类型
含义

int i;
int
定义整型变量i; i=5; cout<<i<<endl;

int *p;
int *
定义p为指向整型数据的指针变量
int i=5,*p=&i; cout<<*p<<endl;

int a[5]
int [5]
定义整型数组a,有5个元素

int *p[4]
int *[4]
定义指针数组，有4个元素，p[0],p[1],p[2],p[3].每个元素都是一个整型指针

char *s;
char *
字符指针，可存储一维字符数组的首地址。
字符指针如果不指向一个数组。是不可修改其指向的内容的。

char *s=”abc”;
cout<<s<<endl;
s=”1234”;//重新赋值
cout<<s<<endl;
//s[0]=’A’;//错

char s[10]=”abc”;
cout<<s<<endl;
//s=”1234”;//错
strcpy(s,”1234”);

char *s[3]
char *[3]
字符指针数组。有3个元素。s[0], s [1], s [2].每个元素都是一个字符指针。

#include < iostream>
using namespace std;
int main()
{
char *month[]={
“”,“January”,“February”,“March”,
“April”,“May”,“June”,“July”,“August”,
“September”,“October”,“November”,“December”};
int i;
for(i=1;i<=12;i++)
{
cout<<month[i]<<endl;
}
system(“pause”);
return 0;
}

int (p)[4]
int ()[4]
P为指向包含4个元素的一维数组的指针变量。当使用列为4的二维数组名作为实参时。形参处即是此种类型

#include
using namespace std;
void dispArr2(int x[][3],int n);
int main()
{
int a[2][3]={{1,2,3},{4,5,6}};
int (*p)[3];
p=a;//合法
int i,j;
for(i=0;i<2;i++)
{
for(j=0;j<3;j++)
{
cout<<p[i][j]<<" ";
}
cout<<endl;
}
dispArr2(a,2);
return 0;
}
//void dispArr2(int (*x)[3],int n)
void dispArr2(int x[][3],int n)

{
int i,j;
for(i=0;i<n;i++)
{
for(j=0;j<3;j++)
{
cout<<x[i][j]<<" ";
}
cout<<endl;
}
}

int f();
int ()
F为返回整型的函数

int *p();
int *()
P为返回整型指针的函数

#include
using namespace std;
int *max(int *p,int *q)
{
if(*p>*q)
return p;
else
return q;
}
int main()
{
int a=5,b=3;
int *p;
p=max(&a,&b);
cout<<*p<<endl;
system(“pause”);
return 0;
}

int (p)()
int ()()
P为指针变量，可指向返回值为整型，参数为空的函数。

int **p
int **
二级指针，当实参为指针数组时，形参为二级指针。

#include < iostream>
using namespace std;
int main()
{
int a=5,*p=&a,**q=&p,i;
cout<<a<<endl;
cout<<*p<<endl;
cout<<**q<<endl;
int x=10,y=20,z=30;
int *nums[3]={&x,&y,&z};
q=nums;
for(i=0;i<3;i++)
{
cout<<**q<<endl;
q++;
}
system(“pause”);
return 0;
}

#include
using namespace std;
void showmonths(char **m,int n)
{
int i;

for(i=1;i<=n;i++)
{
++m;
cout<<*m<<endl;
}
}
int main()
{
char *month[]={
“”,“January”,“February”,“March”,
“April”,“May”,“June”,“July”,“August”,
“September”,“October”,“November”,“December”};
showmonths(month,12);
system(“pause”);
return 0;
}

你能用几种方法解决下面的问题？
编写一个程序，输入月份，输出该月的英文名。
#include < iostream>
#include < cstring>
using namespace std;
int main()
{
int month;
cout<<“请输入月份？（1-12）”;
cin>>month;
switch(month)
{
case 1:
cout<<“January”<<endl;
break;
case 2:
cout<<“February”<<endl;
break;
case 3:
cout<<“March”<<endl;
break;
case 4:
cout<<“April”<<endl;
break;
case 5:
cout<<“May”<<endl;
break;
case 6:
cout<<“June”<<endl;
break;
case 7:
cout<<“July”<<endl;
break;
case 8:
cout<<“August”<<endl;
break;
case 9:
cout<<“September”<<endl;
break;
case 10:
cout<<“October”<<endl;
break;
case 11:
cout<<“November”<<endl;
break;
case 12:
cout<<“December”<<endl;
break;
default:
cout<<“Wrong!!!”<<endl;
break;
}
system(“pause”);
return 0;
}

#include
#include
using namespace std;
int main()
{
int month;
cout<<“请输入月份？（1-12）”;
cin>>month;
if(month= =1)
{
cout<<“January”<<endl;
break;
}
else if(month= =2)
{
cout<<“February”<<endl;
break;
}
else if(month= =3)
{
cout<<“March”<<endl;
break;
}
else if(month= =4)
{
cout<<“April”<<endl;
break;
}
else if(month= =5)
{
cout<<“May”<<endl;
break;
}
else if(month= =6)
{
cout<<“June”<<endl;
break;
}
else if(month= =7)
{
cout<<“July”<<endl;
break;
}
else if(month= =8)
{
cout<<“August”<<endl;
break;
}
else if(month= =9)
{
cout<<“September”<<endl;
break;
}
else if(month= =10)
{
cout<<“October”<<endl;
break;
}
else if(month= =11)
{
cout<<“November”<<endl;
break;
}
else if(month= =12)
{
cout<<“December”<<endl;
break;
}
else
{
cout<<“Wrong!!!”<<endl;
break;
}
system(“pause”);
return 0;
}

#include < iostream>
#include < string>
using namespace std;
int main()
{
string monthsEn[12]={“January”,“February”,“March”,
“April”,“May”,“June”,“July”,“August”,
“September”,“October”,“November”,“December”};
int month;
cout<<“请输入月份？（1-12）”;
cin>>month;
if(month>=1 && month<=12)
{
cout<<monthsEn[month-1]<<endl;
}
else
{
cout<<“输入错误！！”<<endl;
}
system(“pause”);
return 0;
}

#include < iostream>
using namespace std;
int main()
{
char monthsEn[][20]={“January”,“February”,“March”,
“April”,“May”,“June”,“July”,“August”,
“September”,“October”,“November”,“December”};
int month;
cout<<“请输入月份？（1-12）”;
cin>>month;
if(month>=1 && month<=12)
{
cout<<monthsEn[month-1]<<endl;
}
else
{
cout<<“输入错误！！”<<endl;
}
system(“pause”);
return 0;
}

#include < iostream>
using namespace std;
int main()
{
char *monthsEn[12]={“January”,“February”,“March”,
“April”,“May”,“June”,“July”,“August”,
“September”,“October”,“November”,“December”};
int month;
cout<<“请输入月份？（1-12）”;
cin>>month;
if(month>=1 && month<=12)
{
cout<<monthsEn[month-1]<<endl;
}
else
{
cout<<“输入错误！！”<<endl;
}
system(“pause”);
return 0;
}

第7章 用户自定义数据类型
7.1 结构体类型
1为什么需要用结构体类型(如何表达一个学生，教师)
系统提供的数据类型：int (long short unsigned) char float double bool string
学生有哪些属性：姓名（char[]）；性别(bool int char )；年龄(int )；身高(int float double )，体重(float double )，成绩(float double )，电话(字符数组)，学号 （int 字符数组）。

2 如何创建一个新类型？
struct Student//声明一个结构体类型Student
{
int num; //包括一个整型变量num
char name[20]; //包括一个字符数组name,可以容纳20个字符
char sex; //包括一个字符变量sex
int age; //包括一个整型变量age
float score; //包括一个单精度型变量
char addr[30]; //包括一个字符数组addr,可以容纳30个字符
};

声明一个结构体类型的一般形式为
struct 结构体类型名
{成员表};
结构体类型名用来作结构体类型的标志。

上面的声明中Student是结构体类型名。大括号内是该结构体中的全部成员(member)，由它们组成一个特定的结构体。上例中的num,name,sex,score等都是结构体中的成员。在声明一个结构体类型时必须对各成员都应进行类型声明，即
类型名 成员名;
每一个成员也称为结构体中的一个域(field)。成员表又称为域表。成员名定名规则与变量名相同。

3 一个结构体类型定义后占据内存吗？
定义类型，如果未用此类定义变量。不会占据内存。
类型不占内存，变量占内存
4 定义结构体类型变量的方法
先声明结构体类型再定义变量（最常用的方法）
struct Student//声明一个结构体类型Student
{
int num; //包括一个整型变量num
char name[20]; //包括一个字符数组name,可以容纳20个字符
char sex; //包括一个字符变量sex
int age; //包括一个整型变量age
float score; //包括一个单精度型变量
char addr[30]; //包括一个字符数组addr,可以容纳30个字符
};
struct Student student 1, student 2;
5 每个变量占据多大的内存空间？？
在定义了结构体变量后，系统会为之分配内存单元。例如student1和student2在内存中各占63个字节（4+20+1+4+4+30=63）实际上，在分配存储单元时，是以字(word)为单位的，一个字一般包括4个字节。因此student1和student2实际占64个字节。用sizeof(student1)可以测出到结构体变量student1的长度，它的值为64。
6 在声明类型的同时定义变量
例如:
struct Student//声明结构体类型Student
{ int num;
char name[20];
char sex;
int age;
float score;
char addr[30];
} student1,student2; //定义两个结构体类型Student的变量student1,student2
这种形式的定义的一般形式为
struct 结构体名
{
成员表
} 变量名表;
提倡先定义类型后定义变量的第(1)种方法。将声明结构体类型和定义结构体变量分开，便于不同的函数甚至不同的文件都能使用所声明的结构体类型。
7 成员也可以是一个结构体变量。
struct Date//声明一个结构体类型Date
{int month;
int day;
int year;
};
struct Student //声明一个结构体类型Student
{int num;
char name[20];
char sex;
int age;
Date birthday; //Date是结构体类型,birthday是Date类型的成员
char addr[30];
}student1,student2; //定义student1和student2为结构体类型Student的变量
8 结构体变量的初始化
struct Student
{int num;
char name[20];
char sex;
int age;
float score;
char addr[30];
}student1={10001,“Zhang Xin”,‘M’,19,90.5,“Shanghai”};//
也可以采取声明类型与定义变量分开的形式，在定义变量时进行初始化:
Student student2={10002，“Wang Li”,‘F’,20,98,“Beijing”};

9 结构体变量的使用：用一个变量给另一个赋值

10 如何引用结构体变量中的成员？ 使用(.)
#include< iostream>
using namespace std;
struct Date { //声明结构体类型Date
int month;
int day;
int year;
};
struct Student { //声明结构体类型Student
int num;
char name[20];
char sex;
Date birthday; //声明birthday为Date类型的成员
float score;
} student1,student2= {10002,“Wang Li”,‘f’,5,23,1992,89.5};
//定义Student 类型的变量student1,student2,并对student2初始化
int main()
{
student1=student2; //将student2各成员的值赋予student1的相应成员
cout<<student1.num<<endl; //输出student1中的num成员的值
cout<<student1.name<<endl; //输出student1中的name成员的值
cout<<student1.sex<<endl; //输出student1中的sex成员的值
cout<<student1.birthday.month<<‘/’<<student1.birthday.day<<‘/’
<<student1.birthday.year<<endl; //输出student1中的birthday各成员的值
cout<<student1.score<<endl;
system(“pause”);
return 0;
}

11 结构体数组
#include< iostream>
#include< string>
using namespace std;
struct Person
{ //声明结构体类型Person
char name[20];
int count;
};
int main()
{
Person leader[3]= {“Li”,0,“Zhang”,0,“Sun”,0};
//定义Person类型的数组,内容为3个候选人的姓名和当前的得票数
int i,j;
char leader_name[20]; //leader_name为投票人所选的人的姓名
for(i=0; i<10; i++)
{
cin>>leader_name; //先后输入10张票上所写的姓名
for(j=0; j<3; j++) //将票上姓名与3个候选人的姓名比较
if(strcmp(leader_name,leader[j].name)==0)leader[j].count++;
//如果与某一候选人的姓名相同,就给他加一票
}
cout<<endl;
for(i=0; i<3; i++)
{ //输出3个候选人的姓名与最后得票数
cout<<leader[i].name<<“:”<<leader[i].count<<endl;
}
system(“pause”);
return 0;
}

#include< iostream>
#include< string>
using namespace std;
struct person
{
string name;//成员name为字符串变量
int count;
} leader[3]= {“Li”,0,“Zhang”,0,“Sun”,0};
int main()
{
int i,j;
string leader_name; //leader_name为字符串变量
for(i=0; i<10; i++)
{
cin>>leader_name;
for(j=0; j<3; j++)
if(leader_name= =leader[j].name)leader[j].count++; //用"==“进行比较
}
cout<<endl;
for(i=0; i<3; i++)
{
cout<<leader[i].name<<”:"<<leader[i].count<<endl;
}
system(“pause”);
return 0;
}

12 结构体类型指针
如何通过结构体类型指针访问结构体类型变量及每个成员。
#include< iostream>
#include< string>
using namespace std;
int main()
{
struct Student { //声明结构体类型Student
int num;
string name;
char sex;
float score;
};
Student stu; //定义Student类型的变量stu
Student *p=&stu; //定义p为指向Student类型数据的指针变量并指向stu
stu.num=10301; //对stu中的成员赋值
stu.name=“Wang Fang”; //对string变量可以直接赋值
stu.sex=‘f’;
stu.score=89.5;
cout<<stu.num<<" “<<stu.name<<” “<<stu.sex<<” “<<stu.score<<endl;
cout<<(*p).num<<” “<<(*p).name<<” “<<(*p).sex<<” “<<(*p).score<<endl;
cout<num<<” “<name<<” “<sex<<” "<score<<endl;
system(“pause”);
return 0;
}

13 结构体类型指针的应用，让结构体变量手拉手。
#define NULL 0//此行可省略,因为在头文件iostream中已有此定义
#include< iostream>
using namespace std;
struct student {
int num;
float score;
struct student *next;
};
int main()
{
student a,b,c, *head, *p;
a.num=31001;
a.score=89.5; //对结点a的num和score成员赋值
b.num=31003;
b.score=90; //对结点b的num和score成员赋值
c. num=31007;
c.score=85; //对结点c的num和score成员赋值
head=&a; //将结点a的起始地址赋予头指针head
a.next=&b; //将结点b的起始地址赋予a结点的next成员
b.next=&c; //将结点c的起始地址赋予b结点的next成员
c.next=NULL; //结点的next成员不存放其他结点地址
p=head; //使p指针指向a结点
do {
cout<num<<" "<score<<endl; //输出p指向的结点的数据
p=p->next; //使p指向下一个结点
}
while(p!=NULL); //输出完c结点后p的值为NULL
system(“pause”);
return 0;
}

14 结构体类型数据作为函数参数
(1) 用结构体变量名作参数。

#include< iostream>
#include< string>
using namespace std;
struct Student { //声明结构体类型Student
int num;
string name;
float score[3];
};
int main()
{
void print(Student); //函数声明,形参类型为结构体Student
Student stu; //定义结构体变量
stu.num=12345; //以下5行对结构体变量各成员赋值
stu.name=“Li Fang”;
stu.score[0]=67.5;
stu.score[1]=89;
stu.score[2]=78.5;
print(stu); //调用print函数,输出stu各成员的值
system(“pause”);
return 0;
}
void print(Student stu)
{
cout<<stu.num<<" “<<stu.name<<” “<<stu.score[0]<<” "
<<stu.score[1]<<" "<<stu.score[2]<<endl;

}

(2) 用指向结构体变量的指针作实参，将结构体变量的地址传给形参。
#include< iostream>
#include< string>
using namespace std;
struct Student { //声明结构体类型Student
int num;
string name;
float score[3];
};
int main()
{
void print(Student*); //函数声明,形参类型为结构体Student
Student stu,*p=&stu; //定义结构体变量
stu.num=12345; //以下5行对结构体变量各成员赋值
stu.name=“Li Fang”;
stu.score[0]=67.5;
stu.score[1]=89;
stu.score[2]=78.5;
print(&stu); //调用print函数,输出stu各成员的值
print§;
system(“pause”);
return 0;
}
void print(Student *p)
{
cout<num<<" “<name<<” “<score[0]<<” "
<score[1]<<" "<score[2]<<endl;

}

(3) 用结构体变量的引用作函数形参，它就成为实参(是结构体变量)的别名。

#include< iostream>
#include< string>
using namespace std;
struct Student { //声明结构体类型Student
int num;
string name;
float score[3];
};
int main()
{
void print(Student &); //函数声明,形参类型为结构体Student
Student stu; //定义结构体变量
stu.num=12345; //以下5行对结构体变量各成员赋值
stu.name=“Li Fang”;
stu.score[0]=67.5;
stu.score[1]=89;
stu.score[2]=78.5;
print(stu); //调用print函数,输出stu各成员的值
system(“pause”);
return 0;
}
void print(Student &stu)
{
cout<<stu.num<<" “<<stu.name<<” “<<stu.score[0]<<” "
<<stu.score[1]<<" "<<stu.score[2]<<endl;

}