C++ 使用2D指针数组会导致错误

我有如下几点：

template<class T>
struct point{
   point* next = nullptr;
   T* data = nullptr;
}

template<class T>
class newClass
{
   point<T>*** points;

public:
   newClass()
   {
      points = new point<T>**[10];
      for (int i = 0; i < 10; i++)
          points[i] = new point<T>*[10];

      for (int i = 0; i < 10; i++)
          for(int j = 0; j < 10; j++)
             if(j != 9)
                points[i][j]->next = points[i][j+1]; //ERROR
   }
};

模板
结构点{
点*next=nullptr；
T*data=nullptr；
}
模板
类newClass
{
点***点；
公众：
新类（）
{
点数=新点数**[10]；
对于（int i=0；i<10；i++）
点[i]=新点*[10]；
对于（int i=0；i<10；i++）
对于（int j=0；j<10；j++）
如果（j！=9）
点[i][j]->下一个=点[i][j+1]；//错误
}
};

---

有人能帮我理解为什么这会产生错误吗？我没有收到错误消息，程序只是崩溃了。

当您执行

指向[I][j]->下一步

您取消引用未初始化的指针，这将导致未定义的行为

放弃一级间接寻址并执行

points[i][j].next = &points[i][j+1];

或者，执行额外的分配循环来初始化最后一个指针

---

另一种方式是，这里根本不需要使用指针，特别是因为您的分配都是固定大小的，这意味着您可以使用固定数组，甚至更好：

std:：数组点；

当您执行

指向[i][j]->下一步

您将取消引用未初始化的指针，这将导致未定义的行为

放弃一级间接寻址并执行

points[i][j].next = &points[i][j+1];

或者，执行额外的分配循环来初始化最后一个指针

---

另一种方式是，这里根本不需要使用指针，特别是因为您的分配都是固定大小的，这意味着您可以使用固定数组，甚至更好：

std:：数组点；

当您执行

指向[i][j]->下一步

您将取消引用未初始化的指针，这将导致未定义的行为

放弃一级间接寻址并执行

points[i][j].next = &points[i][j+1];

或者，执行额外的分配循环来初始化最后一个指针

---

另一种方式是，这里根本不需要使用指针，特别是因为您的分配都是固定大小的，这意味着您可以使用固定数组，甚至更好：

std:：数组点；

当您执行

指向[i][j]->下一步

您将取消引用未初始化的指针，这将导致未定义的行为

放弃一级间接寻址并执行

points[i][j].next = &points[i][j+1];

或者，执行额外的分配循环来初始化最后一个指针

---

另一种方式是，这里根本不需要使用指针，特别是因为您的分配都是固定大小的，这意味着您可以使用固定数组，甚至更好：

std:：数组点；

表达式的类型

points[i][j]

是

点*

。此指针未初始化。它具有无限的价值。首先，您需要分配一个将由该指针指向的对象。比如说

points[i][j] = new point<t>();

什么都不提

我想你的意思是

template<class T>
class newClass
{
   point<T> **points;

public:
   newClass()
   {
      points = new point<T>*[10];
      for (int i = 0; i < 10; i++)
          points[i] = new point<T>[10]();

      for (int i = 0; i < 9; i++)
                points[i]->next = points[i+1];
   }
};

模板
类newClass
{
点**点；
公众：
新类（）
{
点数=新点数*[10]；
对于（int i=0；i<10；i++）
点[i]=新点[10]（）；
对于（int i=0；i<9；i++）
点[i]->下一个=点[i+1]；
}
};

表达式的类型

points[i][j]

是

点*

。此指针未初始化。它具有无限的价值。首先，您需要分配一个将由该指针指向的对象。比如说

points[i][j] = new point<t>();

什么都不提

我想你的意思是

template<class T>
class newClass
{
   point<T> **points;

public:
   newClass()
   {
      points = new point<T>*[10];
      for (int i = 0; i < 10; i++)
          points[i] = new point<T>[10]();

      for (int i = 0; i < 9; i++)
                points[i]->next = points[i+1];
   }
};

模板
类newClass
{
点**点；
公众：
新类（）
{
点数=新点数*[10]；
对于（int i=0；i<10；i++）
点[i]=新点[10]（）；
对于（int i=0；i<9；i++）
点[i]->下一个=点[i+1]；
}
};

表达式的类型

points[i][j]

是

点*

。此指针未初始化。它具有无限的价值。首先，您需要分配一个将由该指针指向的对象。比如说

points[i][j] = new point<t>();

什么都不提

我想你的意思是

template<class T>
class newClass
{
   point<T> **points;

public:
   newClass()
   {
      points = new point<T>*[10];
      for (int i = 0; i < 10; i++)
          points[i] = new point<T>[10]();

      for (int i = 0; i < 9; i++)
                points[i]->next = points[i+1];
   }
};

模板
类newClass
{
点**点；
公众：
新类（）
{
点数=新点数*[10]；
对于（int i=0；i<10；i++）
点[i]=新点[10]（）；
对于（int i=0；i<9；i++）
点[i]->下一个=点[i+1]；
}
};

表达式的类型

points[i][j]

是

点*

。此指针未初始化。它具有无限的价值。首先，您需要分配一个将由该指针指向的对象。比如说

points[i][j] = new point<t>();

什么都不提

我想你的意思是

template<class T>
class newClass
{
   point<T> **points;

public:
   newClass()
   {
      points = new point<T>*[10];
      for (int i = 0; i < 10; i++)
          points[i] = new point<T>[10]();

      for (int i = 0; i < 9; i++)
                points[i]->next = points[i+1];
   }
};

模板
类newClass
{
点**点；
公众：
新类（）
{
点数=新点数*[10]；
对于（int i=0；i<10；i++）
点[i]=新点[10]（）；
对于（int i=0；i<9；i++）
点[i]->下一个=点[i+1]；
}
};

指针运算符太多。下面的代码将工作

#include <iostream>

using namespace std;

template<class T>
struct point {
    point* next = nullptr;
    T* data = nullptr;
    T* operator->() {
        return data;
    }
};

template<class T>
class newClass
{
    point<T>** points;

public:
    newClass()
    {
        points = new point<T>*[10];
        for (int i = 0; i < 10; i++) {
            points[i] = new point<T>[10];
        }

        for (int i = 0; i < 10; i++) {
            for (int j = 0; j < 10; j++) {
                if (j != 9) {
                    points[i][j].next = points[i][j + 1].next; //ERROR
                }
            }
        }
    }
};

int main()
{
    newClass<int> nc;

    return 0;
}

#包括
使用名称空间std；
模板
结构点{
点*next=nullptr；
T*data=nullptr；
T*运算符->（）{
返回数据；
}
};
模板
类newClass
{
点**点；
公众：
新类（）
{
点数=新点数*[10]；
对于（int i=0；i<10；i++）{
点[i]=新点[10]；
}
对于（int i=0；i<10；i++）{
对于（int j=0；j<10；j++）{
如果（j！=9）{
点[i][j]。下一步=点[i][j+1]。下一步；//错误
}
}
}
}
};
int main（）
{
新类数控；
返回0；
}

指针运算符太多。下面的代码将工作

#include <iostream>

using namespace std;

template<class T>
struct point {
    point* next = nullptr;
    T* data = nullptr;
    T* operator->() {
        return data;
    }
};

template<class T>
class newClass
{
    point<T>** points;

public:
    newClass()
    {
        points = new point<T>*[10];
        for (int i = 0; i < 10; i++) {
            points[i] = new point<T>[10];
        }

        for (int i = 0; i < 10; i++) {
            for (int j = 0; j < 10; j++) {
                if (j != 9) {
                    points[i][j].next = points[i][j + 1].next; //ERROR
                }
            }
        }
    }
};

int main()
{
    newClass<int> nc;

    return 0;
}

#包括
使用名称空间std；
模板
结构点{
点*next=nullptr；
T*data=nullptr；
T*运算符->（）{
返回数据；
}
};
模板
类newClass
{
点**点；
公众：
新类（）
{
点数=新点数*[10]；
对于（int i=0；i<10；i++）{
点[i]=新点[10]；
}
对于（int i=0；i<10；i++）{
对于（int j=0；j<10；j++）{