Копировать раздел би мерного на себя

Question

У меня есть би мерные булева (целое) массив, например, следующее:

0 1 0 0 
0 0 0 0 
0 0 0 0 
0 0 0 0 

Скажет, я хочу, чтобы скопировать раздел первых 2 по 2

0 1 
0 0 

Onto три оставшихся квадрантов, так что бы выглядеть следующим образом, в конце концов:

0 1 0 1 
0 0 0 0 
0 1 0 1 
0 0 0 0 

Я хотел бы использовать memcpy, поскольку я считаю, что это самый быстрый подход. Как я могу использовать его в этом случае? Можно ли даже скопировать двумерное содержимое?

Если нет, то мое единственное изменение - иметь одномерный массив, где я индексирую N * N?

Answer 1

Многомерные массивы будут иметь одинаковую компоновку в памяти как один более длинный массив. В любом случае, memcpy вам не поможет (в любом случае, один звонок).

01010000 
01010000 
00000000 
00000000 

Хотя в абстрактной схеме он выглядит, как вы можете просто скопировать этот квадрат, в действительности это выглядит следующим образом:

01000000010000000000000000000000 
^^^^^^^^^^^^ 

Вы должны включать в себя все значения на первой линии тоже.

Кроме того, memcpy может копировать столько же, сколько длина исходного массива. Вы не можете скопировать 4 байта на 16 байтов с одним вызовом memcpy.

Редактировать: Пока я писал это, вопрос был изменен для изменения значений. Тем не менее, я думаю, что моя точка лучше иллюстрируется исходной настройкой. Это будет работать только по совпадению, если шаблон правильный.

Answer 2

Запомнить

преждевременной оптимизации является корень всех зол

Написать читаемый код и когда приложение не будет достаточно эффективным, то профиль, и вы увидите, где у Вас есть узкие места но на данный момент я почти уверен, что вы не использовали memcpy, не будет влиять столько, сколько вы думаете.

Но ..

Вы помечено C++, так вот мой простой compileable пример реализации C++. Это копия подматрицы до конца матрицы (не раньше, так что если вы будете проходить начальную точку, что подматрицы, например, 2,3 она не будет копировать его 0,0)

#include <iostream> 
    #include <iterator> 
    #include <algorithm> 

    using namespace std; 

    void copy_submatrix(size_t n, 
         size_t m, 
         const pair<size_t, size_t> &from, 
         const pair<size_t, size_t> &to, 
         vector<vector<int>> &oryginal_matrix) 
    { 
     auto begin_y = oryginal_matrix.begin() + from.first; 
     auto begin_to_y = oryginal_matrix.begin() + to.first; 
     auto end_y = begin_y + m; 


     for(; begin_y != end_y; ++begin_y, ++begin_to_y) 
     { 
      auto begin_x = (*begin_y).begin() + from.second; 
      auto begin_to_x = (*begin_to_y).begin() + to.second; 

      copy(begin_x, begin_x + n, begin_to_x); 
     } 
    } 

    void process_matrix(vector<vector<int>> &matrix, 
         size_t submatrix_n, 
         size_t submatrix_m) 
    { 
     for(size_t y = 0; y < matrix.size(); y += submatrix_m) 
      for(size_t x = 0; x < matrix.size(); x += submatrix_n) 
       copy_submatrix(submatrix_n, 
           submatrix_m, 
           { 0, 0 }, 
           { y, x }, 
           matrix); 
    } 

    void print(const vector<vector<int>> &matrix) 
    { 
     for(const auto &v : matrix) 
     { 
      copy(v.begin(), 
        v.end(), 
        ostream_iterator<int>(cout, " ")); 

      cout << "\n"; 
     } 
    } 

    int main() { 
     vector<vector<int>> matrix{ 
      { 0, 1, 0, 0, 0 }, 
      { 0, 0, 0, 0, 0 }, 
      { 0, 0, 0, 0, 0 }, 
      { 0, 0, 0, 0, 0 }, 
      { 0, 0, 0, 0, 0 }, 
      { 0, 0, 0, 0, 0 } 
     }; 


     cout<<"before: \n"; 
     print(matrix); 

     process_matrix(matrix, 2, 3); 

     cout << "after: \n"; 
     print(matrix); 

     return 0; 
    }