shifting rows in 2d array matrix - c++

Question

iam trying to write a function that shifts rows in c++
for example
1 2 3
4 5 6
7 8 9
i want to shift it by one so the result is
7 8 9
1 2 3
4 5 6
the parameters is
void Matrix:: rowShift(const int shiftSize){}
here is the class
class Matrix {
private:
std::string type;
int row, col;
double **array;
void rowShift(const int shiftSize);
here is the constructor
Matrix::Matrix(int rows, int cols, std::string matType) {
type = matType;
row = rows;
col = cols;
array= new double*[row];
for (int i = 0; i < row; ++i)
array[i] = new double[col];
for (int i = 0; i < rows; i++)
for (int j = 0; j<cols; j++)
array[i][j] = 0;
}
any ideas iam new to see and i have a problem iam not used to the syntax either

Answer 1

I am new to C++ and I am not used to the syntax either
First things first, if you are new to the language you should take some time to read up on the basics before you just start writing code. There are many great books to get you started. I would recommend something like this introduction to programming in C++ written by the creator of the language.
Programming: Principles and Practice Using C++ (Bjarne Stroustrup)
I am trying to write a function that shifts rows in C++
So you have a two dimensional array (matrix) that you want to shift all rows down, and the old bottom row becomes the new top row. This seems like it might be your homework assignment loay. Is it your homework? If it is, please tag it as such in the future to be honest with yourself and others. I want you to stop reading my answer to your question now, go get that book and read it cover to cover. Once do that come back and check my answer.
Now that you're familiar with C++ I'll also assume you are familiar with the the standard template library and container objects such as std::vector.
here is the constructor
Now that you're familiar with C++, you know that you can use member initializer lists for your constructor arguments. This means you don't have to initialize them in the body of the constructor! I'm going to leave out your std::string matType variable because it's not used anywhere in the code you provided. I recommend using a nested std::vector to hold your matrix data as opposed to a C style array. The std::vector class will do all your memory management for you (new double[col] will not be necessary). Here we have defined the class private member variable mMatrix to be a std::vector of rows and columns std::vector< std::vector<double> > mMatrix;
Matrix( const size_t rows,
const size_t cols ) :
mRows(rows),
mCols(cols),
mMatrix(rows, std::vector<double>(cols)) {
init();
}
The Matrix::init() function will populate your matrix with default values incrementing from 1 to n. We do this using the concepts you read up on like std::iterator.
void init()
{
std::vector< std::vector<double> >::iterator row;
std::vector<double>::iterator col;
double seedVal(1.0);
for (row = mMatrix.begin(); row != mMatrix.end(); ++row)
{
for (col = row->begin(); col != row->end(); ++col)
{
*col = seedVal;
seedVal++;
}
}
}
Now I'm going to assume that you'll want to print the values of your matrix to verify that the shift down operation has worked. You can print the matrix using nested for loops very similar to the way we initialized the values earlier. This time we can use ::const_iterator since when we print, we are making a guarantee that we are not modifying the contents. We also use formatting flags from #include <iomanip> like std::setfill(' ') and std::setw(6) to get the spacing and formatting to look nice.
void print()
{
std::vector< std::vector<double> >::const_iterator row;
std::vector<double>::const_iterator col;
for (row = mMatrix.begin(); row != mMatrix.end(); ++row)
{
for (col = row->begin(); col != row->end(); ++col)
{
std::cout << std::setfill(' ') << std::setw(6) << *col;
}
std::cout << std::endl;
}
}
Now let's talk about the real reason you're here. The method to down shift the entire matrix (which I think should be a public method of the Matrix class so that it can be accessed by anyone). First, whenever you shift the contents of an array (vector) you must loop in the opposite direction of the shifting. In our case, we should invert the direction of our outer loop over each row. We also do NOT want to overwrite the contents of our rows without saving what was there before. We can accomplish this with a temporary variable that will, you guessed it, temporarily hold the old value while we shift the new one. Here is the method that will down shift all elements of the matrix, as long as we have at least one row to work with.
void shiftDown()
{
if (mRows > 0)
{
for (size_t i = mRows - 1; i-- > 0; )
{
for (size_t j = 0; j < mCols; ++j)
{
double temp = mMatrix[i+1][j];
mMatrix[i+1][j] = mMatrix[i][j];
mMatrix[i][j] = temp;
}
}
}
}
There now you have a self contained Matrix class with a method that will shift each row down and wrap around the top row. For bonus points, you can play with variations of this nested loop to implement methods like shiftUp(), shiftLeft(), and shiftRight().