NickAndNick

Матрица. Вставка строк

May 21st, 2018
116
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. #include <iostream>
  2. #include <iomanip>
  3. #include <random>
  4.  
  5. using namespace std;
  6.  
  7. class Matrix
  8. {
  9. public:
  10.     Matrix() = delete;
  11.     Matrix(const Matrix&) = delete;
  12.     Matrix(Matrix&&) = delete;
  13.     Matrix& operator=(const Matrix&) = delete;
  14.     Matrix& operator=(Matrix&&) = delete;
  15.  
  16.     Matrix(const size_t rows, const size_t cols)
  17.         : matrix_(nullptr), rows_(rows), cols_(cols)
  18.     {
  19.         matrix_ = create(rows_, cols_);
  20.     }
  21.  
  22.     ~Matrix()
  23.     {
  24.         if (matrix_ != nullptr) {
  25.             for (size_t row = 0; row < rows_; ++row) {
  26.                 if (matrix_[row]) {
  27.                     delete[] matrix_[row];
  28.                 }
  29.             }
  30.  
  31.             delete[] matrix_;
  32.             matrix_ = nullptr;
  33.         }
  34.     }
  35.  
  36.     void fill(int a, int b)const
  37.     {
  38.         if (a > b) {
  39.             swap(a, b);
  40.         }
  41.  
  42.         const uniform_int_distribution<> uid(a, b);
  43.         random_device rd;
  44.         mt19937 gen(rd());
  45.  
  46.         for (size_t row = 0; row < rows_; ++row) {
  47.             for (size_t col = 0; col < cols_; ++col) {
  48.                 matrix_[row][col] = uid(gen);
  49.             }
  50.         }
  51.     }
  52.  
  53.     void print(const streamsize width)const
  54.     {
  55.         for (size_t row = 0; row < rows_; ++row) {
  56.             for (size_t col = 0; col < cols_; ++col) {
  57.                 cout << setw(width) << matrix_[row][col];
  58.             }
  59.             cout.put('\n');
  60.         }
  61.     }
  62.  
  63.     void front_row(const int* row, const size_t size)
  64.     {
  65.         if (size != cols_) {
  66.             return;
  67.         }
  68.  
  69.         auto tmp = copy();
  70.         const auto rows = rows_;
  71.  
  72.         destroy(matrix_, rows_);
  73.         ++rows_;
  74.  
  75.         matrix_ = create(rows_, cols_);
  76.  
  77.         for (size_t i = 0; i < cols_; ++i) {
  78.             matrix_[0][i] = row[i];
  79.         }
  80.  
  81.         for (size_t r = 1; r < rows_; ++r) {
  82.             for (size_t c = 0; c < cols_; ++c) {
  83.                 matrix_[r][c] = tmp[r - 1][c];
  84.             }
  85.         }
  86.  
  87.         destroy(tmp, rows);
  88.         tmp = nullptr;
  89.     }
  90.  
  91.     void push_row(const int* row, const size_t size)
  92.     {
  93.         if (size != cols_) {
  94.             return;
  95.         }
  96.  
  97.         auto tmp = copy();
  98.         const auto rows = rows_;
  99.  
  100.         destroy(matrix_, rows_);
  101.         ++rows_;
  102.  
  103.         matrix_ = create(rows_, cols_);
  104.  
  105.         for (size_t r = 0; r < rows; ++r) {
  106.             for (size_t c = 0; c < cols_; ++c) {
  107.                 matrix_[r][c] = tmp[r][c];
  108.             }
  109.         }
  110.  
  111.         for (size_t i = 0; i < cols_; ++i) {
  112.             matrix_[rows][i] = row[i];
  113.         }
  114.  
  115.         destroy(tmp, rows);
  116.         tmp = nullptr;
  117.     }
  118.  
  119.     void insert_row(int* row, const size_t size, const size_t index)
  120.     {
  121.         if (size != cols_) {
  122.             return;
  123.         }
  124.  
  125.         if (index == 0) {
  126.             front_row(row, size);
  127.         } else if (index >= rows_) {
  128.             push_row(row, size);
  129.         }
  130.  
  131.         auto tmp = copy();
  132.         const auto rows = rows_;
  133.  
  134.         destroy(matrix_, rows_);
  135.         ++rows_;
  136.  
  137.         matrix_ = create(rows_, cols_);
  138.  
  139.         for (size_t r = 0; r < rows_; ++r) {
  140.             for (size_t c = 0; c < cols_; ++c) {
  141.                 if (r < index) {
  142.                     matrix_[r][c] = tmp[r][c];
  143.                 } else if (r == index) {
  144.                     matrix_[r][c] = row[c];
  145.                 } else {
  146.                     matrix_[r][c] = tmp[r - 1][c];
  147.                 }
  148.             }
  149.         }
  150.  
  151.         destroy(tmp, rows);
  152.         tmp = nullptr;
  153.     }
  154. private:
  155.     int** matrix_;
  156.     size_t rows_;
  157.     size_t cols_;
  158.  
  159.     int** copy()const
  160.     {
  161.         const auto tmp = create(rows_, cols_);
  162.  
  163.         for (size_t row = 0; row < rows_; ++row) {
  164.             for (size_t col = 0; col < cols_; ++col) {
  165.                 tmp[row][col] = matrix_[row][col];
  166.             }
  167.         }
  168.  
  169.         return tmp;
  170.     }
  171.  
  172.     int** create(const size_t rows, const size_t cols)const
  173.     {
  174.         const auto tmp = new int*[rows_];
  175.  
  176.         for (size_t row = 0; row < rows_; ++row) {
  177.             tmp[row] = new int[cols_];
  178.         }
  179.  
  180.         return tmp;
  181.     }
  182.  
  183.     static void destroy(int** tmp, const size_t rows)
  184.     {
  185.         for (size_t row = 0; row < rows; ++row) {
  186.             delete[] tmp[row];
  187.         }
  188.         delete[] tmp;
  189.     }
  190. };
  191. int main()
  192. {
  193.     cout << "Rows: ";
  194.     size_t rows;
  195.     cin >> rows;
  196.  
  197.     cout << "Columns: ";
  198.     size_t cols;
  199.     cin >> cols;
  200.  
  201.     Matrix matrix(rows, cols);
  202.  
  203.     matrix.fill(1, 100);
  204.     matrix.print(4);
  205.     cout.put('\n');
  206.  
  207.     auto row = new int[cols];
  208.     auto x = 900;
  209.     for (size_t i = 0; i < cols; ++i) {
  210.         row[i] = ++x;
  211.     }
  212.  
  213.     matrix.front_row(row, cols);
  214.     matrix.print(4);
  215.     cout.put('\n');
  216.  
  217.     matrix.push_row(row, cols);
  218.     matrix.print(4);
  219.     cout.put('\n');
  220.  
  221.     cout << "Index: ";
  222.     size_t index;
  223.     cin >> index;
  224.  
  225.     matrix.insert_row(row, cols, index);
  226.     matrix.print(4);
  227.     cout.put('\n');
  228.  
  229.     delete[] row;
  230.     row = nullptr;
  231.  
  232.     system("pause");
  233. }
RAW Paste Data