Need help implementing a class

I am writing a program for keeping a course list for each student in a college. The information about each student should be kept in an object that contains the student's name and a list of courses completed by the student.

* must use a DYNAMIC ARRAY for storing students
* must use LINKED LISTS for storing courses (1 course list for each student)

I have written a course class which is a linked list to store the courses with name, credit and GPA; a student class to contain a student's name and a course list. I am writing the third class: school which should be a dynamic array of student.

The prgram should prompt for user inputs for student name, course name, course GPA, and course credit. All these will be stored in student_list. I kind of wrote a student_insert function, but it doen't seem to work. Could someone please help me out in writing a school member function to insert a student into the student_list with the user inputs? Thank you in advance.

========
student.h
========

Code:

#ifndef STUDENT_H
#define STUDENT_H
#include <string>

namespace jk1998_A
{
      class course
      {     
            public:
                   course(const std::string& name=NULL, const double& GPA=0, const double& credit=0, course* link = NULL);
                   void set_name(const std::string& name) {course_name = name;}
                   void set_GPA(const double& GPA) {course_GPA = GPA;}
                   void set_credit(const double& credit) {course_credit = credit;}
                   void set_node(course* new_node) {node=new_node;}
                   course* link() {return node;}
                   const course* link() const {return node;}
                   std::string get_name() const {return course_name;}
                   double get_GPA() const {return course_GPA;}
                   double get_credit() const {return course_credit;}
                   
                   
                   
            private:
                    std::string course_name;
                    double course_GPA;
                    double course_credit;
                    course* node;      
      };    
      
      void list_head_insert(course*& head_ptr, const std::string& name, const double& GPA, const double& credit);
            
      course* list_search(course* head_ptr, const std::string& target); 
      
      const course* list_search(const course* head_ptr, const std::string& target);
      
      void list_remove(course* previous_ptr); 
      
      void list_head_remove(course*& head_ptr);
          
      void list_insert(course* previous_ptr, const std::string& name, const double& GPA, const double& credit);
          
      void list_copy(const course* source_ptr, course*& head_ptr, course*& tail_ptr);    
      
      void list_clear(course*& head_ptr);
          
          
          
      class student
      {
            public:
                    student(const std::string& name=NULL);
                    student(const student& source);
                    ~student();
                    void operator =(const student& source);
                    void set_student_name(const std::string& name) {student_name=name;}
                    std::string get_student_name() {return student_name;}
                    
                    void course_insert(const std::string& name, const double& GPA, const double& credit);
                    bool course_erase(const std::string& target);
                    
                    

            private:
                    std::string student_name;
                    course* head_ptr;
                    int many_nodes;
                          
            
      };    
      
      
      
      class school
      {
            public:
                   static const int DEFAULT_CAPACITY;
                   
                   school(int initial_capacity = DEFAULT_CAPACITY);
                   school(const school& source);
                   ~school();
                   void reserve(int new_capacity);
                   void student_insert(const student& entry);
                   
            private:      
                    student* student_list;
                    int used;
                    int capacity;
            
      };
}

#endif

========
implement.cpp
========

Code:

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

using namespace std;

namespace jk1998_A
{
/******COURSE*******/
      course::course(const string& name, const double& GPA, const double& credit, course* link)
      {
            course_name = name;
            course_GPA  = GPA;
            course_credit = credit;
            node = link;
      }

      void list_head_insert(course*& head_ptr, const string& name, const double& GPA, const double& credit)
      {
            head_ptr = new course(name, GPA, credit, head_ptr);
      }
      
      course* list_search(course* head_ptr, const string& target)
      {
            course* cursor;
            
            
            for (cursor = head_ptr; cursor != NULL; cursor = cursor->link())
                if (target.compare(cursor->get_name())==0)
                   return cursor;
            return NULL;  
      }
      
      const course* list_search(const course* head_ptr, const std::string& target)
      {
            const course* cursor;
            
            
            for (cursor = head_ptr; cursor != NULL; cursor = cursor->link())
                if (target.compare(cursor->get_name())==0)
                   return cursor;
            return NULL;       
      }      
      
      void list_remove(course* previous_ptr)
      {
            course* remove_ptr;
            
            remove_ptr = previous_ptr->link();
            previous_ptr->set_node(remove_ptr->link());
            delete remove_ptr;     
      }

      void list_head_remove(course*& head_ptr)
      {
            course* remove_ptr;
            
            remove_ptr = head_ptr;
            head_ptr = head_ptr->link();
            delete remove_ptr;     
      }
      
      void list_insert(course* previous_ptr, const string& name, const double& GPA, const double& credit)
      {
            course* insert_ptr;
            
            insert_ptr = new course;
            insert_ptr->set_name(name);
            insert_ptr->set_GPA(GPA);
            insert_ptr->set_credit(credit);
            insert_ptr->set_node(previous_ptr->link());
            previous_ptr->set_node(insert_ptr);                    
      }
      
      void list_copy(const course* source_ptr, course*& head_ptr, course*& tail_ptr)
      {
            head_ptr = NULL;
            tail_ptr = NULL;
            
            if(source_ptr == NULL)
              return;
            
            list_head_insert(head_ptr, source_ptr->get_name(), source_ptr->get_GPA(), source_ptr->get_credit());  
            tail_ptr = head_ptr;
            
            source_ptr = source_ptr->link();
            while(source_ptr != NULL)
            {
                  list_insert(tail_ptr, source_ptr->get_name(), source_ptr->get_GPA(), source_ptr->get_credit());
                  tail_ptr = tail_ptr->link();
                  source_ptr = source_ptr->link();                 
            }     
      }
      
      void list_clear(course*& head_ptr)
      {
            while (head_ptr != NULL)
                  list_head_remove(head_ptr);     
      }
      
      
      
/*******STUDENT******/      
      
      student::student(const std::string& name)
      {
            student_name = name;
            head_ptr = NULL;
            many_nodes=0;                       
      }
      
      student::student(const student& source)
      {
            course* tail_ptr;
            list_copy(source.head_ptr, head_ptr, tail_ptr);
            student_name=source.student_name;
            many_nodes=source.many_nodes;                       
      }
      
      student::~student()
      {
            list_clear(head_ptr);
            many_nodes=0;                   
      }
      
      void student::operator =(const student& source)
      {
            course* tail_ptr;
            if(this == &source)
              return;
              
            list_clear(head_ptr);
            many_nodes = 0;
            list_copy(source.head_ptr, head_ptr, tail_ptr);
            many_nodes = source.many_nodes;     
      }
      
      void student::course_insert(const string& name, const double& GPA, const double& credit)
      {
            list_head_insert(head_ptr, name, GPA, credit);
            ++many_nodes;
      }
      
      bool student::course_erase(const string& target)
      {
            course* target_ptr;
            target_ptr = list_search(head_ptr, target);
            if (target_ptr == NULL)
               return false;
            target_ptr->set_name(head_ptr->get_name());
            target_ptr->set_GPA(head_ptr->get_GPA());
            target_ptr->set_credit(head_ptr->get_credit());
            list_head_remove(head_ptr);
            --many_nodes;
            return true;    
      }
      
      
      
/*********SCHOOL********/
      
      const int school::DEFAULT_CAPACITY=20;
      
      school::school(int initial_capacity)
      {
            student_list = new student[initial_capacity];
            capacity = initial_capacity;
            used=0;           
      }
      
      school::school(const school& source)
      {
            student_list = new student[source.capacity];
            capacity = source.capacity;
            used = source.used;
            copy(source.student_list, source.student_list + used, student_list);                     
      }
      
      school::~school()
      {
            delete [] student_list;                 
      }
      
      void school::reserve(int new_capacity)
      {
            student* larger_array;
            
            if(new_capacity == capacity)
              return;
              
            if(new_capacity < used)
              new_capacity = used;
              
            larger_array = new student[new_capacity];
            copy(student_list, student_list + used, larger_array);
            delete [] student_list;
            student_list = larger_array;
            capacity = new_capacity;
      }
      
      void school::student_insert(const student& entry)
      {
            if(used == capacity)
               reserve(used + 10);
            student_list[used] = entry;
            ++used;
      }
}

=========
main
========

Code:

#include <cstdlib>
#include <iostream>
#include "student.h"

using namespace std;
using namespace jk1998_A;

int main()
{   
    school students;
    
    system("PAUSE");
    return EXIT_SUCCESS;
}

Be a bit more precise than "but it doen't seem to work" please. What did you try and what error message did you get ?

I have figured out the first question.

But I have an bigger problem.

I have a print_student(name) function which suppose search the students for match of name and print out the student name and all the courses of the student. I compiled the program without error, but the program terminated itself without printing out anything when I ran the program. I am using Dev C++. Help PLEASE!

========
main
========

Code:

#include <cstdlib>
#include <iostream>
#include "student.h"

using namespace std;
using namespace jk1998_A;

int main()
{   
    school students;
    
    
    student First;
    First.set_student_name("First Student");
    First.course_insert("Algebra",3.2,3.0);
    First.course_insert("Geometry",3.6,3.0);
    
    student Second;
    Second.set_student_name("Second Student");
    Second.course_insert("Algebra",3.0,3.0);
    
    students.student_insert(First);
    students.student_insert(Second);
    
    students.print_student("First Student");
    
    system("PAUSE");
    return EXIT_SUCCESS;
}

=========
implement.cpp
==========

Code:

void school::print_student(const string& name)
      {
           for(int i=0; i=used; ++i)
           {
                 if((student_list[i].get_student_name()).compare(name)==0)
                 {
                        cout<<student_list[i].get_student_name();
                        break;                                                         
                 }
                 else
                 {
                       cout<<"No match found";    
                 }        
           }     
      }

Code:

           for(int i=0; i=used; ++i)
           {

which it never will unless used is 0...

In the main() function, I just tested course A, and again the program terminated itself without printing out any errors. Is this mean the bug is in the course class?

This looks wrong:

Code:

course(const std::string& name=NULL, const double& GPA=0, const double& credit=0, course* link = NULL);

A NULL pointer is probably not good for a string.
(The string constructor expects a valid char* pointer, and it probably tries to find the char array's lenght first. Boom, dereferencing NULL.)

The correct default value for an empty string is ""

Edit: to be more precise, std::string throws an exception, if passed a NULL pointer to the constructor: basic_string::_S_construct NULL not valid.

Yeah, that fixed the problem. Thank You very much.

The best choice would probably be:

Code:

const std::string& name=std::string()

since that is what you are defaulting to, a default constructed (and therefore empty) string.

good stuff Thanks