静态成员（static）

静态数据成员的生命周期是整个程序。
类的静态数据成员具有静态生存周期，为该类所有对象共享，必须在类外定义和初始化。
静态函数成员
静态函数成员用来处理静态数据，静态数据不属于任意一个对象，但是可以使用任意对象通过调用成员函数来访问静态数据，存在一个问题就是：如果在没有定义对象的前提下，想访问静态数据，则没有对象依托来调用数据访问函数。所以静态函数成员与普通函数成员不同，一般不是用来处理对象数据的，而专门处理属于整个类的静态数据。
静态函数成员可以通过类名+作用域分辨符或者对象调用访问静态数据。
静态成员函数不能直接访问对象的变量，要作为参数传入。
)

const

常成员函数可以被非常对象调用。
常数据成员必须被初始化，并且不能被更新，通过构造函数成员初始化列表进行初始化。

多文件结构和预编译命令

在这里插入图片描述

)
)

静态变量和静态函数即使使用extern关键字也只能在定义的文件中使用。

0722 第六章学习

指针相关

整数0是一个例外，可以把它赋值给指针，表示空指针。C语言使用null,C++11中使用nullptr更安全准确的表示空指针。
不能将非静态变量地址赋值给静态指针

函数指针：

函数指针即指向函数的指针，定义形式为：
存储类型数据类型 （*函数指针名）（）
【数据类型即指针指向函数返回值的类型】
eg:典型应用，函数回调，将函数指针作为一个函数的参数，通过传入不同功能的函数来处理多种相似的事件。

#include"stdafx.h"
#include<iostream>
using namespace std;
int multifun(int a, int b, int( *funp)(int pa,int pb))
{
	return(funp(a,b));
}
int max(int ma, int mb)
{
	return((ma>mb) ? ma : mb);
}
int sum(int sa, int sb)
{
	return(sa + sb);
}
int main()
{
	int n1, n2;
	int res1, res2;
	cout << "please input n1" << endl;
	cin >> n1;
	cout << "please input n2" << endl;
	cin >> n2;
	res1 = multifun(n1, n2, &max);
	res2 = multifun(n1, n2, &sum);
		cout << "res1=" << res1 << endl;
	cout << "res2=" << res2 << endl;
	return 0;
}

对象指针

定义：指向对象的指针。语法：类名 *对象指针名
对象成员访问： ptr->getx() 等同于(*ptr).getx();

指针函数

定义：如果函数的返回值是指针，则称该函数为指针类型的函数。
int *fun(){} 【int 代表返回指针所指向地址空间中的数据类型】

指针数组

定义：数组中的元素为指针类型，即指针数组。
3-1，典型应用：二维数组，指针即地址，数组名即地址，数组里面放地址等同于数组里面放数组，即二维数组。如下：

int main()
{
int l1[]={1,0,0};
int l2[]={0,1,0};
int l3[]={0,0,1};
int *ptr[]={l1,l2,l3};
for(int i=0;i<3;i++)
{
for(int j=0;j<3;j++)
cout<<ptr[i][j]<<" ";
cout<<endl;
}
return 0;
}

智能指针

内存动态分配相关

分配内存
动态内存申请操作符（运算符）： new
句法：new 类型明（参数表）
示例：

#include"Point.h"//假定已经定义Point类
int main()
{
Point *ptr1=new Point;
delete ptr1;  //释放的是指针内存空间，指针本身还存在，后续可以继续使用
ptr1=new Point(1,2);
delete ptr1;
return 0;
}

分配和释放动态数组

句法：new 类型名 [第1维长度][第2维长度]…；delete [] 数组名；
tip:数组长度可以是任意表达式，在运行时计算。

int main() {
	int(*cp)[9][8] = new int[7][9][8];
	for (int i = 0; i < 7; i++)
	for (int j = 0; j < 9; j++)
	for (int k = 0; k < 8; k++)
		*(*(*(cp + i) + j) + k) = (i * 100 + j * 10 + k);
	for (int i = 0; i < 7; i++) {
		for (int j = 0; j < 9; j++) {
			for (int k = 0; k < 8; k++)
				cout << cp[i][j][k] << " ";
			cout << endl;
		}
		cout << endl;
	}
	delete[] cp;
	return 0;

疑问

疑问1 ：关于数组指针：

#include"stdafx.h"
#include<iostream>
using namespace std;
int main()
{
	int (*ptrt)[3];
	int a[2][3] = { { 1, 2, 3 }, { 5, 6, 7 } };
	ptrt=a;
	cout << "out put of ptrt is:" << endl;
	for (int i = 0; i < 3; i++){
		for (int j = 0; j < 3; j++)
			cout << ptrt[i][j];
		cout << endl;
	}
	return 0;
}

上面代码：“（*ptrt）[3]” 改为“（*ptrt）[2]” 和 “ptrt[3]”就报错；按我的理解指针数组存储二维数组的行，所以两行因该没错啊,报错为无法从int[2][3]转化为int※[3]“和无法从int[2][3]转化为int（※）[2]”。
三维数组示例也是的，输出为7个9行8列的矩阵，按理说是79个行的地址呀，但是语法要求是多维数组，定义去掉第一维的数组指针。

疑问1理解：多为数组的指针定义时必须加括号，因为多维数组的指针指向的是每一行的首元素地址，指针加1就跳过列数指向下一行，因此指针后[ ]内的数值代表的是每一行共有几列元素，作为一个参数在指针加减操作时知道跳多远。

动态数组类

每次动态数组的建立需要使用运算符new和delete[]；且容易遗漏delete,目前认为动态数组类是对类特性及优势的运用：即将具有特性意义的数据和方法封装称模块形成用户自己的数据类型方便运用，就像点、线/圆形等。

思路：在类的数据成员中定义整型数组长度数据和存放动态分配地址的指针数据；使用构造函数初始化长度数据并分配动态内存空间。

码例（点动态点类数组）：

#include"stdafx.h"
#include<cassert>
#include "Point.h"
#include<iostream>
using namespace std;
class Arrayofpoint
{
private:
	int size;
	Point *points;
public:
	Arrayofpoint(){};
	Arrayofpoint(int s) :size(s)
	{
		points = new Point[size];
	}
	~Arrayofpoint()
	{
		delete[] points;
	}
	Point &viewelement(int index)
	{
		assert(index >= 0 && index < size);
			return points[index];
	}
};
int main()
{
	Arrayofpoint p(2);
	p.viewelement(0).move(2, 1);
	p.viewelement(1).move(3, 4);
	cout<<"The x of p[0] is: "<<p.viewelement(0).getx();
	cout << endl;
	cout << "The y of p[1] is: " << p.viewelement(1).gety();
	return 0;
}