Segmentation fault error

[GL1Rko23]

I am getting a segmentation fault error in this code taking an infix expression to a postfix expression, I have a lot of debugging code in and I'll leave it in so you can see how far it gets as well. I can't figure out why It is doing this, I have to use my own string library for this which I will include so you can see what stack is using for the strings. This is a lot I am asking to be looked over, but if anyone has the time please assist me! :)

I apologize for string being so sloppy.

This is a link to my string class, it is too long to post in here -

http://pastebin.com/vv4tUw3w

Stack Header with implementation:

#ifndef CS33001_STACK_H_
#define CS33001_STACK_H_

#include <cassert>
#include <new>

template <typename T>
class node {
public:
        node() : data(), next(0) {};
        node(T item) : data(item), next(0) {};

        T data;
        node<T> *next;
};

template <typename T>
class stack{
public:
        //default constructor
        stack(): tos(0) {};

        //copy constructor
        stack(const stack<T>&);

        //deconstructor
        ~stack();

        //constant time swap
        void swap(stack<T>&);

        //assignment operator
        stack<T>&  operator=( stack<T> rhs);

        bool isEmpty() const {return tos == 0; };

        bool isFull() const;

        T pop();

        void push(const T&);


private:
        node<T> *tos;
};



template <typename T>
stack<T>::stack(const stack<T>& actual) {

        node<T> *ttos = actual.tos,
                *bottom = 0, *temp;

        tos = 0;
        while(ttos != 0) {
                temp = new node<T>(ttos -> data);
                if(tos == 0) { //first node
                        tos = temp;
                        bottom = temp;
                }
                else { 
                        bottom -> next = temp;
                        bottom = temp;
                }
                ttos = ttos -> next;
        }
}

template <typename T>
stack<T>::~stack() {
        while(tos != 0) {
                node<T> *temp = tos;
                tos = tos -> next;
                delete temp;
        }
}

template <typename T>
void stack<T>::swap(stack& rhs) {
        node<T> *temp = tos;
        tos = rhs.tos;
        rhs.tos = temp;
}

template <typename T>
bool stack<T>::isFull() const {
        node<T> *temp = new (std::nothrow) node<T>();
        if(temp==0) return true;
        delete temp;
        return false;
}

template <typename T>
stack<T>& stack<T>::operator=( stack<T> rhs) {
        swap(rhs);
        return *this;
}

template <typename T>
T stack<T>::pop() {
        assert(tos != 0);
        node<T> *temp = tos;
        T result = tos -> data;
        tos = tos -> next;
        delete temp;
        return result;
}

template <typename T>
void stack<T>::push(const T& item) {
        assert(!isFull());
        node<T> *temp = new node<T>(item);
        temp -> next = tos;
        tos = temp;
}

#endif 

Infix to postfix where fault occurs:

#include "stack.h"
#include <iostream>
#include <fstream>
#include <ostream>
#include "string.h"
#include <vector>

string infix_to_postfix(string expr);


int main (int argc, char **argv) {


std::streambuf * buf;
std::ofstream of;

if(argc == 1)
{

std::cout << "Usage: Postfix input [output]  ";


return 0;

}

string input;

if(argc == 2)
{
//buffered, stored in a buffer and then read.
buf = std::cout.rdbuf();
input = string(argv[1]);


}
//If there are more then two strings
else if(argc > 2){
//If there are more then two arguments provided, take the first to be the input and the second to be the output
input = string(argv[1]);
//open the file
of.open(argv[2]);
//assigning the buffer
buf = of.rdbuf();
}
//Constructing the output object
std::ostream out(buf);

std::ifstream fin(input.get_c_str());

if(fin.fail())
	{
		std::cerr<<"Cannot open the input file. "
			<<"Program terminates!"<<std::endl;
		return 0;
	}

string line;
while(fin.good()){
std::cout << "I am almost there";

fin >> line;

std::cout << "Infix Expression: " << line << "\n";

std::cout << "I am close";
string infix = infix_to_postfix(line);

std::cout << "Postfix Expression: " << infix << "\n";
}

  return 0;
}


string infix_to_postfix(string expr)
{
    std::cout << "I am here";
    std::vector<string> tokens = expr.split(' ');
    std::cout <<"I am here 2";
    for(int i = 0; i < tokens.size(); ++i)
    {
        std::cout << "_" << tokens[i] << "_";
    }

    stack<string> s;
    int i = 0;
    string lhs,rhs,op;
    while(tokens[i]!= ";"){
        if(tokens[i] != "("){
            if(tokens[i] == ")"){
                rhs = s.pop();
                op = s.pop();
                lhs = s.pop();
                s.push(lhs + rhs + op);
            }
            else
                s.push(tokens[i]);
        }
        ++i;
    }
    string result;
    
    while(! s.isEmpty()){
        result = result + s.pop();
    }
        return result;

}

[BlackSheep]

This section may be the problem:

while(tokens[i]!= ";"){  //Are you guaranteed that tokens contains a ";"? If not then you will be trying to read
                                      //uninitialized data. A fix might be: while(i < tokens.size() && tokens[i]!= ";")?
        if(tokens[i] != "("){
            if(tokens[i] == ")"){
                rhs = s.pop();
                op = s.pop();
                lhs = s.pop();
                s.push(lhs + rhs + op);
            }
            else
                s.push(tokens[i]);
        }
        ++i;
    }

[GL1Rko23]

I am guaranteed that every line will be an infix expression ending in a ;

But I was thinking it was that section causing it too

[BlackSheep]

Do you not have any idea where the error is? Try using breakpoints to narrow it down. And look at the local variables of your code to see if you have a bad pointer somewhere during suspicious functions.