Go4Expert

Go4Expert (http://www.go4expert.com/)
-   C++ (http://www.go4expert.com/forums/cpp/)
-   -   Array addition using templates (http://www.go4expert.com/forums/array-addition-using-templates-t27251/)

tonydav43 30Nov2011 11:11

Array addition using templates
 
What I have to do is have 2 int array's and total the 2 and display it as array3. The Table.h file was created for us, and I have added the +operator and the print functions. When I run the program it crashes. If I take out the 2 lines in main.cpp that relate to array3, it compiles and displays array1 and array2 fine. Using the debugger, it seems to have an error in the +operator function, but I just cannot figure it out

Code:


//main

#include <iostream>
#include "Table.h"

using namespace std;

int main()
{
        Table<int> array1 (2,3);

        array1 (0,0) = 1;
        array1 (0,1) = 2;
        array1 (0,2) = 3;
        array1 (1,0) = 4;
        array1 (1,1) = 5;
        array1 (1,2) = 6;

        print (array1, 2,3);
       
        Table<int> array2 (2,3);

        array2 (0,0) = 7;
        array2 (0,1) = 8;
        array2 (0,2) = 9;
        array2 (1,0) = 10;
        array2 (1,1) = 11;
        array2 (1,2) = 12;

        print (array2, 2,3);

        Table<int> array3 = array1 + array2;

        print (array3, 2,3);

}

Code:

//Table.h

#ifndef TABLE_H
#define TABLE_H

template<typename T>

class Table
{
public:
        Table();
        Table(int m, int n);
        Table(int m, int n, const T& value);
        Table(const Table<T>& rhs);
        ~Table();

        Table<T>& operator = (const Table& rhs);
        Table<T> operator + (const Table& rhs);
        T& operator()(int i, int j);

        int numRows()const;
        int numCols()const;

        void resize(int m, int n);
        void resize(int m, int n, const T& value);
        void print(Table<T>& data, int x, int y);

private:
        void destroy();

private:
        int mNumRows;
        int mNumCols;
        T** mDataMatrix;
};

template <typename T>
Table<T>::Table()
{
        mDataMatrix = 0;
        mNumRows = 0;
        mNumCols = 0;
}

template <typename T>
Table<T>::Table(int m, int n)
{
        mDataMatrix = 0;
        mNumRows = 0;
        mNumCols = 0;
        resize(m, n, T());
}

template <typename T>
Table<T>::Table(int m, int n, const T& value)
{
        mDataMatrix = 0;
        mNumRows = 0;
        mNumCols = 0;
        resize(m, n, value);
}

template <typename T>
Table<T>::Table(const Table<T>& rhs)
{
        mDataMatrix = 0;
        mNumRows = 0;
        mNumCols = 0;
        *this = rhs;
}

template <typename T>
Table<T>::~Table()
{
        //Destroy any previous memory
        destroy();
}

template <typename T>
Table<T>& Table<T>::operator=(const Table& rhs)
{
        //Check for self assessment
  if( this == &rhs ) return *this;

  resize(rhs.mNumRows, rhs.mNumCols);

  for(int i = 0; i < mNumRows; ++i)
      for(int j = 0; j < mNumCols; ++j)
        mDataMatrix[i][j] = rhs.mDataMatrix[i][j];

  return *this;
}

template <typename T>
Table<T> Table<T>::operator + (const Table &rhs)
{
 
        Table<T> sum;

  for(int i = 0; i < mNumRows; ++i)

      for(int j = 0; j < mNumCols; ++j)
      {
        sum.mDataMatrix[i][j] = mDataMatrix[i][j] + rhs.mDataMatrix[i][j];
      }

  return sum;
}

template <typename T>
T& Table<T>::operator()(int i, int j)
{
        return mDataMatrix[i][j]; //Return the ijth table entry
}

template <typename T>
int Table<T>::numRows()const
{
        return mNumRows; //Return number of rows
}

template <typename T>
int Table<T>::numCols()const
{
        return mNumCols; //Return the number of cols
}

template <typename T>
void Table<T>::resize(int m, int n)
{
        resize(m, n, T()); //Call resize and use default constructor T()
        //as a value
}

template <typename T>
void Table<T>::resize(int m, int n, const T& value)
{
        //destroy previous data
        destroy();
        //Save dimensions
        mNumRows = m;
        mNumCols = n;

        //Allocate a row(array) of pointers
        mDataMatrix = new T*[mNumRows];

        //Loop through each pointer in this row array
        for(int i = 0; i < mNumRows; ++i)
        {
                //Allocate a col for the ith row to build the table
                mDataMatrix[i] = new T[mNumCols];

                //Loop through each element in this row[i] and copy value into it
                for(int j = 0; j < mNumCols; ++j)
                        mDataMatrix[i][j] = value;
        }
}

template <typename T>
void Table<T>::destroy()
{
        //Does the matrix exist
        if(mDataMatrix)
        {
                //Iterate over each row i
                for(int i = 0; i < mNumRows; ++i)
                {
                        //Does the ith col array exist
                        if(mDataMatrix[i])
                        {
                                //Yes delete it
                                delete[]mDataMatrix[i];
                                mDataMatrix[i] = 0;
                        }
                }
                //Now delete the row array
                delete[] mDataMatrix;
                mDataMatrix = 0;
        }
//Table destroyed so dimensions are zero
        mNumRows = 0;
        mNumCols = 0;

}

template <typename T>
void print(Table<T>& data, int x, int y)
{
        for(int i = 0; i < x; ++i)
        {
                cout << "{";
                for(int j = 0; j < y; ++j)
                        cout << data(i, j) << " ";
                cout << "}" << endl;
        }
}


#endif



All times are GMT +5.5. The time now is 19:49.