Memory Leak problem

[shahki]

I seem to have a memory leak that I have been trying to find but cannot locate in this templated linked list class. Am I missing something? I am fairly new to C++ so thank you in advance for any help.

  #ifndef LLIST_H
#define LLIST_H

/*
	Templated Linked List class.
	
	September 2015
*/
#include <ostream>
#include <stdexcept>

using namespace std;

// This is a templated struct.  You don't need to change this.
template <class T>
struct node_t {
  T data;
  node_t* next;
};


// Change this class!
template <class T>
class LList{

  public:
  LList(){
    head = NULL;
    s = 0;
  }
  
  ~LList(){
    node_t<T>* temp = head;
    while(temp){
      node_t<T>* to_delete = temp;
      temp = temp->next;
      delete to_delete;
    }
    head = NULL;
    s = 0;
  }
	
  LList(const LList& other){
    node_t<T>* temp = other.head; 
    s = 0;
    head = NULL;
    while(temp){
      this->push_back(temp->data);
      temp = temp->next;
    }
  }
	
  LList<T>& operator= (const LList& other){
    if(this == &other){
      return *this;
    }
    //this = NULL;
    //head = NULL;
    clear();
    s = 0;
    node_t<T>* temp = other.head;
    s++;
    while (temp){
      this->push_back(temp->data);
      temp = temp->next;
      s++;
    }
  return *this;
  }
     
  T getAt(int pos) const{
    node_t<T>* temp = head;
    T ret;
    if (pos < 0) { 
      pos = size() + pos;
      if (pos < 0) {
        throw logic_error("Position not in list");
      }
    }
    if (pos < size()){
      for (int i = 0; i < pos; i++){
        temp = temp->next;
      }
      ret = temp->data;
    }
    else{
     throw logic_error("Index not within linked list"); 
    }
    return ret;
  }

  int size() const{
    node_t<T>* temp = head;
    int i = 0;
    while(temp){
      i++;
      temp = temp->next;
    }
    return i;
  }
 
  void push_back(T value){
    // Is the list empty?
    if(head == NULL){
      //push_front(thing);  this will work fine ..or
      node_t<T>* new_node = new node_t<T>;
      new_node->data = value;
      new_node->next = NULL;
      head = new_node;
      return;
    }
    node_t<T>* temp = head;
    while(temp->next){
      temp = temp->next;
    }
    // temp is...... a valid node with a null next pointer
    node_t<T>* new_node = new node_t<T>;
    new_node->data = value;
    new_node->next = NULL;
    temp->next = new_node;
    s++;
  }
  
  void push_front(T value){
    node_t<T>* temp = new node_t<T>;
    temp->next = head;
    temp->data = value;
    head = temp;
    s++;
  }
	
	void setAt(T value, int pos){
	  node_t<T>* temp = head;
	  if (pos < 0){
	    pos = size() + pos;
	    if (pos < 0){
	      throw logic_error("Position not in list");
	    }
	  }
	  if (pos < size()){
	    for (int i = 0; i < pos; i++){
	    temp = temp->next;
	    } 
	    temp->data = value;
	  } else{
	    throw logic_error("Inputted position larger than list");
	  }
	}
	
	void remove(int pos){
	  if(pos >= size()){
      throw logic_error("Position not in list");
    }
    if (pos < 0){
      pos = size() + pos;
      if (pos < 0){
        throw logic_error("Position not in list");
      }
    }
    if(pos == 0){ // first element
      if (size() == 0){
        throw logic_error("List empty");
      }
      node_t<T>* temp = head;
      head = head->next;
      delete temp;
      return;
    }
    node_t<T>* temp = head;
    while(temp && pos > 1){
      pos--;
      temp = temp->next;
    }
    if(!temp){
      throw logic_error("Bad index!");
      return;
    }
    node_t<T>* to_delete = temp->next;
    temp->next = temp->next->next;
    delete to_delete;
    s--;
	}
	
	LList<T> reverse() const{ 
	  LList<T> ret;
	  for (int i = size()-1; i >= 0; i--){
	    ret.push_back(getAt(i));
	  }
	
	return ret;
	}
	
	LList<T> operator+(const LList<T>& other) const{
	  LList<T> ret;
	  node_t<T>* temp = head;
	  while (temp){
	    ret.push_back(temp->data);
	    temp = temp->next;
	  }
	  temp = other.head;
	  while(temp){
	    ret.push_back(temp->data);
	    temp = temp->next;
	  }
	  return ret;
	}
	
	bool operator==(const LList<T>& other) const{
	  node_t<T>* temp = head;
	  node_t<T>* temp2 = other.head;
	  int i = 0;
    if (size() == other.size()){
      if (size() == 0){
        return true;
      }
      while(temp){
        if (temp->data == temp2->data){
          i++;
          temp = temp->next;
          temp2 = temp2->next;
        }
      }
    }else{
      return false;
    }
    if (i == size()){
      return true;
    }else{
	    return false;
	  }
	}
	
	bool operator!=(const LList<T>& other) const{
	  node_t<T>* temp = head;
	  node_t<T>* temp2 = other.head;
	  int i = 0;
    if (size() != other.size()){
      if (size() == 0 || other.size() == 0){
        return true;
      }
      while(temp){
        if (temp->data != temp2->data){
          i++;
          temp = temp->next;
          temp2 = temp2->next;
        }
      }
    }
    else{
      return false;
    }
    if (i == size()){
      return true;
    }
    else{
	    return false;
	  }
	}
	
	void clear(){
	  node_t<T>* temp = head;
    while(temp){
      node_t<T>* to_delete = temp;
      temp = temp->next;
      delete to_delete;
    }
    head = NULL;
    s = 0;
	}
 
  
private:
    node_t<T>* head;
    int s;
  // Fill in stuff here!
};

template <class T>
ostream& operator<<(ostream& out, const LList<T> other){
  out << "[";
  for (int i = 0; i < other.size(); i++){
    out << i << ": " << other.getAt(i);
    i++;
  }
  out << "]\n";
	return out;
}


#endif 

[ne555]

> I seem to have a memory leak
¿why do you think that?

> Am I missing something?
main()
please give me something that I could run.

[DyslexicChciken]

I noticed your push_back function updates size with s++ and your operator= function also updates size with s++. Unless I am missing something, this would double the size of the current list instance if s is for size.

  LList<T>& operator= (const LList& other){
    if(this == &other){
      return *this;
    }
    clear();
    s = 0;
    node_t<T>* temp = other.head;
    s++;
    while (temp){
      this->push_back(temp->data);//size update here
      temp = temp->next;
      s++; //size update here
    }
  return *this;
  }

  void push_back(T value){
    if(head == NULL){
      node_t<T>* new_node = new node_t<T>;
      new_node->data = value;
      new_node->next = NULL;
      head = new_node;
      return;
    }
    node_t<T>* temp = head;
    while(temp->next){
      temp = temp->next;
    }
    node_t<T>* new_node = new node_t<T>;
    new_node->data = value;
    new_node->next = NULL;
    temp->next = new_node;
    s++; //size update here
  }