Event Registration System

(Using Object-Oriented Programming Principles in C++.)

Project Guide Name: Dr. Shivani Sood

Designation: Lecturer
Department: School of Computer Application
Institute name: Lovely Professional University
Complete address of the Institute /University: Jalandhar - Delhi, Grand Trunk Rd,
Phagwara, Punjab 144411
Contact Number:
Email ID:

Project team (student)

Name: Pema Kinley, Anant Upadhyay
Email ID: pemakinley1333@gmail.com, anantupadhyay198@gmail.com
Contact Number: +91 - 6284858975, +91-9569397322
 Introduction
In today's digital world, organizing and managing events like conferences, workshops, and
seminars requires efficient registration systems. These systems not only ensure a smooth
experience for attendees but also help organizers manage and track participants effectively.
This project, titled Event Registration System Using C++ and OOP Concepts, simulates a
real-world event registration process through a simple, console-based application.

The project serves two main purposes: to enable users to view events, register using personal
details, select attendee types, and receive a unique pass ID; and to provide admin features like
viewing all registrations, searching by pass ID, and checking total counts. All essential
Object-Oriented Programming (OOP) concepts—encapsulation, inheritance, abstraction, and
polymorphism—are demonstrated through its design.

Targeted at beginners and intermediate programmers, the project shows how theoretical OOP
principles can be applied in real applications. With features like class hierarchies, static
members, function overloading, and dynamic data storage using vectors, it models real-world
scenarios in a structured and reusable way.

The menu-driven, modular interface guides users step-by-step and ensures maintainability
and scalability. Future extensions like file storage or graphical interfaces can easily be added.
Overall, this project blends practical utility with strong educational value, making it a great
learning tool for mastering C++ and OOP.
 Vision
As a beginner in computer applications, my vision for this project is to build a simple and
meaningful event registration system that not only solves a real-world problem but also helps
me strengthen my understanding of Object-Oriented Programming (OOP) in C++. I aim to
create an application that demonstrates the practical use of classes, inheritance, encapsulation,
and other core programming concepts in an easy and organized way.

Mission
 To apply what I have learned in C++ and OOP by developing a working console-based
application.
 To create a user-friendly system where anyone can register for events and get a unique
digital pass.
 To include admin features that allow viewing and managing attendee information easily.
 To gain hands-on experience using concepts like classes, objects, function overloading,
static members, and vectors.
 To improve my problem-solving, coding, and system design skills through practical
implementation.
 To lay the foundation for future projects and build confidence in writing real-world C++
applications
 Project Goals and Expected Outcomes
Core Learning Objectives:

Fundamental C++ Application – Develop a functional console-based program using basic

headers (<iostream> and <string>), reinforcing syntax, control structures, and user input
handling.
Introduction to OOP – Implement a simple class hierarchy (inheritance between Person and
Attendee) to model real-world relationships.
Data Management – Store and retrieve attendee data using arrays, introducing the concept
of structured data storage without advanced libraries.
Problem-Solving Practice – Troubleshoot common issues like input validation and array
bounds, building debugging skills.

Expected Functional Outcomes:

User Registration Flow:

Display a static list of events.

Capture user details (name, email, phone) via console input.

Generate and display a unique pass ID.

Admin Features:

View all registrations in a tabulated format.

Search attendees by pass ID (linear search implementation).

Display total registration count.

 System Overview
User Flow:

Step 1: View Available Events

On launch, the system displays a list of upcoming events (e.g. "Tech Conference",
"Startup Meetup").

Step 2: Main Menu Options

Register for an Event
View Your Pass (by Pass ID)
Admin Menu (no password required for now)
Exit

User Registration Flow:

Input: Name, Email, Phone
Choose Event
Choose Attendee Type: Student / Professional / VIP
Generate and show a unique Event Pass ID
Admin Menu:
View All Registrations
Search Registration by Pass ID
Show Total Registration Count
Back to Main Menu
 Implementation Details
The Event Registration System is implemented using core C++ features with a focus on
Object-Oriented Programming (OOP) principles. The application consists of three primary
classes—Person, Attendee, and EventSystem—each designed to encapsulate specific
functionalities while promoting code reusability and modularity.

The Person class serves as the base class, storing common attributes like name, email, and
phone number. It provides getter methods to access these private members and a display()
function to show basic details. The Attendee class inherits from Person, extending its
functionality to include event-specific attributes such as passId, eventName, and
attendeeType. A static idCounter ensures unique pass IDs are generated for each attendee.
The display() method is overridden to include attendee-specific information.

The EventSystem class acts as the main controller, managing user interactions through a
menu-driven interface. It uses a fixed-size array to store attendee objects (limited to 100
entries) and includes methods for registration, pass viewing, and administrative tasks. User
input is handled via cin and getline(), with basic validation to ensure correct event and
attendee type selection.

For data management, the system employs manual array traversal instead of STL algorithms
(since only <iostream> and <string> are used). The admin features include viewing all
registrations, searching by Pass ID (using linear search), and displaying the total registration
count.

The implementation demonstrates polymorphism through method overriding, encapsulation

via private data members, and abstraction by hiding complex operations behind simple
method calls. While the current version uses console I/O and memory arrays, it lays a strong
foundation for future enhancements like file persistence or dynamic data structures.
 Table 1.1 Class Specifications Table

Class Data Members Member Description

Functions
name (string) getName() Returns attendee's
name
email (string) getEmail() Returns email
address
Person phone (string) getPhone() Returns contact
number
display() Shows basic person
details

passId (string) getPassId() Returns auto-

generated Pass ID
eventName (string) getEventName() Returns registered
Attendee event name
(inherits Person) attendeeType getAttendeeType() Returns attendee
(string) type
(Student/VIP/etc.)
idCounter (static generatePassId() Generates unique
int) (static) Pass IDs
display() Shows complete
(overridden) attendee details

OOP and C++ Features to Use

Object-Oriented Programming Features
 Feature Usage in Code Explanation
Defines a blueprint for
Class class Attendee attendees, grouping data
and functions together.
Attendee Creates multiple objects
Object attendees[MAX_ATTENDEES] to hold each attendee's
; info.
These can only be
name, email, phone, eventName, accessed from inside the
Private Members
passID class, providing
encapsulation.
Allows interaction with
registerAttendee(),
Public Members private data in a
displayPass(), getPassID()
controlled way.
Shared by all objects.
Helps generate unique
Static Data Member static int idCounter;
Pass IDs for each
attendee.
Protects data from
Grouping data and functions in
Encapsulation outside interference,
class
allows clean interfaces.
Functions like registerAttendee()
Hides complex features
and displayPass() hide internal
Abstraction and shows only the
implementation and show only
function interface
relevant info.

C++ Features

Feature Usage in Code Explanation

Header Files #include <iostream>, #include Allows use of input/output
 <string> and string handling.
Avoids writing std:: before
Namespaces using namespace std; every standard function
like cout, cin, string.
const int MAX_ATTENDEES = Declares fixed values for
Constants
100; array size and event count.
string events[], Attendee Used to store a fixed list of
Arrays
attendees[] events and attendees.
Controls program flow
Control Statements if, else, do-while, for, continue based on user input and
conditions.
getline(), string concatenation Takes multi-word input
String Handling
(+) and formats pass ID.
Breaks code into reusable
Function Definition void registerAttendee(...), etc.
parts for clarity and reuse.
Attendee
Stores multiple attendee
Object Array attendees[MAX_ATTENDEES]
objects efficiently.
;
Static Member Required outside the class
int Attendee::idCounter = 1000;
Initialization for static members.
Used in passID = "PASS" + Converts integers to
to_string()
to_string(idCounter); strings.

E-R Diagram
Figure 1.1 E-R Diagram of the System.

Code Snippits
Figure 1.2 Code snippits

System Interface

Figure 1.3 Console based system interface

Conclusion
The Event Registration System project successfully demonstrates the practical application of
core C++ and Object-Oriented Programming (OOP) principles within a structured console-
based application. By limiting dependencies to only <iostream> and <string>, the project
emphasizes fundamental programming concepts while maintaining simplicity and clarity for
beginner developers.

The implementation highlights key OOP features such as class design, inheritance,
encapsulation, and polymorphism, providing a clear model for real-world entity relationships
(e.g., Attendee as a specialized Person). The use of static members for pass ID generation and
arrays for data storage introduces essential programming techniques without relying on
advanced libraries. The menu-driven interface ensures user-friendly navigation, while basic
input validation improves robustness.

Learning Outcomes:
This project serves as an introductory exercise in C++ programming, reinforcing:

 Class and Object Implementation

 Basic Memory Management (arrays)

 Control Flow and User Input Handling

 Debugging and Problem-Solving

In summary, this project effectively bridges theory and practice, offering a tangible example
of how OOP concepts translate into functional software. It provides a stepping stone for
further exploration of C++ and more complex system development.