Matrix operations using classes

Partial Answer This does not cover all aspects of your code, so feel free to wait for other responses.

In OOP, it is important to identify the scope of an object. In your case, you have two input matrices and possibly a result matrix for the operation that the user selects. The key point is, that each matrix should be a distinguished instance of your matrix class. What you have is something like a matrix manager, that contains multiple matrices in a single instance.

When you re-design your matrix class to contain a single matrix, you should possibly externalize your user input logic. Also, the sum, diff and transpose functions could be external functions that take two matrices as parameters and return a resulting matrix. However, I guess it would also be ok to have them as member function that only takes the second matrix as parameter.

Consider the following class definition:

#include <vector>

class matrix {
private:
    // matrix with m columns and n rows
    int _m, _n;
    // values, organized as an outer vector of rows
    // and an inner vector of columns
    std::vector<std::vector<int>> _values;

public:
    // initialize matrix by its size
    matrix(int m, int n)
        : _m(m), _n(n)
    {
        // initialize the matrix size
        _values.resize(n);
        for (int i = 0; i < n; ++i)
        {
            _values[i].resize(m);
        }
    }

    // TODO:
    // - other constructors
    // - copy operator
    // - other desired functions
    // - assessors to the matrix elements
};

Maybe you can start from there.

Your code seems to be wrong for few reasons.

First is from the basics of matrices. They are 0 index based. Meaning that in your loops you have to start from 0, not from 1. So if you declare a matrix a[10][10] the the indexes will be from 0 to 9.Following this, you will have:

for (i=0; i<x; i++)  //since x is 10 you want to stop at the last index which is 9

If you only print the matrix operations results there is no need to save them somewhere, you can just print the results.Therefore you do not need to have the other matrices, two are enough. For example your sum function will be like this :

void matrix3::sum()
{
    cout << "Sum of Matrices 1 and 2 is\n";
    for (i=0; i<=x; i++)
    {
        for ( j=0; j<=y; j++)
        {
            cout << a[i][j]+c[i][j] << "";
        }
        cout << endl;
    }
}

Also, you do not have a constructor ( which is the method that initializes your object) . This can be your values function since it assigns values to your matrices.

matrix3 is a user defined data type and C++ gives you a lot of freedom to make it the way you want. However, if you make it overly complicated people cannot use it effectively. As a rule of thumb you should aim to make your data types behave roughly like an int because screwing up the usage of an int is pretty hard.

To add 2 ints you write something like this:

    int a = 1;
    int b = 2;
    int c = a + b;

Since we are aiming to mimic ints, the way we want to add matrices is this:

    matrix3 a = ...;
    matrix3 b = ...;
    matrix3 c = a + b;

To print a matrix we would simply do this: std::cout << c << '\n'.

What you did is combine a container (holding multiple objects) together with input/output and the actual functionality of matrix operations. You should try to make each class only have a single purpose. The only purpose that matrix3 should have is to do matrix operations.

Instead of writing an example by hand I'll refer you to eigen where they did all of this plus some other neat tricks.

Now imagine I did int c = a + b; and my output said "The sum of 1 and 2 is 3". That would suck. Your matrix3 shouldn't do that either.

If you want to define Matrix Operations in a class like way. You need to look at a matrix as an object (not a thing that holds three matrixes).

Matrix as an object.

What are the properties of a matrix?

1) Width
2) Height
3) Values  (Data)

What are the action that can be performed on a matrix.

1) Sum
2) Diff
3) Transpose

Looking at these properties I would define the following.

class Matrix
{
    std::size_t      width;
    std::size_t      height;
    std::vector<int> data;

    public:
        Matrix  sum(Matrix const& rhs);
        Matrix  diff(Matrix const& rhs);
        Matrix  transpose();
};

You also need to define a couple of standard functions (or disable some standard functions).

class Matrix
{
    public:
        // Create a matrix (of specified width/height with all data set to zero
        Matrix(int width, int height);

        // Copy a matrix
        Matrix(Matrix const& copy);

        // Allow people to set matrixes via assignment
        Matrix operator=(Matrix const& copy);

        // Input and output operations so you can print a matrix
        // And read a matrix from a stream (stdin/stdout)
        friend std::ostream operator<<(std::ostream& str, Matrix const& output);
        friend std::istream operator>>(std::istream& str, Matrix& input);
};

Once you have defined these you should be all set.