C++ Vector and Matrix - c++

Question

I'm trying to implement a program which is able to compute a matrix-product.
GOAL: Input v or m and the program automatically computes dot-product, matrix-vector product or matrix product.
The program is working for vectors, and quadratic-matrices but for non-quadratic-matrices the program crashes with.
terminate called after throwing an instance of 'std::out_of_range'
what(): vector::_M_range_check: __n (which is 1) >= this->size() (which is 1)
I'm not sure if the function matrix_input() really is the issue or if my way to enter 2D-Vektors is wrong.
When I input m 2 1 1 2 m 1 2 2 1 the program crashes in the function matrix_input() because it outputs error-2, error-3 not anymore.
I have noticed that the program crashes because in the second matrix the last row doesn't exist or something similar.
#include <iostream>
#include <vector>
#include <cassert>
using namespace std;
//Checks if input is a matrix or vector
//PRE: Char v or m
//POST: Returns number of the char 1 or 2 or 0 as error
int m_or_v(char m_v) {
if(m_v=='v')
return 1;
else if(m_v=='m')
return 2;
assert("error");
return 0;
}
//Inputs a vector if input was 'v'
//PRE: Takes vector
//POST: Checks length of the vector, inputs values into the vector
void vector_input(vector<int> &vector_v) {
int row = 0;
cin >> row;
int cache = 0;
for(int i = 0;i<row;i++) {
cin >> cache;
vector_v.push_back(cache);
}
}
//Inputs a matrix if input was 'm'
//PRE: Takes matrix
//POST: Checks number row, col and inputs the values into the matrix
void matrix_input(vector<vector<int>> &matrix_m) {
int row = 0;
int col = 0;
int cache_m = 0;
cin >> row;
cin >> col;
for(int r = 0;r<row;r++) {
vector<int> empty = {};
cout << "error-1";
for(int c = 0;c<col;c++) {
cin >> cache_m;
empty.push_back(cache_m);
cout << "error-2";
}
//I believe the program crashes in at this point, because the last row doesn't exist.
matrix_m.push_back(empty);
}
cout << "error-3";
}
//Computes the dot product if the input were two vectors
void scalar_product(const vector<int> &vector_1,const vector<int> &vector_2) {
int value = 0;
if(vector_1.size()==vector_2.size()) {
for(unsigned long i = 0;i<vector_1.size();i++) {
value += (vector_1.at(i)*vector_2.at(i));
}
cout << "s" << endl;
cout << value;
}
else
cout << "error";
}
//Checks if dot product, matrix-vector product or matrix product
int mult_mode(int mode1, int mode2) {
if(mode1==1&&mode2==2) {
cout << "error";
return 0;
}
else if(mode1==1&&mode2==1)
return 1;
else if((mode1==2&&mode2==1)||(mode1==1&&mode2==2))
return 2;
else if(mode1==2&&mode2==2)
return 3;
else {
cout << "error";
return 0;
}
}
//Check if Matrix-Vektor Product is possible
bool mvp_valid(const vector<vector<int>> &matrix_1,
const vector<int> &vector_2) {
if(matrix_1.at(0).size()==vector_2.size())
return true;
return false;
}
//Computes Vector-Matrix product
void mvp_result(const vector<vector<int>> &matrix_1,
const vector<int> &vector_2, vector<int> &result) {
int cache = 0;
for(unsigned long row = 0;row<matrix_1.size();row++) {
for(unsigned long col = 0;col<vector_2.size();col++) {
cache += matrix_1.at(row).at(col)*vector_2.at(col);
}
result.push_back(cache);
cache = 0;
}
}
//Outputs a vector
void output_v(vector<int> &vec) {
cout << "v " << vec.size() << endl;
for(unsigned long i = 0;i<vec.size();i++) {
cout << vec.at(i) << " ";
}
}
//Check if Matrix x Matrix is valid
bool mxm_valid(
const vector<vector<int>> &matrix_1,
const vector<vector<int>> &matrix_2) {
if(matrix_1.at(0).size()==matrix_2.size())
return true;
return false;
}
//Computes the matrix-matrix product
void mxm_result(
const vector<vector<int>> &matrix_1,
const vector<vector<int>> &matrix_2,
vector<vector<int>> &result_m) {
int cache = 0;
vector<int> empty;
for(unsigned long row = 0;row<matrix_1.size();row++) {
result_m.push_back(empty);
for(unsigned long col = 0;col<matrix_2.at(row).size();col++) {
for(unsigned long row_col = 0;row_col<matrix_2.size();row_col++) {
cache+=matrix_1.at(row).at(row_col)*matrix_2.at(row_col).at(col);
}
result_m.at(row).push_back(cache);
cache = 0;
}
}
}
//Outputs a matrix
void output_m(const vector<vector<int>> &matx) {
for(unsigned long col = 0;col<matx.size();col++) {
for(unsigned long row = 0;row<matx.size();row++) {
cout << matx.at(col).at(row) << " ";
}
cout << endl;
}
}
//Outputs the size of the matrix
void size_m(const vector<vector<int>> &matx) {
cout<<"m "<<matx.size()<<" "<<matx.at(0).size()<<endl;
}
int main() {
char mode_c = ' ';
int mode1 = 0;
int mode2 = 0;
vector<int> vector_1;
vector<vector<int>> matrix_1;
vector<int> vector_2;
vector<vector<int>> matrix_2;
//Vector or Matrix Number 1
cin >> mode_c;
mode1 = m_or_v(mode_c);
if(mode1==1) {
vector_input(vector_1);
}
else if(mode1==2) {
matrix_input(matrix_1);
}
//Vector or Matrix Number 2
cin >> mode_c;
mode2 = m_or_v(mode_c);
if(mode2==1) {
vector_input(vector_2);
}
else if(mode2==2) {
cout << "error-10";
matrix_input(matrix_2);
cout << "error-11";
}
switch(mult_mode(mode1, mode2)) {
case 1:
scalar_product(vector_1,vector_2);
break;
case 2:
if(mvp_valid(matrix_1, vector_2)==true) {
vector<int> result;
mvp_result(matrix_1, vector_2, result);
output_v(result);
}
else
cout << "error";
break;
case 3:
if(mxm_valid(matrix_1, matrix_2)==true) {
vector<vector<int>> result_m;
mxm_result(matrix_1, matrix_2, result_m);
size_m(result_m);
output_m(result_m);
}
else
cout << "error";
break;
}
}