#include<iostream.h>
#include <string.h>

#include<stdlib.h>
using namespace std;


//----------------defining user class----------------------------
class user{
//data member of user class
char * ID;
char * Name;
char * Address;
protected:
    char * Status;

//public interface of user class
public:
    // Default and overloaded constructors
        user();
       user(char * ID,char * Name,char * Address,char * Status);
       
    // Setter and Getter fucntions   
       void set_Name();
 
       const char * get_Name() const;
       void set_add();
       void verify_user();

   // Destructor
   ~user();
// end of user class
};

// Implementation of overloaded constructor
user::user(char * id,char * aname,char * address,char * astatus){
               
               ID=new char[strlen(id)+1];
               strcpy(ID,id);
          
          Name = new char[strlen(aname)+1];
          strcpy(Name,aname);
                
                Address = new char[strlen(address)+1];
                strcpy(Address,address);
                
                Status = new char[strlen(astatus)+1];
                strcpy(Status,astatus); 

}
            
// Implementation of set_Name() method
void user::set_Name(){
     char name[50];
     cout<<"\nEnter user name:"<<"\n";
     cin.getline(name,50);
     
     Name = new char[strlen(name)+1];
     strcpy(Name,name);
     }
     
// Implementation of get_Name() method
const char * user::get_Name() const{
     if(Name != NULL){
             return Name;
    
            }
     }
// Implementation of set_add() method to set the value of Address
void user::set_add(){
     char add[300];
     cout<<"\nEnter address:"<<"\n";
     cin.getline(add,300);
     
     Address = new char[strlen(add)+1];
     strcpy(Address,add);
                
     
     }
// Implementation of Verify_user() method, to varify a user
void user::verify_user() {
     cout<<"\n\n -------------User Verification---------\n\n";
     //----set_Name function call---------
     set_Name();
     //--------set_address call---------
     set_add();
     //------set status as verified----------
     char stat[20]="verified";
      Status = new char[strlen(stat)+1];
     strcpy(Status,stat); 
     cout<<"\n\nUser\t"<<Status<<"\n\n"; 
     }
// Implementation of destructor
user::~user(){
delete []ID;
delete []Name;
delete []Address;
delete [] Status;

}    

//----------------defining Member class----------------------------

// Inheritance relationship between Member and user classes
class Member:public user{ 

// Data members of Member class
char * Password;

//public interface for the Member class
public:
        //Overloaded constructor
       Member(char * ID,char * Name,char * Address,char * Status,char * Password);

      // Setter and getter fucntions 
      void passw();
      const char * get_password() const;
      void verify_user();
      void add_mem();
      void delete_mem();
      ~Member();

};

// Implementation of overloaded constructor
Member::Member(char * id,char * an,char * add,char * stat,char * pass):user(id, an, add, stat){
                     
                   Password = new char[strlen(pass)+1];
                   strcpy(Password,pass);
                  
             }

// Implementation of passw() method, to verify password
void Member::passw(){
     
     char pass[40];
     cout<<"\nEnter password:"<<"\n";
     cin.getline(pass,40);
     
     Password = new char[strlen(pass)+1];
     strcpy(Password,pass);
     }

// Implementation of getter function             
const char * Member::get_password() const{
     if(Password != NULL){
             return Password;
    
             }
     }

// Overriding the verify_user() method in Member class
void Member::verify_user() {
     cout<<"\n\n -------------Member User Verification---------\n\n";
     //----------assigning password to user---------
     passw();
     //------set status as Member user----------
     char stat[20]="Member";
      Status = new char[strlen(stat)+1];
     strcpy(Status,stat); 
     cout<<"\n\nUser is "<<Status<<"\n\n"; 
     }     
// ------------Add Member-------------------
 void Member::add_mem(){
     cout<<"a member has been added";
      }
//-------------------delete Member----------     
 void Member::delete_mem(){
     cout<<"a member has been deleted";
      } 
//-----------Destructor Implementation--------------- 
Member::~Member(){

delete [] Password;
     
     }     
          
//----------------defining Admin class----------------------------


class Admin:public user{ //Making User class as base class 

//Private data members of Admin class
char * Password;

//public interface of Admin class
public:

//Overloaded constructor
Admin(char * ID,char * Name,char * Address,char * Status,char * Password);

//Setter and getter fucntions
void passw();
const char * get_password() const;
void verify_user();
void add_admin();
void delete_admin();

// Admin class Destructor
~Admin();
// end of Admin class
};

// Implementation of overloaded constructor
Admin::Admin(char * id,char * an,char * add,char * stat,char * pass):user(id, an, add, stat){
                     
                   Password = new char[strlen(pass)+1];
                   strcpy(Password,pass);
                  
             }

// Implementation of passw() method for 
void Admin::passw(){
                char pass[40];
     cout<<"\nEnter password:"<<"\n";
     cin.getline(pass,40);
     
     Password = new char[strlen(pass)+1];
     strcpy(Password,pass);
             }
             
// Implementation of get_password() method
const char * Admin::get_password() const{
     if(Password != NULL){
             return Password;
    
             }
     }

// Overriding the verify_user() method in Admin class
void Admin::verify_user() {
     cout<<"\n\n -------------Administrator User Verification---------\n\n";
     
     //----------assigning password to user---------
     passw();
     
     //------set status as Admini user----------
     char stat[20]="Administrator";
      Status = new char[strlen(stat)+1];
     strcpy(Status,stat); 
     cout<<"\n\nUser is "<<Status<<"\n\n"; 
     }     
// ------------Add Admin-------------------
 void Admin::add_admin(){
     cout<<"admin has been added";
      }
// ------------Delete Admin-------------------
 void Admin::delete_admin(){
     cout<<"admin has been deleted";
      }      
//-----------Destructor Implementation--------------- 
Admin::~Admin(){
delete []Password;    
    }

int main(){

//user object
user user1("","","",""); // user class overloaded constructor is called

// callilng verify-user() method by user object    
user1.verify_user();

// Member object
Member memb("","","","","");// Member class overloaded constructor is called

// callilng verify-user() method by Member object
memb.verify_user();

//Admin object 
Admin adm("","","","","");// Member class overloaded constructor is called

// callilng verify-user() method by Admin object
adm.verify_user(); 
 
    system("pause");
}