1. We have moved from vBulletin to XenForo and you are viewing the site in the middle of the move. Though the functional aspect of everything is working fine, we are still working on other changes including the new design on Xenforo.
    Dismiss Notice

Array addition using templates

Discussion in 'C++' started by tonydav43, Nov 30, 2011.

  1. tonydav43

    tonydav43 New Member

    Joined:
    Aug 10, 2011
    Messages:
    22
    Likes Received:
    0
    Trophy Points:
    0
    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 
    
     

Share This Page