Doubly Linked List Copy Constructor and Overloading = operator

[zspar]

We were given Student class and Student Roll class (header files included below) The only things I cant figure out so far are how to overload the = operator for StudentRoll, and the copy constructor for studentRoll. I know that copy and swap would probably be the best thing to use here but this is for a school assignment and it has to pass very specific tests with only these functions. Heres what I have, any suggestions are appreciated.

//Student.h 
#ifndef STUDENT_H
#define STUDENT_H

#include <string>

class Student {

 public:
  Student(const char * const name, int perm);

  int getPerm() const;
  const char * const getName() const;

  void setPerm(const int perm);
  void setName(const char * const name);

  Student(const Student &orig);
  ~Student();
  Student & operator=(const Student &right);

  std::string toString() const;

 private:
  int perm;
  char *name; // allocated on heap                                                                                                                                                   

};


#endif


//studentRoll.h
#ifndef STUDENTROLL_H
#define STUDENTROLL_H

#include <string>
#include "student.h"

class StudentRoll {

 public:
  StudentRoll();
  void insertAtTail(const Student &s);
  std::string toString() const;

  StudentRoll(const StudentRoll &orig);
  ~StudentRoll();
  StudentRoll & operator=(const StudentRoll &right);

 private:
  struct Node {
    Student *s;
    Node *next;
  };
  Node *head;
  Node *tail;
};


#endif

//studentRoll.cpp
#include <string>
#include "studentRoll.h"
#include <sstream>
#include <iostream>
StudentRoll::StudentRoll() {
  head = tail = NULL;
}

void StudentRoll::insertAtTail(const Student &s) {
    /*  tail -> next = new Node;
    tail = tail -> next;
    tail -> s = s;
    tail -> next = null;

    */
    Node* n = new Node;
    n -> s = new Student(s);

    n -> next = NULL;

    if (head == NULL){
        head = n;
    }
    if(tail != NULL){
        tail -> next = n;
    }
    n -> next = NULL;
    tail = n;
}

std::string StudentRoll::toString() const {
    std::ostringstream oss;
    oss << "[";
    Node *p = head;
    while (p){
        oss << p -> s -> toString();
        if(p != tail) oss << ",";
        p = p -> next;
    }
    oss << "]";
    delete p;
    return oss.str();

}

StudentRoll::StudentRoll(const StudentRoll &orig) {
    Node *p1 = 0;
    Node *p2 = 0;

    if (orig.head == NULL){
        head = NULL;
        tail = NULL;
    }
    else{

        head = new Node;
        head -> s = new Student(*(orig.head -> s));
        std::cout << "got here";
        p1 = head;
        p2 = orig.head -> next;
    }
    while(p2){
        p1 -> next = new Node;
        p1 = p1 -> next;
        p1 -> s = new Student(*(orig.head -> s));

        p2 = p2 -> next;
    }
    p1 -> next = NULL;
    tail = p1;
    delete p1;
    delete p2;

}

StudentRoll::~StudentRoll() {
    Node *current = head;
    while ( current != 0 ){
        Node* next =  current->next;
        delete current;
        current = next;
    }

}


StudentRoll & StudentRoll::operator =(const StudentRoll &right ) {
  // The next two lines are standard, and you should keep them.
  // They avoid problems with self-assignment where you might free up 
  // memory before you copy from it.  (e.g. x = x)

  if (&right == this) 
    return (*this);

  // TODO... Here is where there is code missing that you need to 
  // fill in...

        Node *p1 = 0;
        Node *p2 = 0;

        if (right.head == NULL){
                head = NULL;
                tail = NULL;
        }
        else{

                head = new Node;
                head -> s = new Student(*(right.head -> s));

                p1 = head;
                p2 = right.head -> next;
        }
        while(p2){
                p1 -> next = new Node;
                p1 = p1 -> next;
                p1 -> s = new Student(*(p2 -> s));

                p2 = p2 -> next;
        }
        p1 -> next = NULL;
        tail = p1;
        delete p1;
        delete p2;  
  // KEEP THE CODE BELOW THIS LINE
  // Overloaded = should end with this line, despite what the textbook says.
  return (*this); 

}

[mbozzi]

Regarding your copy constructor, you have an insert_at_tail, so just iterate the argument and insert the elements in the list:

StudentRoll::StudentRoll(const StudentRoll &orig) {
  for(Node* n = orig.head; n; n = n->next) 
    insertAtTail(*n);
}

Copy assignment operators usually follow one of a few patterns, and so are a little easier to write, if more complicated.

See this, and the posts linked from it:
http://www.cplusplus.com/forum/beginner/215692/#msg1001849

There are two steps to an assignment operator:
1.) Release the old resources; then
2.) Copy the new ones from the right-hand-side.
You release old resources in the destructor, and copy resources in the copy constructor. Don't duplicate code -- you can call them:

StudentRoll& operator=(StudentRoll const& rhs) {
  if (std::addressof(rhs) == this) return *this; // careful for self-assignment
  ~StudentRoll(); // release old resources 
  new(this) StudentRoll(rhs); // storage reuse -- copy from rhs
  return *this;
}

Preferably, copy-and-swap provides a strong exception guarantee by doing things in this order:
1.) Make a temporary copy of the new resources (which might throw)
2.) Switch your old resources with the temporary copy (which must not throw)
3.) Destroy the temporary copy of your old resources.

StudentRoll& operator=(StudentRoll rhs) { 
  swap(*this, rhs);
  return *this;
}

[zspar]

In regards to calling the destructor in the assignment operator, I was under the impression that you can't explicitly call a destructor.
Also for the copy constructor it is complaining and telling me no known conversion from argument Student* to const Student&. Thanks for the help!

[mbozzi]

You can explicitly call a destructor, although the uses for it are relatively rare -- usually it appears in around uses of placement-new, e.g., in the case of storage reuse like here, or wrapped in allocators. Regardless, the code I posted literally comes from an example in the standard document itself - from [basic.life]:
http://eel.is/c++draft/basic.life#8

no known conversion from argument Student* to const Student&

It looks like this part won't compile

  for(Node* n = orig.head; n; n = n->next) 
    insertAtTail(*n);

although hopefully you got the idea.
It's difficult for me to produce working code without enough of yours to compile. Still, I don't see where that error is coming from.