First chance exception without compiling errors

Question

The code I wrote compiles without errors thus I don't know the reason an error is ocurring.

#pragma once
class Macierz
{
public:
class Wiersz
{
public:
    int *tab;
    int dlugosc;
    Wiersz(int d);
};

int x;
int y;
Wiersz *wiersze;
public:
Macierz(int m, int n);
Macierz(Macierz &m);

Macierz & operator+(Macierz &m);
Macierz & operator-(Macierz &m);
Macierz & operator*(Macierz &m);
Macierz & operator=(Macierz &m);
int& operator()(int x, int y);
string to_String();

};

#include "stdafx.h"
#include "Macierz.h"


Macierz::Macierz(int _x, int _y) :x(_x), y(_y)
{
Wiersz **tab = new Wiersz*[_x];
for (int i = 0; i < x; i++)
    tab[i] = new Wiersz(_y);
wiersze = *tab;
}


Macierz::Macierz(Macierz &m) :Macierz(m.x, m.y)
{
for (int i = 0; i < x; i++)
    for (int j = 0; j < y; j++)
        wiersze[i].tab[j] = m.wiersze[i].tab[j];
}




Macierz & Macierz::operator+(Macierz &m)
{
if (x != m.x || y != m.y) throw "Macierze maja rozne rozmiary";
Macierz *temp = new Macierz(m);

for (int i = 0; i < x; i++)
    for (int j = 0; j < y; j++)
        (*temp).wiersze[i].tab[j] += wiersze[i].tab[j];

return *temp;
}


Macierz & Macierz::operator-(Macierz &m)
{
if (x != m.x || y != m.y) throw "Macierze maja rozne rozmiary";
Macierz *temp = new Macierz(m);

for (int i = 0; i < x; i++)
    for (int j = 0; j < y; j++)
        (*temp).wiersze[i].tab[j] -= wiersze[i].tab[j];

return *temp;
}


Macierz & Macierz::operator*(Macierz &m)
{
Macierz *temp;
if (x == m.y)
{
    temp = new Macierz(m.x, y);
    for (int i = 0; i < (*temp).x; i++)
        for (int j = 0; j < (*temp).y; j++)
            for (int l = 0; l < m.y; l++)
                (*temp).wiersze[i].tab[j] += wiersze[i].tab[l] * m.wiersze[l].tab[j];

}
else if (y == m.x)
{
    temp = new Macierz(x, m.y);
    for (int i = 0; i < (*temp).x; i++)
        for (int j = 0; j < (*temp).y; j++)
            for (int l = 0; l < y; l++)
                (*temp).wiersze[i].tab[j] += wiersze[i].tab[l] * m.wiersze[l].tab[j];
}
else throw "Rozmiary macierzy sie nie zgadzaja";

return *temp;
}


Macierz & Macierz::operator=(Macierz &m)
{
for (int i = 0; i < x; i++)
    for (int j = 0; j < y; j++)
        wiersze[i].tab[j] = m.wiersze[i].tab[j];

return *this;
}


int& Macierz::operator()(int x, int y)
{
return wiersze[x].tab[y];
}


Macierz::Wiersz::Wiersz(int i)
{
dlugosc = i;
tab = new int[dlugosc];
}


string Macierz::to_String()
{

std::ostringstream str;
str << "|";
for (int i = 0; i < x; i++)
{
    for (int j = 0; j < y; j++)
        str << wiersze[j].tab[i] << ",";
    str << "\b|\n";
}

return str.str();
}

Using constructor in main doesn't crash the program:

Macierz m1(1,1);

However there seems to be a problem with accesing to certain data field, e.g.

 m1(0,0) = 1;

(at least this is a code line at which some yellow arrow points)

Program is used for operations on matrix(+, -, *). I wrote a program in similar fashion for euclidean vector operations which works perfectly.

Thanks for help in advance.

Always show relevant ([SCCE](http://meta.stackexchange.com/questions/22754/sscce-how-to-provide-examples-for-programming-questions)) code here and not linked from other sites. — crashmstr, Jan 06 '15 at 12:51
Run the debug-build in the debugger. The debugger will stop at the location of the crash, and let you examine the function call stack, as well as all variables. — Some programmer dude, Jan 06 '15 at 12:51

score 1 · Accepted Answer · edited May 23 '17 at 12:06

There are a lot of issues in your code that will result in problems:

Your constructor Macierz(int _x, int _y) doesn't work like you think it does. Only wiersze[0] will be valid after it finishes and any non-zero index will access unknown memory. The issue is really with your design of your 2D matrix class. I would get rid of the manually managed memory and just use a 2D vector vector<vector<int>> or even just a flat 1D vector and manage the index manually.
Your copy constructor Macierz(Macierz &m) doesn't allocate memory for the new matrix and thus you are writing to unknown memory.
All your binary operators (+, -, *) allocate a new object and return it which will result in leaked memory. The canonical way is usually to modify the object and just return *this; for such operators. See this question for more details on operator overloading.
Your copy operator Macierz::operator=(Macierz &m) doesn't check if the matrix is the same size or not. If it isn't the same size you'd need to destroy and reallocate the matrix.
Your Macierz::operator()(int x, int y) doesn't check the input indexes which may be on purpose but you may consider throwing an exception like with your other methods.
You have no destructor which will result in leaked memory, although if you use a vector<> you wouldn't need one.

If you really need/want to implement a 2D matrix class from scratch you can search online for a large variety of existing code, like this one, as examples of what to do.

score 0 · Answer 2 · answered Jan 06 '15 at 12:59

0

As there is a lot of pointers arithmetic, I bet that this is a memory access issue.
Anyway, as you are using C++, you should leverage of a matrix class instead of reinventing the wheel ...
For example Basic Linear Algebra Library with his matrix class is a top reference.
With such a class, while compiled in debug mode, memory access is checked and helps you to quickly wrong index.

answered Jan 06 '15 at 12:59

Jean Davy

2,062
1
19
24

Wish I could use basic classes. I need to sort of reinvent a wheel for my classes. – user4165421 Jan 06 '15 at 13:00
So have a look how this class is built, and insert index checking in your own – Jean Davy Jan 06 '15 at 13:04

First chance exception without compiling errors

2 Answers2