Understanding copy of 2D arrays - c++

Question

I am trying to switch cols and rows of a 2D array by using a temp array and replace original array with temp using std::copy at the end. But std::Copy copying only first row and rest are showing same old values in original array. Also the statement array = {}; is not clearing indexes to 0.
// Clear array to 0 (issue: This has no effect at all)
array[arrayRowSize][arrayColSize] = {};
// Copy array (issue: only first row is copied, rest of original still has old values)
std::copy(&tempArray[0][0], (&tempArray[0][0])+arrayColSize*arrayRowSize, &array[0][0]);
Can anyone take a look at my code and tell me what I am doing wrong ? Please add some details about how it actually work, and suggest if there is anything we can improve.
#include <iostream>
#include <cstdint>
using namespace std;
bool IsIntegerInputValid (int16_t arrayData, int8_t arrayLimit)
{
// Entered input is a non-digit, negative number or > arrayLimit ?
if ( cin.fail() || arrayData < 0 || arrayData > arrayLimit )
{
// Clear error flag and input buffer
cin.clear();
cin.ignore();
cout << "Invalid input, Please try again" << endl;
return false;
}
return true;
}
int main()
{
const uint8_t kMaxArraySize = 10;
int16_t array[kMaxArraySize][kMaxArraySize] = {};
int16_t arrayRowSize = 0;
int16_t arrayColSize = 0;
// Get array size
while (1)
{
cin >> arrayRowSize;
if ( IsIntegerInputValid ( arrayRowSize, kMaxArraySize) )
{
while (1)
{
cin >> arrayColSize;
if ( IsIntegerInputValid ( arrayColSize, kMaxArraySize) )
{
break; // Got valid size
}
}
break; // Got valid size
}
}
// Get array input
for (int i = 0; i < arrayRowSize; ++i)
{
for (int j = 0; j < arrayColSize; ++j)
{
cin >> array[i][j];
if ( !IsIntegerInputValid (array[i][j], kMaxArraySize) )
{
--i; // Try again
}
}
}
// Copy rows to cols and cols to rows
int16_t tempArray[kMaxArraySize][kMaxArraySize] = {};
for (int i = 0; i < arrayColSize; ++i)
{
for (int j = 0; j < arrayRowSize; ++j)
{
tempArray[i][j] = array[j][i];
cout << tempArray[i][j] << ' ';
}
cout << endl;
}
array[arrayRowSize][arrayColSize] = {}; // Clear array to 0 (issue: This has no effect at all)
// Copy array (issue: only first row is copied, rest of original still has old values)
std::copy(&tempArray[0][0], (&tempArray[0][0])+arrayColSize*arrayRowSize, &array[0][0]);
return 0;
}
Thanks

Answer 1

array[arrayRowSize][arrayColSize] = {}; // Clear array to 0 (issue: This has no effect at all)
This accesses the table element at next out of bounds row of array and next out of bounds column of that row (if the row had any column that werent out of bounds). The behaviour is undefined. The last index that can be accessed is array[arrayRowSize - 1][arrayColSize - 1]. Assigning to an element out of bounds does nothing along the lines of clearing the array.
To set all elements of an array to zero, I would use:
std::memset(array, 0, sizeof array);
That said, you're about to overwrite all values, so this appears to be pointless.
std::copy(&tempArray[0][0], (&tempArray[0][0])+arrayColSize*arrayRowSize, &array[0][0]);
This assumes that the lines are stored contiguously in memory. And if that were true, this would work just fine. However, since you've allocated A large array, and use only part of each row, there are unused parts of the rows between.
An example: You allocate a 7x7 array, then use only a 3x3 array within it. The memory layout could be following:
|-----| <- a row
AAAXXXXBBBXXXXCCCX...
|-------| <- first 9 elements
A represents first row, B represents second ...
X represents unused part of the array.
Now, if you copy 9 contiguous elements as if they were all elements of your array, you would get AAAXXXXBB, which contains plenty of unused elemnets, and not all of used elements.
Since your rows are not contiguous, you must copy each row separately. Or you could copy the entire array including the unused portions.

Answer 2

The copy doesn't work because sizes of your aray is not the same as kMaxArraySize.
copy tries to copy array as one dimensional array. but in your case 2d array coverted to 1d can have a lot of zeros inside.
if you've choosen size 3, 3 the your array will be like :
1 2 3 0 0 0 0 0 0 0
4 5 6 0 0 0 0 0 0 0
7 8 9 0 0 0 0 0 0 0
......
for 1d representation it will look like:
1 2 3 0 0 0 0 0 0 0 4 5 6 0 0 0 0 0 0 0 7 8 9 0 0 0 0 0 0
but copy will take only 9 first records.