1 Replies - 165 Views - Last Post: 21 October 2012 - 04:25 PM Rate Topic: -----

#1 mgrex  Icon User is offline

  • D.I.C Head

Reputation: 3
  • View blog
  • Posts: 196
  • Joined: 25-March 10

Logical error Searching a Template vector array.

Posted 21 October 2012 - 04:17 PM

I have indicated the problem in line 46 of the following int_main. 12.87 does not exist in any of the array's index.

Int main()
// This program demonstrates the SearchableVector template . 
#include <iostream> 
#include "SearchableVector.h" 
using namespace std; 

int main() 
{
	const int SIZE = 10;		// Number of elements 
	int count;					// Loop counter 
	int result;					// To hold search results

	// Create 2 SearchableVector objects 
	SearchableVector<int> intTable(SIZE); 
	SearchableVector<double> doubleTable(SIZE); 
	
	// Store values in objects. 
	for (count = 0; count < SIZE; count++) 
	{ 
		intTable[count] = (count * 2); 
		doubleTable[count] = (count * 2.14); 
	} 

	// Display the values in the objects . 
	cout << "These values are in int Table:\n"; 
	for (count = 0; count < SIZE; count++) 
		{cout << intTable[count] << " "; }
	cout << endl << endl; 
	
	cout << "These values are in doubleTable:\n"; 
	for (count = 0; count < SIZE; count++) 
		cout << doubleTable [count] << " "; 
	cout << endl; 
	
	// Search for the value 6 in intTable . 
	cout << "\nSearching for 6 in intTable.\n"; 
	result = intTable.findItem(6); 
	if (result == -1) 
		cout << "6 was not found in intTable.\n"; 
	else 
		cout << "6 was found at subscript " << result << endl; 	 

	//////////////////////////////////////////////
	// Search for the value 12.84 in doubleTable. 
	cout << "\nSearching for 12.84 in doubleTable.\n" ; 
	//result = doubleTable.findItem(12.84);		//works fine, displays else statement
	result = doubleTable.findItem(12.87);	//Calls line 141 & 128 of SimpleVector header, instead of the next statement.
	if (result == -1) 
		cout<< "12.84 was not found in doubleTable.\n"; 
	else 
		cout << "12.84 was found at subscript " << result << endl; 

	system("pause");
	return 0;
}




SimpleVector.h
// SimpleVector class template declaration. Throughout the class declaration,
// the data type paramerer is used where you wish to support any data type.
// Benefit of doing a class template, is that we don't have to creater multiple classes
// for different primitive data types, that would perform error/bounds checking for 
// each of them.

#ifndef SIMPLEVECTOR_H 
#define SIMPLEVECTOR_H 
#include <iostream>		// Needed for bad_alloe exception 
#include <new>			// Needed for the exit function 
#include <cstdlib> 
using namespace std; 

template <class T> 
class SimpleVector 
{ 
private: 
	T *aptr;				// To point to the allocated array
	
	//*****************************************************************
	// arraySize member variable is declared as an int. This is because
	// it holds the size of the array, which will be an integer value, 
	// regardless of the data type of the array. This is also why 
	// the size member function returns an int.
	//*****************************************************************
	int	 arraySize;			// Number of elements in the array

	void memError();		// Handles memory allocation errors 
	void subError();		// Handles subscripts out of range

public: 
	// Default constructor 
	SimpleVector() 
		{	aptr = 0; arraySize = 0;	} 

	// Constructor declaration 
	SimpleVector(int);

	// Copy constructor declaration 
	SimpleVector(const SimpleVector &); 

	// Destructor declaration 
	~SimpleVector(); 


	// Accessor to return the array size 
	int size() const 
		{	return arraySize;	} 

	// Accessor to return a specific element 
	T getElementAt(int position); 

	// Overloaded [] operator declaration 
	T &operator[](const int &); 
}; 
 

//************************************************************
// Constructor for SimpleVector class. Sets the size of the  
// array and allocates memory for it. 
//************************************************************ 
template <class T> 
SimpleVector<T>::SimpleVector(int s) 
{ 
	arraySize = s; 
	// Allocote memory for the array. 
	try 
	{ 
		aptr = new T [s]; 
	}
	catch (bad_alloc) 
	{ 
		memError(); 
	} 
	
	// Initialize the array . 
	for (int count = 0; count < arraySize; count++) 
		*(aptr + count) = 0;
}

//*********************************************
// Copy Constructor for SimpleVector class. 
//********************************************* 
template <class T> 
SimpleVector<T>::SimpleVector(const SimpleVector &obj) 
{ 
	// Copy the array size. 
	arraySize = obj.arraySize; 

	// Allocate memory for the array. 
	aptr = new T[arraySize]; 
	if (aptr == 0) 
		memError(); 

	// Copy the elements of obj's array. 
	for(int count = 0; count < arraySize; count++) 
		*(aptr + count) = *(obj.aptr + count); 
}

//***************************************
// DestrUCtor for SimpleVector class. 
//***************************************
template <class T> 
SimpleVector<T>::~SimpleVector() 
{ 
	if (arraySize > 0) 
		delete [] aptr; 
} 

//************************************************************
// memError function. Displays an error message and
// terminates the program when memory allocation fails.
//************************************************************
template <class T> 
void SimpleVector<T>::memError() 
{ 
	cout << "ERROR:Cannot allocate memory.\n"; 
	exit(EXIT_FAILURE); 
} 

//************************************************************
// subError function. Displays an error message and 
// terminates the program when a subscript is out of range.
//************************************************************
template <class T> 
void SimpleVector<T>::subError() 
{  
	cout << "ERROR: Subscript out of range.\n"; 
	exit(EXIT_FAILURE); 
}

//*****************************************************
// getElementAt function. The argument is a subscript. 
// This function returns the value stored at the sub-
// cript in the array.
//*****************************************************
template <class T> 
T SimpleVector<T>::getElementAt(int sub) 
{
	if (sub < 0 || sub >= arraySize) 
		subError(); 
	return aptr[sub]; 
} 

//********************************************************* 
// Overloaded [] operator. The argument is a subscript. 
// This function returns a reference to the element  
// in the array indexed by the subscript.  
//*********************************************************
template <class T> 
T &SimpleVector<T>::operator[](const int &sub) 
{ 
	if (sub < 0 || sub >= arraySize) 
		subError(); 
	return aptr[sub]; 
}
#endif 


SearchableVector.h
//Applying class templates to an inherited class

#ifndef SEARCHABLEVECTOR_H 
#define SEARCHABLEVECTOR_H 
#include "SimpleVector.h"

template <class T> 
//**********************************************************
// Each time the name SimpleVector is used in the class template,
// the type, parameter T is used with it.
class SearchableVector : public SimpleVector<T> 
{ 
public : 
	//*******************************************
	// Default constructor
	// <T>, the type parameter, must be passed, 
	// since SimpleVector, is a class template.
	SearchableVector() : SimpleVector<T>() 
		{ } 

	// Constructor 
	SearchableVector(int size) : SimpleVector<T>(size) 
		{ } 

	// Copy constructor
	SearchableVector(const SearchableVector &); 

	//***************************************************************************
	// Accessor to find an item
	// Accepts an argument, and performs a simple linear search to determine
	// whether the argument's value is stored in the array. If the value is 
	// found in the array, its subscript is returned. Otherwise, -1 is returned. 
	int findItem(const T); 
};

//****************************************************** 
// Copy constructor 
//****************************************************** 
template <class T> 
SearchableVector<T>::SearchableVector(const SearchableVector &obj) :
						SimpleVector<T>(obj.size())
{ 
	for(int count = 0; count < this->size(); count++) 
		this->operator[](count) = obj[count]; 
} 

//****************************************************** 
// findItem function 
// This function searches for item. If item is found 
// the subscript is returned. Otherwise -1 is returned. 
//****************************************************** 
template <class T> 
int SearchableVector<T>::findItem(const T item) 
{ 
	for (int count = 0; count <= this->size(); count++) 
	{
		if (getElementAt(count) == item) 
			return count; 
	}
	return -1;
}
#endif 


Is This A Good Question/Topic? 0
  • +

Replies To: Logical error Searching a Template vector array.

#2 mgrex  Icon User is offline

  • D.I.C Head

Reputation: 3
  • View blog
  • Posts: 196
  • Joined: 25-March 10

Re: Logical error Searching a Template vector array.

Posted 21 October 2012 - 04:25 PM

I think i may have solved it.

Modifying the findItem function's, for loop, seemed to get the program to display the correct answer.

template <class T> 
int SearchableVector<T>::findItem(const T item) 
{ 
	for (int count = 0; count <= this->size()-1; count++) 
	{
		if (getElementAt(count) == item) 
			return count; 
	}
	return -1;
}
#endif 

This post has been edited by mgrex: 21 October 2012 - 04:27 PM

Was This Post Helpful? 0
  • +
  • -

Page 1 of 1