Can someone help with my seg fault?
My code produces a segmentation fault. I was hoping someone could analyze my code and alert me how to avoid causing it. I have a generic TreeItem, everything extends it in order for a Tree to contain integers, doubles, strings, and Tree's themselves. Thanks
Code:
#include <iostream>
#include <sstream>
#include <string>
#include <typeinfo>
using namespace std;
//Abstract class for entire hierarchy
class TreeItem
{
public:
virtual string toString()=0;
virtual ~TreeItem();
};
//need here because one of the classes uses a node
class Node
{
private:
TreeItem *value;
Node *left;
Node *right;
public:
//Constructors
Node( TreeItem *value );
Node();
//Accessors
TreeItem* getValue(); //fetch the data
Node* getLeft();
Node* getRight();
//Mutators
void setRight( Node* right );
void setLeft( Node* left );
//Other class functions
void insert( TreeItem *value );
double total();
string toString();
string print(); //used for tree's
};
//Subclass (A string)
class StringTreeItem : public TreeItem
{
private:
string value;
public:
StringTreeItem( string value );
string toString();
};
//Subclass (A tree)
class ActualTreeItem : public TreeItem
{
private:
Node *root;
public:
ActualTreeItem();
double total();
string toString();
void insert( TreeItem *value );
};
//Abstract subclass for numeric value hiearchy
//Subclass Hierarchy
class NumericTreeItem : public TreeItem
{
public:
virtual ~NumericTreeItem();
};
class FloatTreeItem : public NumericTreeItem
{
private:
double value;
public:
FloatTreeItem( double value );
double getValue();
string toString();
};
class IntTreeItem : public NumericTreeItem
{
private:
int value;
public:
IntTreeItem( int value );
int getValue();
string toString();
};
//End subclass hierarchy
//End Entire Hiearchy
//Class Methods
//TreeItem
TreeItem::~TreeItem(){}
//StringTreeItem
StringTreeItem::StringTreeItem( string value )
{
this->value = value;
}
string StringTreeItem::toString()
{
return value; //already a string
}
//ActualTreeItem
//null constructor
ActualTreeItem::ActualTreeItem()
{
root = NULL;
}
//need to change/fix, for now its just a dummy method
string ActualTreeItem::toString()
{
string result = "\nempty list";
if( root != NULL )
{
result = root->print();
}
return result;
}
double ActualTreeItem::total()
{
double result;
//need to find the total of all numeric value in current list,
//ignoring strings and other trees stored as data
if( root != NULL )
{
result = root->total();
}
return result;
}
//fix this code
void ActualTreeItem::insert( TreeItem *value )
{
//Do ordered inserts
if( root == NULL )
{
root = new Node( value );
}
else
{
root->insert( value ); //recursive insert
}
}
//NumericTreeItem
NumericTreeItem::~NumericTreeItem(){}
//IntTreeItem
////constructor
IntTreeItem::IntTreeItem( int value )
{
this->value = value;
}
int IntTreeItem::getValue()
{
return value;
}
string IntTreeItem::toString()
{
stringstream stream;
string retValue;
//do conversion
stream << value;
stream >> retValue;
return retValue;
}
//FloatTreeItem
//constructor
FloatTreeItem::FloatTreeItem( double value )
{
this->value = value;
}
double FloatTreeItem::getValue()
{
return value;
}
string FloatTreeItem::toString()
{
stringstream stream;
string retValue;
//do conversion
stream << value;
stream >> retValue;
return retValue;
}
//Node
//constructor
Node::Node( TreeItem *value )
{
this->value = value;
this->left = NULL;
this->right = NULL;
}
Node::Node()
{
this->value = NULL;
this->left = NULL;
this->right = NULL;
}
TreeItem* Node::getValue()
{
return value;
}
Node* Node::getLeft()
{
return left;
}
Node* Node::getRight()
{
return right;
}
void Node::setLeft( Node* left )
{
this->left = left;
}
void Node::setRight( Node* right )
{
this->right = right;
}
void Node::insert( TreeItem *value )
{
//code here
if( value != NULL )
{
if( value->toString() < this->toString() )
{
if( this->getLeft() == NULL )
{
this->setLeft( new Node( value ) ); //need &?? or is this expression ok?
}
else
{
this->getLeft()->insert( value );
}
}
else if( value->toString() > this->toString() )
{
if( this->getRight() == NULL )
{
this->setRight( new Node( value ) );
}
else
{
this->getRight()->insert( value );
}
}
//if identical, do nothing...no duplicate inserts
}
}
double Node::total()
{
double result = 0;
if( this->getLeft() != NULL )
{
result += this->getLeft()->total(); //it gets added
}
try
{
result += (double)( ( dynamic_cast<IntTreeItem*>( this->getValue() ) )->getValue() ); //cast TreeItem down to IntTreeItem, envoke it's value method, then convert to double
throw 1;
}
catch( int i )
{
//do nothing
}
try
{
result += ( ( dynamic_cast<FloatTreeItem*>( this->getValue() ) )->getValue() ); //cast TreeItem down to FloatTreeItem, envoke it's value method (which gives a double)
throw 1;
}
catch( int i )
{
//do nothing
}
if( this->getRight() != NULL )
{
result += this->getRight()->total(); //it gets added
}
return result;
}
string Node::toString()
{
return this->getValue()->toString();
}
//only called by tree's
string Node::print()
{
string result = "<";
//probably need formatting
if( this->getLeft() != NULL )
{
result += "<";
result += this->getLeft()->print();
}
else
{
result += "<>";
}
result += this->getValue()->toString();
if( this->getRight() != NULL )
{
result += ">";
result += this->getRight()->print();
}
else
{
result += "<>";
}
return result;
}
//End Class Methods
int main ()
{
ActualTreeItem BinaryTree1,
BinaryTree2;
BinaryTree1.insert( new IntTreeItem( 10 ) );
BinaryTree1.insert( new FloatTreeItem( 5.5 ) );
BinaryTree1.insert( new StringTreeItem( "Ralph" ) );
BinaryTree1.insert( new StringTreeItem( "Alice" ) );
BinaryTree1.insert( new IntTreeItem( 20 ) );
BinaryTree1.insert( new IntTreeItem( 30 ) );
BinaryTree1.insert( new StringTreeItem( "Ed" ) );
cout << BinaryTree1.toString();
cout << "\nTotal: ";
cout << BinaryTree1.total();
BinaryTree2.insert( &BinaryTree1 );
BinaryTree2.insert( new StringTreeItem( "Ralph" ) );
BinaryTree2.insert( new IntTreeItem( 1 ) );
BinaryTree2.insert( new StringTreeItem( "Ed" ) );
BinaryTree2.insert( new FloatTreeItem( 99.5 ) );
cout << BinaryTree2.toString();
cout << "\nTotal: ";
cout << BinaryTree2.total();
delete
cout << "\n\nEnd processing...\n";
return (1);
}
