Can Someone Help Me Troubleshoot This Program (It Transposes A Matrix Using Pointers)

Question

I have this program that I made that is supposed to transpose a matrix, no matter what size it is. It however is not working like it is supposed to and I have no idea why, I do get output from it there are no compiling errors but the output for {1,2,3},{4,5,6}, is {1,0,0},{0,0,4}, which makes absolutely no sense to me. I have worked through "memory snapshots" on paper many times but just can't find what I'm missing, I really just need another set of eyes at this point, thanks.

#include "stdafx.h"

#include <fstream>

#include <iostream>

#include <iomanip>

#include <string>

#include <cmath>

#include <vector>

using namespace std;

void squaretranspose(int &M, int &MT, int ROWS, int COLS);

int main(void)
{
    int M[2][3]={{1,2,3},{4,5,6}};
    int MT[3][2]={0};
    int ROWS(2),COLS(3);

int i,j;
cout << " The entries of the original matrix " << endl;
for(i=0;i<=ROWS-1;i++)
{
    for(j=0;j<=COLS-1;j++)
{
cout<<M[i][j]<<"\t";
}
cout << endl;
}
squaretranspose(M[0][0],MT[0][0],ROWS,COLS);
cout << " The entries of the transposed non-square matrix " << endl;
for(i=0;i<=COLS-1;i++)
{
    cout << endl;
    for(j=0;j<=ROWS-1;j++)
{
cout<<MT[i][j]<<"\t";
}
}
system ("PAUSE");
return 0;
}
void squaretranspose (int &M, int &MT, int ROWS, int COLS)
{
    // declare pointers to change the input matrice's values
    int *ptr,*ptrT;
// declare indices for a row by row process
    int i,j;
// declare placeholder 2d vectors for swapping the I,j, entries to ,j,i entries  
    vector < vector<int>> temp(ROWS,COLS);
    vector < vector<int>> tempT(COLS,COLS);
    vector < vector<int>> temp_T(ROWS,ROWS);
// set the pointers to point to the first entry of the input and output matrices
    ptr = &M;
    ptrT = &MT;

// if rows=cols we want to use 2d vector temp
    if (ROWS=COLS)
    {
// store all of the input matrice's values in the 2d vector "temp"
    for(i=0;i<=ROWS-1;i++)
    {
        for(j=0;j<=COLS-1;j++)
        {

// set the i,j th entry of the 2d vector "temp" equal to the value currently pointed to by the pointer
        temp[i][j]=*ptr;
// increment the pointer to the address of the next entry of the input matrix unless we are on the last entry
               if ((i!=ROWS-1)&&(j!=COLS-1))
               { 
               ptr++;
               }
        }
        }
    }
// reset pointer address to first entry
    ptr=&M;
// the for loop for swapping the j,i entries of the 2d vector "temp" with the i,j entries of the input matrix
    for(i=0;i<=ROWS-1;i++)
    {
        for(j=0;j<=COLS-1;j++)
        {
// if j is not equal to i swap the value pointed to by the pointer (the i,j entry of the input matrix) for the j,ith entries value of the 2d vector "temp"
        if (j!=i)
            {
            *ptr=temp[j][i];
            }
        // increment the pointer if it is not on the last entry
               if ((i!=ROWS-1)&&(j!=COLS-1))
               { 
               ptr++;
               }
        }
    }*/


// if ROWS<COLS we want to have 2d vector tempT
if (ROWS<COLS)
{
// store all of the input matrice's values in the 2d vector "tempT"
    for(i=0;i<=ROWS-1;i++)
    {
        for(j=0;j<=COLS-1;j++)
        {
// set the j,ith entry of the 2d vector "temp" equal to the value currently pointed to by the pointer
        tempT[j][i]=*ptr;
// increment the pointer to the address of the next entry of the input matrix
        if (((i!=(ROWS-1))&&(j!=(COLS-1))))
        {
            ptr++;
        }
        }
    }
    ptr=&M;
// transport the entries of tempT into the output matrix MT
    for(i=0;i<=COLS-1;i++)
    {
        for(j=0;j<=ROWS-1;j++)
        {
        *ptrT=tempT[i][j];
// increment the pointer
        if (((i!=ROWS-1)&&(j!=COLS-1)))
        {
            ptrT++;
        }
        }
    }
}
ptrT=&MT;

// if ROWS>COLS we want to use the 2d vector temp_T
if (ROWS>COLS)
{
// store all of the input matrice's values in the 2d vector "temp_T"
    for(i=0;i<=ROWS-1;i++)
    {
        for(j=0;j<=COLS-1;j++)
        {

// set the j,i th entry of the 2d vector "temp" equal to the value currently pointed to by the pointer
        temp_T[j][i]=*ptr;
// increment the pointer
        if (((i!=ROWS-1)&&(j!=COLS-1)))
        {
            ptrT++;
        }
    }

// the for loop for swapping the j,i entries of the 2d vector "temp" with the i,j entries of the input matrix
    for(i=0;i<=COLS-1;i++)
    {
        for(j=0;j<=ROWS-1;j++)
        {
// if j is not equal to i swap the value pointed to by the pointer (the i,j entry of the input matrix) for the j,ith entries value of the 2d vector "temp"
            if (j!=i)
            {
            *ptrT=temp_T[j][i];
            }
// increment the pointer
        if (((i!=ROWS-1)&&(j!=COLS-1)))
        {
            ptrT++;
        }
        }
    }
}
return;
}

// so there it is, it is not very efficient if COLS is very small and say ROWS is very huge because of the intermediary 2d square vector, but for everything else it should be pretty good, if it was working properly.

Answer 1

Use DIY indexing: ptrT[ index(j,i,COLS,ROWS) ] = ptr[ index(i,j,ROWS,COLS) ] . Now all you have to do is write the function that converts 2D indeces to 1D indeces.

Answer 2

There are a couple of major issue with your code, this line:

if (ROWS=COLS)

was probably meant to be:

if (ROWS == COLS)

The first case you will assign the value of COLS to ROWS in the second case you will be checking if they are equal. In all of your for loops you are using <= when you should be using < otherwise you will be accessing one outside your array bounds.

Beyond that, the code is just too complicated, a transpose function should be pretty straight forward, this is one possible method:

template <int n, int m>
void squaretranspose( int a[n][m], int b[m][n])
{
    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < m; j++)
        {
            b[j][i] = a[i][j];
        }
    }
} 

But the fastest and simplest way to transpose a matrix will be to invert your coordinates, so instead of accessing (i,j) you access (j,i) . If on the other hand performance is your main concern then this previous thread covers the topic pretty well my solution as well and has my solution as others which may suit you.