Dynamic Memory allocation during Transpose - c++

Question

I am trying to calculate the transpose of a matrix that is not n by n.
The problem is I have to allocate new memory to each element being added, I do not have to delete the **array.
Code is something like that.
// initialize a 2-D array.
array = new int*[row];
for (int i=0; i<row; i++){
arr[i] = new int[col]();
}
Now I am considering just One case that suppose my matrix is 3*4. transpose of Matrix has dim 4*3.
I do the following code But it is giving "SEGMENTATION FAULT". The idea is i allocate a new memory to the element that would be added as a result of transpose.
Code is:
int r=col;
int c=row;
if (col<c){
arr = new int*[row];
for (int i=col; i<=c; i++){
arr[i] = new int[col](); // trying to allocate New Memory to elem.
}
It is giving error here.
Any Help. Also if there is any other method to solve this prolem , do suggest.

Answer 1

In your second code sample, you write over the array limits. arr is row elements long, counting from 0 to row - 1. In the for loop your index i goes from col to c which is equivalent to row and one element beyond the array. Correct code would be < instead of <=
for (int i=col; i < c; i++){
arr[i] = new int[col](); // trying to allocate New Memory to elem.
}
Apart from that, may I suggest you look at Wikipedia: Transpose, because in your second case you can use the the first code sample with just row and col switched.

Answer 2

Write a wrapper with accessor functions (e.g. operator(row,col) for matrices), and use a single-dimensional array of size rows*cols internally.
It makes things much easier, and keeps the data for this matrix together. This can have cache benefits for smaller matrices.
Here is an example, as requested in your comment. It's held very simple by purpose and does not use any templates. It uses a vector as internal storage. You can access the matrix elements using operator(..), e.g.
Matrix A(3,4);
// fill matrix
// you can access each element in a natural syntax as expected from math
int x = A(2,2);
A(2,2) = 3;
In addition, you probably should use exceptions instead of asserts to check for index overflow.
// matrix.h
#include <vector>
class Matrix
{
public:
Matrix(size_t rows, size_t cols);
int& operator()(size_t row, size_t col);
const int& operator()(size_t row, size_t col) const;
int& operator[](size_t index);
const int& operator[](size_t index) const;
Matrix get_transposed() const;
size_t compute_index(size_t row, size_t col) const;
void print();
private:
size_t _rows;
size_t _cols;
std::vector<int> _data;
}; // class Matrix
// matrix.cpp
#include "matrix.h"
#include <iostream>
#include <cassert>
Matrix::Matrix(size_t rows, size_t cols)
: _rows(rows)
, _cols(cols)
, _data(rows*cols, 0)
{
}
int& Matrix::operator()(size_t row, size_t col)
{
const size_t index = compute_index(row, col);
assert(index < _data.size());
return _data[index];
}
const int& Matrix::operator()(size_t row, size_t col) const
{
const size_t index = compute_index(row, col);
assert(index < _data.size());
return _data[index];
}
int& Matrix::operator[](size_t index)
{
return _data[index];
}
const int& Matrix::operator[](size_t index) const
{
return _data[index];
}
size_t
Matrix::compute_index(size_t row, size_t col) const
{
// here you should check that:
// row < rows
// col < cols
// and throw an exception if it's not
assert(row<_rows);
assert(col<_cols);
return row * _cols + col;
}
Matrix
Matrix::get_transposed() const
{
Matrix t(_cols,_rows);
for(size_t row = 0; row < _rows; ++row)
for(size_t col = 0; col < _cols; ++col)
{
t(col,row) = (*this)(row,col);
}
return t;
}