LinuxQuestions.org
Welcome to the most active Linux Forum on the web.
Go Back   LinuxQuestions.org > Forums > Non-*NIX Forums > Programming
Reload this Page glibc detected?
User Name
Password
Programming This forum is for all programming questions.
The question does not have to be directly related to Linux and any language is fair game.

Notices

Reply
 
LinkBack Search this Thread
Old 11-19-2005, 12:29 PM   #1
TurtleFace
Member
 
Registered: Jul 2005
Distribution: Mandrake LE 2005
Posts: 51

Rep: Reputation: 15
glibc detected?

hey i'm doing a project in c++ for one of my classes where you have to read some infix expressions from a file change them into postfix than evaluate them and output to the file however i keep getting this error when i run it:
*** glibc detected *** double free or corruption (fasttop): 0x0804d270 ***
Aborted
it occurs after the code has done what i want it to i have it set up to just output the data it read from the file
this is the main for my code
Code:
#include <iostream>
#include <fstream>
#include <string>
#include <cassert>
#include <cctype>
#include "Queue.h"
#include "LinkedList.h"
#include "Stack.h"
using namespace std;

Queue<string> readerQueue;
Stack<char> opStack;
Stack<char> evalStack;
LinkedList<int> varList;

string toPostfix(string exp);
void evaluate(string exp);

int main() {
	ifstream  fin;
	fin.open("myfile.txt");
	assert(fin.is_open());
	string reading;
	for ( ;; ) {
		getline(fin, reading);
		if (fin.eof()) {
			break;
			}
		readerQueue.push(reading);
		}
	fin.close();
	string temp;
	while (!readerQueue.isEmpty()) {
		temp = readerQueue.peek();
		cout << readerQueue.getSize() << " " << temp << endl;
		readerQueue.pull();
		}
	/*while (!readerQueue.isEmpty()) {
		temp = toPostfix(readerQueue.peek());
		evaluate(temp);
		readerQueue.pull();
		}
	ofstream fout("output.txt");
	assert(fout.is_open());
	fout << varList.print();
	fout.close();
	cout << "Processing comlete." << endl;*/
	return 0;
	}
/* Converts an infix expression to postfix
   pre - infix expression is passed
   post - postfix expression is returned */
inline string toPostfix(string exp) {
	char token, topToken;
	string postfixExp;
	for (int i = 0 ; i < exp.size() ; i ++) {
		token = exp[i];
		switch (token) {
			case ' ' : 	break;

			case '=' :	opStack.push(token);
					break;

			case '(' :	opStack.push(token);
					break;

			case ')' :	for ( ;; ) {
						assert (!opStack.isEmpty());
						topToken = opStack.peek();
						opStack.pop();
						if (topToken == '(') {
							break;
							}
						postfixExp.append(" " + topToken);
						}
					break;

			case '+' :
			case '-' :
			case '*' :
			case '/' :
			case '%' :	for ( ;; ) {
						if (opStack.isEmpty() || opStack.peek() == '(' ||
						(token == '*' || token == '/' || token == '%') && (opStack.peek() == '+' || opStack.peek() == '-')) {
							opStack.push(token);
							break;
							}
						else {
							topToken = opStack.peek();
							opStack.pop();
							postfixExp.append(" " + topToken);
							}
						}
					break;

			default:	//operand
					postfixExp.append(" " + token);
					for ( ;; ) {
						if (!isalnum(exp[i+1])) {
							break;
							}
						i++;
						token = exp[i];
						postfixExp.append(1, token);
						}
			}
		}
	//Pop remaining operators on the stack
	for ( ;; ) {
		if (opStack.isEmpty()) {
			break;
			}
		topToken = opStack.peek();
		opStack.pop();
		if (topToken != '(') {
			postfixExp.append(" " + topToken);
			}
		else {
			cerr << "***ERROR IN INFIX EXPRESSION***" << endl;
			break;
			}
		}
	return postfixExp;
	}

/* Evaluates a postfix expression
   pre - postfix expression is passed
   post - after evaluation, values inserted into a list */
inline void evaluate(string exp) {
	char token, upperTok, lowerTok;
	int holder, upper, lower;
	for (int i = 0 ; i < exp.size() ; i ++) {
		token = exp[i];
		switch (token) {
			case ' ' : 	break;

			case '+' :
			case '-' :
			case '*' :
			case '/' :
			case '%' :	upperTok = evalStack.peek();
					evalStack.pop();
					lowerTok = evalStack.peek();
					evalStack.pop();
					if (isalpha(lowerTok)) {
						lower = varList.getValue(lowerTok);
						}
					else {
						lower = (int)lowerTok;
						}
					if (isalpha(upperTok)) {
						upper = varList.getValue(upperTok);
						}
					else {
						upper = (int)upperTok;
						}
					switch (token) {
						case '+' :	holder = lower + upper;
								break;

						case '-' :	holder = lower - upper;
								break;

						case '*' :	holder = lower * upper;
								break;

						case '/' :	holder = lower / upper;
								break;

						case '%' :	holder = lower % upper;
								break;
						}
					evalStack.push((char)holder);
					break;

			case '=' :	upperTok = evalStack.peek();
					evalStack.pop();
					lowerTok = evalStack.peek();
					evalStack.pop();
					if (isalpha(upperTok) && !isalpha(lowerTok)) {
						varList.insert(upperTok, (int)lowerTok);
						break;
						}
					else {
						varList.insert(lowerTok, (int)upperTok);
						break;
						}

			default:	//operand
					evalStack.push(token);
					break;	
				}
		}
	}
this is queue.h i think this is where the problems lies because all im trying to do is pull() the data from the queue
Code:
#ifndef QUEUE
#define QUEUE

# include <iostream>
using namespace std;

template <typename ElementType>
class Queue {
	private:
		class Node {
			public:
				ElementType data;
				Node * next;
				Node (ElementType newData, Node * link = NULL): data(newData), next(link) {}
			};
		typedef Node * NodePointer;
	
	public:
		Queue();
		Queue(const Queue<ElementType> &);
		~Queue();
		bool isEmpty() const;
		int getSize() const;
		void push(ElementType);
		ElementType peek();
		void pull();
		void display(ostream & out) const;
		const Queue<ElementType> & operator= (const Queue<ElementType> &);
	
	private:
		int size;
		NodePointer head;
		NodePointer top;
	};

template <typename ElementType>
Queue<ElementType>::Queue(): size(0) {
	ElementType garbage;
	head = new Node(garbage, NULL);
	top = head;
	}

template <typename ElementType>
Queue<ElementType>::Queue(const Queue<ElementType> & original) {
	size = original.size;
	if (head->next == NULL) {
		head->next = NULL;
		}
	else {
		NodePointer origPtr = original.head->next;
		NodePointer newPtr = new Node(origPtr->data);
		head->next = newPtr;
		for (origPtr = origPtr->next ; origPtr != NULL ; origPtr = origPtr->next) {
			newPtr->next = new Node(origPtr->data);
			newPtr = newPtr->next;
			}
		}
	}

template <typename ElementType>
Queue<ElementType>::~Queue() {
	NodePointer deletePtr = head->next;
	while (deletePtr != NULL) {
		head->next = deletePtr->next;
		delete deletePtr;
		deletePtr = head->next;
		}
	}

template <typename ElementType>
bool Queue<ElementType>::isEmpty() const {
	return (top == head);
	}

template <typename ElementType>
int Queue<ElementType>::getSize() const {
	return size;
	}

template <typename ElementType>
void Queue<ElementType>::push(ElementType item) {
	if (top == head) {
		head->next = new Node(item);
		top = head->next;
		}
	else {
		NodePointer newPtr = new Node(item);
		top->next = newPtr;
		top = newPtr;
		}
	size++;
	}

template <typename ElementType>
ElementType Queue<ElementType>::peek() {
	if (isEmpty()) {
		cerr << "Queue empty unable to return value." << endl
		     << "Returning garbage data." << endl;
		ElementType garbage;
		return garbage;
		}
	NodePointer ptr = head->next;
	return ptr->data;
	}

template <typename ElementType>
void Queue<ElementType>::pull() {
	if (isEmpty()) {}
	else if (top == head->next) {
		delete top;
		top = head;
		size--;
		}
	else {
		NodePointer ptr = head->next;
		head->next = ptr->next;
		delete ptr;
		size--;
		}
	}

template <typename ElementType>
void Queue<ElementType>::display(ostream & out) const {
	NodePointer currentPtr = head->next;
	while (currentPtr != NULL) {
		out << currentPtr->data << " ";
		currentPtr = currentPtr->next;
		}
	out << endl;
	}

template <typename ElementType>
const Queue<ElementType> & Queue<ElementType>::operator= (const Queue<ElementType> & original) {
	if (this != original) {
		NodePointer deletePtr = head->next;
		while (deletePtr != NULL) {
			head->next = deletePtr->next;
			delete deletePtr;
			deletePtr = head->next;
			}
		size = original.size;
		if (isEmpty()) {
			head->next = NULL;
			top = head;
			}
		else {
			NodePointer origPtr = original.head->next;
			NodePointer newPtr = new Node(origPtr->data);
			head->next = newPtr;
			for (origPtr = origPtr->next ; origPtr != NULL ; origPtr = origPtr->next) {
				newPtr->next = new Node(origPtr->data);
				newPtr = newPtr->next;
				}
			}
		}
	return * this;
	}

template <typename ElementType>
ostream & operator<< (ostream & out, const Queue<ElementType> & queue) {
	queue.display(out);
	return out;
	}
#endif
 
Old 11-19-2005, 12:30 PM   #2
TurtleFace
Member
 
Registered: Jul 2005
Distribution: Mandrake LE 2005
Posts: 51

Original Poster
Rep: Reputation: 15
forgot the myfile.txt contains this
Code:
A = 5

B = 1

C = A + B

D = C * C
 
Old 11-19-2005, 12:35 PM   #3
TurtleFace
Member
 
Registered: Jul 2005
Distribution: Mandrake LE 2005
Posts: 51

Original Poster
Rep: Reputation: 15
might as well include the other headers os you can compile
linkedlist.h
Code:
#ifndef LINKEDLIST
#define LINKEDLIST

#include <iostream>
#include <cctype>
#include <string>
using namespace std;

template <typename ElementType>
class LinkedList {
	private:
		class Node {
			public:
				char variable;
				ElementType value;
				Node * next;
				Node (char newVar, ElementType newValue, Node * link = NULL): variable(toupper(newVar)), value(newValue), next(link) {}
			};
		typedef Node * NodePointer;
	
	public:
		LinkedList();
		LinkedList(const LinkedList<ElementType> &);
		~LinkedList();
		ElementType getValue(char) const;
		bool isEmpty() const;
		bool isMember(char)const;
		int getSize() const;
		void insert(char, ElementType);
		void remove(char);
		string print() const;
		void display(ostream & out) const;
		const LinkedList<ElementType> & operator= (const LinkedList<ElementType> & original);
	
	private:
		bool search(char, NodePointer &);
		NodePointer head;
		int size;
	};

template <typename ElementType>
LinkedList<ElementType>::LinkedList(): size(0) {
	char garbage;
	ElementType trash;
	head = new Node(garbage, trash, NULL);
	}

template <typename ElementType>
LinkedList<ElementType>::LinkedList(const LinkedList<ElementType> & original) {
	size = original.size;
	if (head->next == NULL) {
		head->next = NULL;
		}
	else {
		NodePointer origPtr = original.head->next;
		NodePointer newPtr = new Node(origPtr->vairable, origPtr->value);
		head->next = newPtr;
		for (origPtr = origPtr->next ; origPtr != NULL ; origPtr = origPtr->next) {
			newPtr->next = new Node(origPtr->vairable, origPtr->value);
			newPtr = newPtr->next;
			}
		}
	}

template <typename ElementType>
LinkedList<ElementType>::~LinkedList() {
	NodePointer deletePtr = head->next;
	while (deletePtr != NULL) {
		head->next = deletePtr->next;
		delete deletePtr;
		deletePtr = head->next;
		}
	}

template <typename ElementType>
ElementType LinkedList<ElementType>::getValue(char var) const {
	NodePointer currentPtr = head->next;
	while (currentPtr != NULL) {
		if (toupper(var) == toupper(currentPtr->variable)) {
			return currentPtr->value;
			}
		currentPtr = currentPtr->next;
		}
	cerr << "VARIABLE NOT IN LIST" << endl;
	ElementType garbage;
	return garbage;
	}

template <typename ElementType>
bool LinkedList<ElementType>::isEmpty() const {
	return (head->next == NULL);
	}

template <typename ElementType>
bool LinkedList<ElementType>::isMember(char var) const {
	bool state = false;
	if (this.isEmpty()) {}
	else {
		NodePointer currentPtr = head->next;
		while (currentPtr != NULL) {
			if (var == currentPtr->variable) {
				state = true;
				break;
				}
			currentPtr = currentPtr->next;
			}
		}
	return state;
	}

template <typename ElementType>
int LinkedList<ElementType>::getSize() const {
	return size;
	}

template <typename ElementType>
void LinkedList<ElementType>::insert(char name, ElementType item) {
	NodePointer trailPtr = NULL;
	if (!search(name, trailPtr)) {
		NodePointer newPtr = new Node(name, item);
		size++;
		if (trailPtr == NULL) {
			newPtr->next = head->next;
			head->next = newPtr;
		}
		else {
			newPtr->next = trailPtr->next;
			trailPtr->next = newPtr;
			}
		}
	}

template <typename ElementType>
void LinkedList<ElementType>::remove(char name) {
	NodePointer deletePtr, trailPtr = NULL;
	if (search(name, trailPtr)) { 
		if (trailPtr == NULL) {
			deletePtr = head->next;
			head->next = deletePtr->next;
			}
		else {
			deletePtr = trailPtr->next;
			trailPtr->next = deletePtr->next;
			}
		delete deletePtr;
		size--;
		}
	}

template <typename ElementType>
string LinkedList<ElementType>::print() const {
	NodePointer currentPtr = head->next;
	string output;
	while (currentPtr != NULL) {
		output += currentPtr->variable;
		output += "=";
		output += (char)currentPtr->value;
		output += " ";
		currentPtr = currentPtr->next;
		}
	return output;
	}
template <typename ElementType>
void LinkedList<ElementType>::display(ostream & out) const {
	NodePointer currentPtr = head->next;
	while (currentPtr != NULL) {
		out << currentPtr->variable << "=" << currentPtr->value << " ";
		currentPtr = currentPtr->next;
		}
	out << endl;
	}

template <typename ElementType>
const LinkedList<ElementType> & LinkedList<ElementType>::operator= (const LinkedList<ElementType> & original) {
	if (this != & original) {
		NodePointer deletePtr = head->next;
		while (deletePtr != NULL) {
			head->next = deletePtr->next;
			delete deletePtr;
			deletePtr = head->next;
			}
		size = original.size;
		if (original.head->next == NULL) {
			head->next = NULL;
			}
		else {
			NodePointer origPtr = original.head->next;
			NodePointer newPtr = new Node(origPtr->variable, origPtr->value);
			head->next = newPtr;
			for (origPtr = origPtr->next; origPtr !=NULL; origPtr = origPtr->next) {
				newPtr->next = new Node(origPtr->variable, origPtr->value);
				newPtr = newPtr->next;
				}
			}
		}
	return * this;
	}

template <typename ElementType>
ostream & operator<< (ostream & out, const LinkedList<ElementType> & list) {
	list.display(out);
	return out;
	}

template <typename ElementType>
bool LinkedList<ElementType>::search(char name, NodePointer & trailPtr) {
	NodePointer currentPtr = head->next;
	while(currentPtr != NULL && currentPtr->variable < name) {
		trailPtr = currentPtr;
		currentPtr = currentPtr->next;
		}
	return (currentPtr != NULL && currentPtr->variable == name);
	}

#endif
stack.h
Code:
#ifndef STACK
#define STACK

# include <iostream>
using namespace std;

template <typename ElementType>
class Stack {
	private:
		class Node {
			public:
				ElementType data;
				Node * next;
				Node (ElementType newData, Node * link = NULL): data(newData), next(link) {}
			};
		typedef Node * NodePointer;
	
	public:
		Stack();
		Stack(const Stack<ElementType> &);
		~Stack();
		bool isEmpty() const;
		int getSize() const;
		void push(ElementType);
		ElementType peek();
		void pop();
		void display(ostream & out) const;
		const Stack<ElementType> & operator= (const Stack<ElementType> &);
	
	private:
		int size;
		NodePointer head;
		NodePointer top;
	};

template <typename ElementType>
Stack<ElementType>::Stack(): size(0) {
	ElementType garbage;
	head = new Node(garbage, NULL);
	top = head;
	}

template <typename ElementType>
Stack<ElementType>::Stack(const Stack<ElementType> & original) {
	size = original.size;
	if (head->next == NULL) {
		head->next = NULL;
		}
	else {
		NodePointer origPtr = original.head->next;
		NodePointer newPtr = new Node(origPtr->data);
		head->next = newPtr;
		for (origPtr = origPtr->next ; origPtr != NULL ; origPtr = origPtr->next) {
			newPtr->next = new Node(origPtr->data);
			newPtr = newPtr->next;
			}
		}
	}

template <typename ElementType>
Stack<ElementType>::~Stack() {
	NodePointer deletePtr = head->next;
	while (deletePtr != NULL) {
		head->next = deletePtr->next;
		delete deletePtr;
		deletePtr = head->next;
		}
	}

template <typename ElementType>
bool Stack<ElementType>::isEmpty() const {
	return (top == head);
	}

template <typename ElementType>
int Stack<ElementType>::getSize() const {
	return size;
	}

template <typename ElementType>
void Stack<ElementType>::push(ElementType item) {
	if (top == head) {
		head->next = new Node(item);
		top = head->next;
		}
	else {
		NodePointer newPtr = new Node(item);
		top->next = newPtr;
		top = newPtr;
		}
	size++;
	}

template <typename ElementType>
ElementType Stack<ElementType>::peek() {
	if (isEmpty()) {
		cerr << "Stack empty unable to return value." << endl
		     << "Returning garbage data." << endl;
		ElementType garbage;
		return garbage;
		}
	return top->data;
	}

template <typename ElementType>
void Stack<ElementType>::pop() {
	if (isEmpty()) {}
	else if (top == head->next) {
		delete top;
		top = head;
		size--;
		}
	else {
		NodePointer ptr = head->next;
		while (ptr->next != top) {
			ptr = ptr->next;
			}
		delete top;
		top = ptr;
		size--;
		}
	}

template <typename ElementType>
void Stack<ElementType>::display(ostream & out) const {
	NodePointer currentPtr = head->next;
	while (currentPtr != NULL) {
		out << currentPtr->data << endl;
		currentPtr = currentPtr->next;
		}
	}

template <typename ElementType>
const Stack<ElementType> & Stack<ElementType>::operator= (const Stack<ElementType> & original) {
	if (this != original) {
		NodePointer deletePtr = head->next;
		while (deletePtr != NULL) {
			head->next = deletePtr->next;
			delete deletePtr;
			deletePtr = head->next;
			}
		size = original.size;
		if (isEmpty()) {
			head->next = NULL;
			top = head;
			}
		else {
			NodePointer origPtr = original.head->next;
			NodePointer newPtr = new Node(origPtr->data);
			head->next = newPtr;
			for (origPtr = origPtr->next ; origPtr != NULL ; origPtr = origPtr->next) {
				newPtr->next = new Node(origPtr->data);
				newPtr = newPtr->next;
				}
			}
		}
	return * this;
	}

template <typename ElementType>
ostream & operator<< (ostream & out, const Stack<ElementType> & stack) {
	stack.display(out);
	return out;
	}
#endif
 
  


Reply


Thread Tools Search this Thread
Search this Thread:

Advanced Search

Posting Rules
You may not post new threads
You may not post replies
You may not post attachments
You may not edit your posts
BB code is On
Smilies are On
[IMG] code is Off
HTML code is Off
Trackbacks are Off
Pingbacks are On
Refbacks are Off

Similar Threads
Thread Thread Starter Forum Replies Last Post
FC3 glibc detected *** double free or corruption: josedragone Fedora 5 09-17-2009 10:16 PM
*** glibc detected *** malloc() / free()/ double RohanShrivastav Programming 9 03-24-2009 12:37 PM
*** glibc detected *** double free or corruption (!prev): 0x082c1120 *** eXor Slackware 6 04-11-2008 08:47 AM
glibc detected ; memory corruption pingu Linux - Software 3 10-12-2005 01:29 AM
OpenOffice.org *** glibc detected *** free(): invalid pointer: 0x41481c94 *** Artanicus Linux - Software 2 02-19-2005 07:04 PM


All times are GMT -5. The time now is 04:51 AM.

Contact Us - Advertising Info - Rules - LQ Merchandise - Donations - Contributing Member - LQ Sitemap -
Main Menu
 
My LQ
Write for LQ
LinuxQuestions.org is looking for people interested in writing Editorials, Articles, Reviews, and more. If you'd like to contribute content, let us know.
Main Menu
Syndicate
RSS1  Latest Threads
RSS1  LQ News
Twitter: @linuxquestions
identi.ca: @linuxquestions
Facebook: @linuxquestions
Open Source Consulting | Domain Registration