今天在研究infomap的源码的是否，发现里面定义了个Node的指针数组：
Node **node = new Node*[Nnode]；
for(i=0;i<Nnode;i++){
node[i]=new Node(i);
degree[i]=0.0;
}对于Node **node = new Node*[Nnode]，这一句比较好理解，就是在内存中申请了一片空间用于存放Nnode个指针，大小为Nnode*8 （假设指针类型的长度为8字节）。但是下面for循环进行赋值的时候不太理解：node[i]=new Node(i);为什么会这么写呢？
new Node(i)不是得到一个Node的对象吗，怎么会是一个指针呢？
- new创建类对象需要指针接收，一处初始化，多处使用//new出来的其实是一个指针，而不是具体对象，和java有区别
- new创建类对象使用完需delete销毁
- new创建对象直接使用堆空间，而局部不用new定义类对象则使用栈空间
- new对象指针用途广泛，比如作为函数返回值、函数参数等
- 频繁调用场合并不适合new，就像new申请和释放内存一样
（1）使用new创建类对象：
CTest* pTest = new CTest();
delete pTest;
pTest用来接收类对象指针。
（2）不用new，直接使用类定义申明：
CTest mTest;
此种创建方式，创建之初就已经分配了内存空间，使用完后不需要手动释放，该类析构函数会自动执行。而new申请的对象，则只有调用到delete时再会执行析构函数，如果程序退出而没有执行delete则会造成内存泄漏。
（3）类指针可以先行定义，但类指针只是个通用指针，在new之前并为该类对象分配任何内存空间。
CTest* pTest = NULL;只是一个普通指针，没有经过new的操作分配具体空间，所以不用delete释放。
1. 我们先看看如何动态定义一个char类型(基本类型int/float/double)的数组
const int n ;
char *a = new char[n];new char[n] 表示在内存中(heap)分配了sizeof(char)*n字节的空间，并且返回一个指向所分配内存首地址的指针； 所以，在这里，定义了一个char类型的指针来指向这块内存空间。
2 在看看如何动态定义一个char类型(基本类型int/float/double)的指针数组
const int n ;
char **a = new char*[n];指针数组就是一个数组，只不过数组里面的元素是指针类型；而int类型的数组里面的元素是int类型。
new char*[n]也表示在内存中(heap)分配了sizeof(char)*n字节的空间，并且返回一个指向所分配内存首地址的指针，但是，
不同的是，这些内存里面放的是指针变量，即，存放的是地址。 因此，我们要定义一个二级指针来指向这块内存空间。详细理解，可以画出内存管理图.
PS:在涉及到指针时，多想想内存分布及管理，必要时，可画出，可帮助理解。
3 最后，如何动态定义一个 对象指针数组
#include <iostream>
using namespace std;
class A
{
private:
int i;
public:
A(int i)
{
this->i=i;
}
int getI(){
return i;
}
void setI(int k){
i=k;
}
};
int main()
{
int n=10;
A** a =new A*[n];
cout<<"a的地址："<<a<<endl;
cout<<"sizeof(A): "<<sizeof(A)<<endl;
for(int i=0; i<n; i++){
a[i] = new A(i);
cout<<"(*a["<<i<<"]).getI(): "<<(*a[i]).getI();//a[i]是指针，所以*a[i]代表A类的对象
cout<<", a["<<i<<"]->getI(): "<<a[i]->getI();//a[i]是指针，所以a[i]->getI()调用该指针对应的对象的函数
cout<<", &(*a["<<i<<"])"<<&(*a[i]);//A的对象所在的内存地址
cout<<", a["<<i<<"] :"<<a[i]<<", &a["<<i<<"] :"<<&a[i]<<endl;//指针a[i]的值（内容）以及存放（指向）指针a[i]的地址。
}
for(int i=0;i<n;i++){
delete a[i];
}
delete a;
return 0;
}
a[i] = new A(i); 的含义:new A()表示定义一个A 对象，并在heap中分配内存空间，并返回一个指向该内存的指针（new返回的是对指针）。 并用a[i]指向他。
以下图中a[5]为例，a[5]=new A(5);是两个步骤：new A(5)表示定义了一个A的对象（没名字,这一点很重要，这句话并不是说为a[5]分配一个存储空间，而是在heap内申请一片区域来保存A的一个对象，但是这个对象总得有个名字，或者handler吧，要不然你没法用啊），并在heap中给她分配了内存空间（从0x5fafd8开始到0x5fafe8的16个字节的空间），并返回一个指向该内存的指针a[5]，a[5]的内容写的是0x5fafd8，而a[5]自己所在的位置是0x5fb834，它在指针数组的第6个位置，也就是它距离指针数组a的起始位置0x5fb820为4*6=24个字节。
动态分配的内存（各个new A(i)）都存放在堆上，而指针放在栈上(各a[i])。 如果要写程序验证的话，你在方法内部new一个对象，然后把对象的引用（指针）返回给上层函数，如果在栈上，方法返回后对象会释放，如果在堆上不会被释放，而且你在方法内部给堆对象赋值都还有效（后面我们给出了一个例子）。
上面我们的示例代码中，(*a[i]).getI()和a[i]->getI()得到的值一样，又引出了另一个问题：C 语言结构体之点运算符( . )和箭头运算符( -> )的区别 ：
我们使用类的对象的时候，有时用点运算符( . )，时而是用箭头运算符( -> )；那么这两者之间的使用有什么区别么？
相同点：两者都是二元操作符，而且右边的操作数都是成员的名称（成员变量或者成员函数）。
不同点：点运算符( . )的左边操作数是一个结果为对象的表达式；
箭头运算符( -> )的左边的操作数是一个指向对象的指针。
继续聊堆和栈的问题：
class CTest
{
public:
int a;
};
class CBest
{
public:
int b;
};
CTest* fun(CBest* pBest)
{
CTest* pTest = new CTest();
pTest->a = pBest->b;
return pTest;
}
int main()
{
CBest* pBest = new CBest();
CTest* pRes= fun(pBest);
if(pBest!=NULL){
cout<<"pBest不为空"<<endl;
delete pBest;
}
if(pRes!=NULL){
cout<<"pRes不为空"<<endl;
delete pRes ;
}
/*if(pTest!=NULL){//这一段必须注释掉，pTest只是一个局部变量，这里无法访问到，pTest是放在栈上的
cout<<"pTest不为空"<<endl;
delete pTest ;
}*/
return 0;
}
JAVA：
A a = new A();
为A对象创建了一个实例，但在内存中开辟了两块空间：一块空间在堆区，存放new A（）这个对象；
另一块空间在堆栈，也就是栈，存放a，a的值为new A（）这个对象的内存地址。因为java在JVM中运行，
所以a 描述的内存地址不一定是这个对象真实内存的地址。
Object o; // 这是声明一个引用，它的类型是Object，他的值为null，还没有指向任何对象，该引用放在内存的栈区域中。
o = new Object(); // new Object()句，实例化了一个对象，就是在堆中申请了一块连续空间用来存放该对象。
= // 运算符，将引向o指向了对象。也就是说将栈中表示引用o的内存地址的内容改写成了Object对象在堆中的地址。
C++：
C++ 如果直接定义类，如classA a; a 存在栈上（也意味着复制了对象a在栈中），如果classA a = new classA就存在堆中。
C++中：
Student student(20) ; //这里student是引用 对象分配在 栈空间中,这里只是我的理解
Student *student = new Student(20); //这里student是指针它本身在栈中,new Student(20)是分配在堆内存空间的
new Student(20)是在堆空间里创建的实体，它与在数据段以及栈空间里创建的实体不同。尽管它们也是确确实实存在的实体，但是，我们看不见，也摸不着。所以必须用一个东西来表示它，这个就是指针或者引用了。这里我们使用student来指向堆中申请的这块区域，后面就可以用这个指针对这块区域进行访问了。参考：
https://blog.csdn.net/ShenYuanLuo/article/details/51146140