C++知识补充(结构体和指针)

结构体
1.结构体可以存储多种类型的数据
2、struct inflatable { char name[20]; float volume; double price; }
结构体名称inflatable，可以创建inflatable类型的变量
3、创建变量：

inflatable hat;

<C++允许在声明结构变量是省略关键字struct>

4.hat的类型是inflatable,可以用（.）来访问各个成员，hat.volume（是float类型）

5.结构初始化时等号可选则省去

inflatable duck={"anhsgyuhdijk",  2.01, 9.98};

{}内若不包含任何东西，成员都将被设置为0

inflatable mayor{};

6.可以将结构体作为参数传给函数
可以让函数返回一个结构
可以用（=）将结构赋给另一个同类型的结构

7.可以同时完成定义结构和创建结构变量的工作

struct perks
{
	int key;
	char car[12];
}mr_smith, ms_jones;

struct perks
{
	int key;
	char car[12];
}mr_gl=
{
	7;
	"Pahfiodsl"
};

还可以定义没有名称的结构类型，圣烈名称，同时定义一种结构类型和这种类型的变量：

struct 
{
	int key;
	char car[12];
}mr_gl

8.结构数组
创建元素为结构的数组
创建一个包含100个inflatable结构的数组：

inflatable gifts[100];

gifts是一个inflatable数组，其中每个元素都是inflatable对象
gifts[0].volume
gifts[50].volume
初始化数组：

inflatable gifts[2] = 
{
	{"fghj", 0.6, 45.22},
	{"tghnj", 2222, 456.55}
};

9.位字段
允许指定占用特定位数的结构成员
字段的类型应为整型或枚举，接着是冒号，然后是一个数字，制定了使用的位数。可使用没有名称的字段提供间距

struct ghj
{
	unsigned int SN : 4;
	unsigned int : 4;
	bool hhh :1;
};

//初始化
ghj kk={14, true}

指针
指针是一个变量，存储的是值的地址
对于常规变量，对变量应用&，就可得到其位置

将地址视为指定值，值视为派生量
指针名表示的是地址，*运算符为解除引用运算符，应用于指针，可得到该地址处存储的值

指针的声明必须指定指针指向的数据的类型

int *p_updates

//声明创建一个指针和一个int变量
int* p1, p2

<使用new分配内存>
指针的真正用途：在运行阶段分配未命名的内存以存储值
用new分配

int* pn = new int

new运算符根据类型来确定需要多少字节的内存，然后找到这样的内存，返回其地址
为一个数据对象获得并指定分配内存的格式：

typeName * pointer_name = new typeName

<delete释放内存>

int* ps =new int;
...
delete ps;

释放ps指向的内存，但不删除指针ps本身，可以将ps重新只想另一个新分配的内存块

<静态联编>
数组是在编译时加入到程序中，必须在编写程序时指定数组的长度
<动态联编>
数组再程序运行时创建的，程序在运行时确定数组长度

• 使用new创建动态数组

int* psome = new int [10]

创建包含10个int的数组，new返回第一个元素的地址

delete [] psome

释放整个数组
delete和指针之间的[]:如果使用new时带【】，则使用delete时也带【】

int* pt = new int;
short* ps = new short [500];
delete [] pt ;
delete ps;

• 使用动态数组
  第一个元素：psome[0], 第二个元素：psome[1]

psome = psome + 1

psome[0]现在指向psome[1],psome[1]指向psome[2]

//数组的值给指针的才种方法：
double wage[3] = {10000.0, 20000.0, 30000.0}
short stacks[3] = {3, 2, 1}
double* pw = wage;
short* ps =&stacks[0];

对数组应用sizeof得到的是数组的长度，对指针应用sizeof得到的是指针的长度，即使指针指向的是一个数组
数组名是第一个元素的地址，对数组名应用地址运算符时，得到的是整个数组的地址

short tell[10];
cout << tell <<endl;  //表示&tell[0]
cout << &tell <<endl;  //表示整个数组的地址

&tell[0]是一个2字节内存块的地址，&tell是一个20字节内存块的
tell+1将地址值加2
&tell+2将地址加20
tell是一个指针
&te’l’l指针，指向包含20个元素的short数组
short (*pas) [20] = &tell //声明指针
pas的类型为short（ * ）[20]

• 指针和字符串
  函数strlen()：返回字符串的长度
  函数strcpy(A,B）：将字符串从一个位置复制到另一个位置
  A:目标地址，B：要复制的字符串的地址
  函数strncpy(A,B,nu’m)：要复制的最大字节数
  如果给cout提供一个指针，将打印地址。如果指针类型为char*，则cout将显示指向的字符串。如果要显示的是字符串的地址，必须将指针强制转换为另一种指针类型(int*) ps

• 动态结构
  可以通过使用new来创建动态结构
  用new用于结构分为2步：创建结构、访问其成员

struct inflatable 
{
	char name[20];
	float volum;
	double price;
}
inflatable * ps = new inflatable;
inflatable pp = {'ccccccccccc', 89.0, 66.89}

访问结构成员：
1、->
ps->price
如果结构标识符是结构名，使用句点运算符pp.name
如果标识符是指向结构的指针，使用箭头运算符pp->volum
2、ps是指向结构的指针，*ps是被指向的值（结构本身），（*ps）.price

• 类型组合

struct an_years_end
{
	int year;
};
#创建数组指针
const an_years_end * arp = {&s01, &s02, &s03};
cout << arp[1]->year << endl;
#创建上述数组的指针
const an_years_end ** ppa = arp;

arp是一个数组的名称，是第一个元素的地址，ppa是一个指向an_years_end的指针
一般使用auto ppb = arp
ppa是一个指向结构指针的指针，所以*ppa是一个结构指针，（*ppa）->year
ppa指向arp的第一个元素，*ppa为第一个元素&s01，所以，（*ppa）->year为s01的成员

---

函数指针
think()是一个函数，think就是该函数的地址，将函数作为参数进行传递，就必须传递函数名
声明指向函数的指针，也必须指定指针指向的函数类型
double(*pf) (int);
（*pf）是函数，pf是函数指针
*pf (int) 表明pf()是一个返回指针的函数
（*pf）(int)表明pf是一个指向函数的指针

double pam(int);
double (*pf)(int);
pf = pam；
double x = pam(4);
double y = (*pf)（5）；

void estimate(int lines, double (*pf)(int) );
estimate(50, pam);

第二个参数是函数指针，指向的函数接受一个int参数，返回一个double值

const double * f1(const double ar[], int n);
const double * f2(const double [], int);
const double *f3(const double *, int);

函数原型中，const double ar[]与const double *ar含义完全相同
函数原型中，可省略标识符，const double ar[]可简化为const double[]
const double *ar可简化为const double *
声明一个指针
const double *(*p1) = （const double *, int)
auto p2 = f2
（*p1)(av, 3), p2(av, 3)都指向f1()、f2()
返回类型 const double *

const double *(*pa[3])(const double *, int) = {f1, f2, f3};

声明数组：pa[3]
*pa[3]表明pa是一个包含三个指针的数组