Почему код выкидывает исключение переполнение стека?

Question

[likilix]

Изучаю шаблон. Написал класс на шаблонах для работы с квадратной матрицей, не против критики по коду в целом))

#include <iostream>
#include <fstream>
#include <exception>

using namespace std;

namespace mrx {

template<int N,
         typename T = int>
    class Matrix {

       private:
          T _Mydata[N][N];

          void Assign(T _x);

          void out_of_range(int i, int j);
          void Xout_of_range(void) const;
       public:

          Matrix(void);

          int cell(void) const;
          int row(void) const;

          T item(int i, int j) const;
          T& item(int i, int j);

          void unfold(void);

          Matrix<N, T> operator * (T _x);
          Matrix<N, T> operator * (const Matrix<N, T>& _x);
          Matrix<N, T> operator + (const Matrix<N, T>& _x);
          Matrix<N, T> operator - (const Matrix<N, T>& _x);
          Matrix<N, T> operator = (const Matrix<N, T>& _x);
          Matrix<N, T> operator == (const Matrix<N, T>& _x);

          template<int N, typename T>
             friend std::istream& operator >> (std::istream& _c, Matrix<N, T>& _x);
          template<int N, typename T>
             friend std::ifstream & operator >> (std::ifstream& _c, Matrix<N, T>& _x);
          template<int N, typename T>
             friend std::ostream& operator << (std::ostream& _c, const Matrix<N, T>& _x);
          template<int N, typename T>
             friend std::ofstream& operator << (std::ofstream& _c, const Matrix<N, T>& _x);
    };

template<int N, typename T>
    void Matrix<N, T>::Assign(T _x)
    {
    for(int i = 0; i < N * N; i++) *(*_Mydata + i) = _x;
    }

template<int N, typename T>
    void Matrix<N, T>::out_of_range(int i, int j)
    {
    if((i < 0 || i > N)
     ||(j < 0 || j > N))
      {
      Xout_of_range();
      }
    }

template<int N, typename T>
    void Matrix<N, T>::Xout_of_range(void) const
    {
    throw std::out_of_range("out of range");
    }

template<int N, typename T>
    Matrix<N, T>::Matrix(void)
    {
    Assign(0);
    }

template<int N, typename T>
    int Matrix<N, T>::cell(void) const
    {
    return N;
    }

template<int N, typename T>
    int Matrix<N, T>::row(void) const
    {
    return N;
    }

template<int N, typename T>
    T Matrix<N, T>::item(int i, int j) const
    {
    out_of_range(i, j);
    return _Mydata[i][j];
    }

template<int N, typename T>
    T& Matrix<N, T>::item(int i, int j)
    {
    out_of_range(i, j);
    return _Mydata[i][j];
    }

template<int N, typename T>
    void Matrix<N, T>::unfold(void)
    {
    Matrix<N, T> temp;
    for(int i = 0; i < N; i++) {
       for(int j = 0; j < N; j++) {
           temp._Mydata[i][j] = _Mydata[j][i];
       }
    }
    for(int i = 0; i < N * N; i++) {
      *(*_Mydata + i) = *(*temp._Mydata + i);
    }
    }

template<int N, typename T>
    Matrix<N, T> Matrix<N, T>::operator * (T _x)
    {
    Matrix<N, T> temp;
     for(int i = 0; i < N * N; i++) {
       *(*temp._Mydata + i) = *(*_Mydata + i) * _x;
     }
    return temp;
    }

template<int N, typename T>
    Matrix<N, T> Matrix<N, T>::operator * (const Matrix<N, T>& _x)
    {
    Matrix<N, T> temp;
     for(int i = 0; i < N; i++) {
        for(int j = 0; j < N; j++) {
           for(int k = 0; k < N; k++) {
               temp._Mydata[i][j] += _Mydata[i][k] * _x._Mydata[k][j];
           }
        }
    }
    return temp;
    }

template<int N, typename T>
    Matrix<N, T> Matrix<N, T>::operator + (const Matrix<N, T>& _x)
    {
    Matrix<N, T> temp;
     for(int i = 0; i < N * N; i++) {
       *(*temp._Mydata + i) = *(*_Mydata + i) + *(*_x._Mydata + i);
     }
    return temp;
    }

template<int N, typename T>
    Matrix<N, T> Matrix<N, T>::operator - (const Matrix<N, T>& _x)
    {
    Matrix<N, T> temp;
     for(int i = 0; i < N * N; i++) {
       *(*temp._Mydata + i) = *(*_Mydata + i) - *(*_x._Mydata + i);
     }
    return temp;
    }

template<int N, typename T>
    Matrix<N, T> Matrix<N, T>::operator = (const Matrix<N, T>& _x)
    {
    for(int i = 0; i < N * N; i++) {
      *(*_Mydata + i) = *(*_x._Mydata + i);
    }
    return *this;
    }

template<int N, typename T>
    Matrix<N, T> Matrix<N, T>::operator == (const Matrix<N, T>& _x)
    {
    for(int i = 0; i < N * N; i++) {
      if(*(*_Mydata + i) != *(*_x._Mydata + i)) {
         return false;
      }
    }
    return true;
    }

template<int N, typename T>
    std::istream& operator >> (std::istream& _c, Matrix<N, T>& _x)
    {
    for(int i = 0; i < N * N; i++) {
      _c>> *(*_x._Mydata + i);
    }
    return _c;
    }

template<int N, typename T>
    std::ifstream & operator >> (std::ifstream& _c, Matrix<N, T>& _x)
    {
    for(int i = 0; i < N * N; i++) {
      _c>> *(*_x._Mydata + i);
    }
    return _c;
    }

template<int N, typename T>
    std::ostream& operator << (std::ostream& _c, const Matrix<N, T>& _x)
    {
    for(int i = 0; i < N; i++) {
       for(int j = 0; j < N; j++) {
          (_c<<_x._Mydata[i][j]).put(' ');
       }
      _c.put('\n');
    }
    return _c;
    }

template<int N, typename T>
    std::ofstream& operator << (std::ofstream& _c, const Matrix<N, T>& _x)
    {
    for(int i = 0; i < N; i++) {
       for(int j = 0; j < N; j++) {
          (_c<<_x._Mydata[i][j]).put(' ');
       }
      _c.put('\n');
    }
    return _c;
    }
};

int main()
{
    mrx::Matrix<2000, float> a;
    


    return 0;
}

Answer 1

[Wataru]

У вас массив внутри класса, класс - локальная переменная. Получается массив на стеке. На 4 миллиона ячеек. Но стек ограничен и вот он переполняется. Стандартного размера не хватает. Надо поднять размер стека опциями линкера.

Или экземпляр класса создавайте в куче, через new, и храните в unique_ptr.

А по коду: не используйте эту сишную арифметику указателей. У вас двумерный массив, вы и обращайтесь везде через 2 индекса в квадратных скобках. Так понятнее код будет.