目前Pproject 遇到一些问题，是把所有点的xyz坐标，用循环的方式读取，形成一个二维数组，然后将该二维数组转化为一维数组。运算中的矩阵是三行N列的，第一行是所有点的X坐标，第二行是所有点的Y坐标，第三行是所有点的Z坐标。
在这里先补充一点指针的知识：
二维数组和指针⑴
用指针表示二维数组元素。要用指针处理二维数组，首先要解决从存储的角度对二维数组的认识问题。我们知道，一个二维数组在计算机中存储时，是按照先行后列的顺序依次存储的，当把每一行看作一个整体，即视为一个大的数组元素时，这个存储的二维数组也就变成了一个一维数组了。而每个大数组元素对应二维数组的一行，我们就称之为行数组元素，显然每个行数组元素都是一个一维数组。
下面我们讨论指针和二维数组元素的对应关系，清楚了二者之间的关系，就能用指针处理二维数组了。
设p是指向二维数组a[m][n]的指针变量，则有：int* p=a[0]; 此时P是指向一维数组的指针。P++后，p指向 a[0][1]。如果定义int (*p1)[n];p1=a;p1++后，p1指向a[1][0];
则p+j将指向a[0]数组中的元素a[0][j]。由于a[0]、a[1]┅a[M-1]等各个行数组依次连续存储，则对于a数组中的任一元素a[i][j]，指针的一般形式如下：p+iN+j 相应的如果用p1来表示，则为(p1+i)+j
元素a[i][j]相应的指针表示为：( p+iN+j) 相应的如果用p1来表示，则为*((p1+i)+j)
同样，a[i][j]也可使用指针下标法表示，如下：p [i**N+j]
例如，有如下定义：
int a[3][4]={{10,20,30,40,},{50,60,70,80},{90,91,92,93}};则数组a有3个元素，分别为a[0]、a[1]、a[2]。而每个元素都是一个一维数组，各包含4个元素，如a[1]的4个元素是a[1][0]、a[1][1]、a[1]2]、a[1][3]。
若有：int p=a[0];则数组a的元素a[1][2]对应的指针为：p+14+2,元素a[1][2]也就可以表示为：( p+14+2), 用下标表示法，a[1][2]表示为：p[14+2]
特别说明：
对上述二维数组a，虽然a[0]、a都是数组首地址，但二者指向的对象不同，a[0]是一维数组的名字，它指向的是a[0]数组的首元素，对其进行“”运算，得到的是一个数组元素值，即a[0]数组首元素值，因此，a[0]与a[0][0]是同一个值；而a是一个二维数组的名字，它指向的是它所属元素的首元素，它的每一个元素都是一个行数组，因此，它的指针移动单位是“行”，所以a+i指向的是第i个行数组，即指向a[i]。对a进行“”运算，得到的是一维数组a[0]的首地址，即a与a[0]是同一个值。当用int p;定义指针p时，p的指向是一个int型数据，而不是一个地址，因此，用a[0]对p赋值是正确的，而用a对p赋值是错误的。这一点请读者务必注意。
⑵ 用二维数组名作地址表示数组元素。
另外，由上述说明，我们还可以得到二维数组元素的一种表示方法：
对于二维数组a，其a[0]数组由a指向，a[1]数组则由a+1指向，a[2]数组由a+2指向，以此类推。因此，a与a[0]等价、(a+1)与a[1]等价、(a+2)与a[2]等价，┅，即对于a[i]数组，由*(a+i)指向。由此，对于数组元素a[i][j]，用数组名a的表示形式为：((a+i)+j)
指向该元素的指针为：
*(a+i)+j
数组名虽然是数组的地址，但它和指向数组的指针变量不完全相同。
第一，指针变量的值可以改变，即它可以随时指向不同的数组或同类型变量，而数组名自它定义时起就确定下来，不能通过赋值的方式使该数组名指向另外一个数组。
第二，数组名是指针，类型是指向元素类型的指针，但值是指针常量，声明数组时编译器会为声明所指定的元素数量保留内存空间。数组指针是指向数组的指针，声明指针变量时编译器只为指针本身保留内存空间。
指针数组与数组指针的区别
-指针数组 一个指针指向一个数组
-数组指针 一个数组里面全是指针
⑶ 行数组指针https://www.jianshu.com/p/038c842d0705
在上面的说明中我们已经知道，二维数组名是指向行的，它不能对如下说明的指针变量p直接赋值：
int a[3][4]={{10,11,12,13},{20,21,22,23},{30,31,32,33}},*p;
其原因就是p与a的对象性质不同，或者说二者不是同一级指针。C语言可以通过定义行数组指针的方法，使得一个指针变量与二维数组名具有相同的性质。行数组指针的定义方法如下：
数据类型 (*指针变量名)[二维数组列数]；
例如，对上述a数组，行数组指针定义如下：int (p)[4];它表示，数组p有4个int型元素，分别为(*p)[0]、(*p)[1]、(*p)[2]、(*p)[3] ，亦即p指向的是有4个int型元素的一维数组，即p为行指针
下面是关于new 操作的说明 ： 部分引自<<C++面向对象开发>>
1、new运算符返回的是一个指向所分配类型变量（对象）的指针。对所创建的变量或对象，都是通过该指针来间接操作的，而动态创建的对象本身没有名字。
2、一般定义变量和对象时要用标识符命名，称命名对象，而动态的称无名对象(请注意与栈区中的临时对象的区别，两者完全不同：生命期不同，操作方法不同，临时变量对程序员是透明的)。
3、堆区是不会在分配时做自动初始化的（包括清零），所以必须用初始化式(initializer)来显式初始化。new表达式的操作序列如下：从堆区分配对象，然后用括号中的值初始化该对象。
下面是从堆中申请数组
1、申请数组空间：
指针变量名=new 类型名[下标表达式];
注意：“下标表达式”不是常量表达式，即它的值不必在编译时确定，可以在运行时确定。这就是堆的一个非常显著的特点，有的时候程序员本身都不知道要申请能够多少内存的时候，堆就变的格外有用。
2、释放数组空间：
delete [ ]指向该数组的指针变量名;
注意：方括号非常重要的，如果delete语句中少了方括号，因编译器认为该指针是指向数组第一个元素的，会产生回收不彻底的问题（只回收了第一个元素所占空间），我们通常叫它“内存泄露”，加了方括号后就转化为指向数组的指针，回收整个数组。delete [ ]的方括号中不需要填数组元素数，系统自知。即使写了，编译器也忽略。<<Think in c++>>上说过以前的delete []方括号中是必须添加个数的，后来由于很容易出错，所以后来的版本就改进了这个缺陷。
下面是个例子，VC上编译通过
#include<iostream>
using namespace std;
//#include <iostream.h> //for VC
#include <string.h>
void main(){
int n;
char *p;
cout<<"请输入动态数组的元素个数"<<endl;
cin>>n; //n在运行时确定，可输入17
p=new char[n]; //申请17个字符（可装8个汉字和一个结束符）的内存空间strcpy(pc,“堆内存的动态分配”);//
cout<<p<<endl;
delete []p;//释放pc所指向的n个字符的内存空间return ; }
通过new建立的对象要调用构造函数，通过deletee删除对象要调用析构函数。
CGoods *pc;
pc=new CGoods; //分配堆空间，并构造一个无名对象
//的CGoods对象；
…….
delete pc; //先析构，然后将内存空间返回给堆；
堆对象的生命期并不依赖于建立它的作用域，所以除非程序结束，堆对象（无名对象）的生命期不会到期，并且需要显式地用delete语句析构堆对象，上面的堆对象在执行delete语句时，C++自动调用其析构函数。正因为构造函数可以有参数，所以new后面类（class）类型也可以有参数。这些参数即构造函数的参数。但对创建数组，则无参数，并只调用缺省的构造函数。见下例类说明：
class CGoods{
char Name[21];
int Amount;
float Price;
float Total_value;
public:
CGoods(){}; //缺省构造函数。因已有其他构造函数，系统不会再自动生成缺省构造，必须显式声明。 CGoods(char* name,int amount ,float price){
strcpy(Name,name);
Amount=amount;
Price=price;
Total_value=price*amount; }
……}；//类声明结束
下面是调用机制 ：
void main(){
int n;
CGoods *pc,*pc1,*pc2;
pc=new CGoods(“hello”，10，118000);//调用三参数构造函数
pc1=new CGoods(); //调用缺省构造函数
cout<<”输入商品类数组元素数”<<endl;
cin>>n;
pc2=new CGoods[n];//动态建立数组，不能初始化，调用n次缺省构造函数
……
delete pc;
delete pc1;
delete []pc2; }
（１）指针数组：一个数组里存放的都是同一个类型的指针，通常我们把他叫做指针数组。
比如 int * a[10];它里边放了１０个int * 型变量，由于它是一个数组，已经在栈区分配了１０个(int * )的空间，也就是３２位机上是４０个byte,每个空间都可以存放一个int型变量的地址，这个时候你可以为这个数组的每一个元素初始化，在，或者单独做个循环去初始化它。
例子： 但是我不建议达内的学生这么写，可能会造成歧义，不是好的风格，并且在VC中会报错，应该写成如下 ：
int * a[2]；
a[0]= new int[3];
a[1]=new int[3];
delete a[0];
delet a[1];
这样申请内存的风格感觉比较符合大家的习惯；由于是数组，所以就不可以delete a;编译会出警告.delete a[1];
注意这里 是一个数组，不能delete [] ;
（ ２ ） 数组指针 ： 一个指向一维或者多维数组的指针；
int * b=new int[10]; 指向一维数组的指针b ;
注意，这个时候释放空间一定要delete [] ,否则会造成内存泄露， b 就成为了空悬指针.
int (*b2)[10]=new int[10][10]; 注意，这里的b2指向了一个二维int型数组的首地址.
注意：在这里，b2等效于二维数组名，但没有指出其边界，即最高维的元素数量，但是它的最低维数的元素数量必须要指定！就像指向字符的指针，即等效一个字符串,不要把指向字符的指针说成指向字符串的指针。这与数组的嵌套定义相一致。
int(*b3) [30] [20]; //三级指针――>指向三维数组的指针；
int (b2) [20]; //二级指针；
b3=new int [1] [20] [30];
b2=new int [30] [20];
两个数组都是由600个整数组成，前者是只有一个元素的三维数组，每个元素为30行20列的二维数组，而另一个是有30个元素的二维数组，每个元素为20个元素的一维数组。
删除这两个动态数组可用下式：
delete [] b3; //删除（释放）三维数组；
delete [] b2; //删除（释放）二维数组；
再次重申：这里的b2的类型是int () ，这样表示一个指向二维数组的指针。
b3表示一个指向（指向二维数组的指针）的指针，也就是三级指针.
https://blog.csdn.net/bzhxuexi/article/details/12193339具体的细节请参考上述的博客链接
目前的难度在，如何一一读取这些点的三维坐标，然后将其存储成二维数组。
一个思路是，将该数组用数组指针的形式，行数组指针定义如下：
int (p)[4];它表示，数组p有4个int型元素，分别为(*p)[0]、(*p)[1]、(*p)[2]、(*p)[3] ，亦即p指向的是有4个int型元素的一维数组，即p为行指针,我想把每个点的X坐标，存成三行i列的数组。
即吧x[6] = {1,2,3,4,5,6} ,y[6] = {1,2,3,4,5,6},z[6] = {1,2,3,4,5,6};依次存放到 (*p)[4]里面。
来源：CSDN
作者：weixin_42470012
链接：https://blog.csdn.net/weixin_42470012/article/details/103535918