-
About the Course 1
CDAC CCAT Study Materials
Crack your CDAC CCAT Exams in first attempt with LMT Study Materials- 📚Complete Study Notes (Concepts & Solved Example)
- 📌 500+ Practice Problems
- 📝 Formula's and tricks
- 👣 Beginner Friendly
- ⭐️ Trusted by 1000+ Students
- 📑 Previous Year Question Papers
- 📚 Section A + Section B + Section C [ All Notes Available ]
The one-stop destination for everything you need for CDAC CCAT Exam Preparations
So let's dive in - Enroll today, Crack the exam & get into top Institute of CDAC and get to work with your Dream Company-
Linear Search [Recursion and Storage Management] 05 minLecture1.1
-
Section A [ Quantitative ] - Number System 15
-
[ New Video ] Number System – 1 25 minLecture2.1
-
[ New Video ] Number System – 2 21 minLecture2.2
-
[ New Video ] Number System – 3 19 minLecture2.3
-
[ New Video ] Number System – 4 25 minLecture2.4
-
Number System Part #1 13 minLecture2.5
-
Number System Part #2 12 minLecture2.6
-
Number System Part #3 07 minLecture2.7
-
Number System Part #4 10 minLecture2.8
-
Number System Part #5 10 minLecture2.9
-
Number System Part #6 10 minLecture2.10
-
Number System Part #7 07 minLecture2.11
-
Number System Part #8 07 minLecture2.12
-
Number System Part #9 09 minLecture2.13
-
Number System Part #10 09 minLecture2.14
-
Number System, LCM & HCF Practice ProblemLecture2.15
-
-
Section A [ Quantitative ] - Simple and Compound Interest 8
-
Simple Interest Part #1 20 minLecture3.1
-
Simple Interest Part #2 19 minLecture3.2
-
Compound Interest Part #1 25 minLecture3.3
-
Compound Interest Part #2 23 minLecture3.4
-
Fastest Method to Solve Compound Interest 07 minLecture3.5
-
Simple Interest and compound [Formula]Lecture3.6
-
Simple and Compound Interest [Notes]Lecture3.7
-
Simple and Compound Interest [Practice Problems]Lecture3.8
-
-
Section A [ Quantitative ] - Decimal and Fractions 2
-
1. Decimal and Fractions 20 minLecture4.1
-
2. Decimal and Fractions 15 minLecture4.2
-
-
Section A [ Quantitative ] - Time, Speed and Distance 4
-
Time, Speed & Distance – 1 18 minLecture5.1
-
Time, Speed & Distance – 2 22 minLecture5.2
-
Time, Speed & Distance – 3 28 minLecture5.3
-
Time, Speed & Distance – Practice Question 34 minLecture5.4
-
-
Section A [ Quantitative ] - Odd Man Out and Series 2
-
Odd man out and series -1 19 minLecture6.1
-
Odd man out and series -2 17 minLecture6.2
-
-
Section A [ Quantitative ] - Perimeter, Area, Volume 2
-
Perimeter, Area, Volume – 1 20 minLecture7.1
-
Perimeter, Area, Volume – 2 20 minLecture7.2
-
-
Section A [ Quantitative ] - Simplification and Approximation 2
-
Simplification – 1 11 minLecture8.1
-
Simplification – 2 11 minLecture8.2
-
-
Section A [ Quantitative ] - Probability 7
-
Probability Part #1 16 minLecture9.1
-
Probability Part #2 14 minLecture9.2
-
Probability Part #3 28 minLecture9.3
-
Probability Part #4 28 minLecture9.4
-
Probability [ Formula and Solved Examples ]Lecture9.5
-
Probability [Practice Problems]Lecture9.6
-
Probability All PPT_Lecture9.7
-
-
Section A [ Quantitative ] - Calender 4
-
Calendar 13 minLecture10.1
-
Calendar Problem [Notes]Lecture10.2
-
Calendar Problem [Handmade Notes]Lecture10.3
-
Calendar Problem [ Practice Problem ]Lecture10.4
-
-
Section A [ Quantitative ] - Clock Problems 6
-
Clock Problems Part #1 13 minLecture11.1
-
Clock Problems Part #2 17 minLecture11.2
-
Clock Problems Part #3 10 minLecture11.3
-
Clock Problem [Handmade Notes]Lecture11.4
-
Clock Problem [ Notes]Lecture11.5
-
Clock Problem [ Practice Problem ]Lecture11.6
-
-
Section A [ Quantitative ] - Boats and Streams 7
-
Boats & Streams – 1 20 minLecture12.1
-
Boats & Streams – 2 25 minLecture12.2
-
Boats and Stream Part #1 10 minLecture12.3
-
Boats and Stream Part #2 11 minLecture12.4
-
Boat and Stream [Formula]Lecture12.5
-
Boat and Stream [Handmade Notes]Lecture12.6
-
Boat and Stream [Practice Problems]Lecture12.7
-
-
Section A [ Quantitative ] - Profit and Loss 9
-
[ New Video ] Profit & Loss – 1 16 minLecture13.1
-
[ New Video ] Profit & Loss – 2 26 minLecture13.2
-
[ New Video ] Profit & Loss – 3 18 minLecture13.3
-
Profit and Loss Part #1 09 minLecture13.4
-
Profit and Loss Part #2 21 minLecture13.5
-
Profit and Loss Part #3 15 minLecture13.6
-
Profit & Loss [Formula]Lecture13.7
-
Profit and Loss [ Notes ]Lecture13.8
-
Profit and Loss [Practice Problems]Lecture13.9
-
-
Section A [ Quantitative ] - Average 5
-
Average full Concept and Tricks Part #1 11 minLecture14.1
-
Average full Concept and Tricks Part #2 09 minLecture14.2
-
Average full Concept and Tricks Part #3Lecture14.3
-
Averages [ Notes ]Lecture14.4
-
Averages Practice Questions 26 minLecture14.5
-
-
Section A [ Quantitative ] - Arithmetic Progression and Geometric Progression 7
-
Arithmetic Progression Part #1 10 minLecture15.1
-
Arithmetic Progression Part #2 08 minLecture15.2
-
Geometric Progression Part #1 08 minLecture15.3
-
Geometric Progression Part #2 07 minLecture15.4
-
Sequence and Series # 1 [ AP – GP Practice Problem ] 25 minLecture15.5
-
Sequence and Series # 2 [ AP – GP – HP Practice Problem ] 22 minLecture15.6
-
Arithmetic Progression and Geometric Progression [ Notes ]Lecture15.7
-
-
Section A [ Quantitative ] - Surds and Indices 2
-
Section A [ Quantitative ] - Ages Problems 8
-
Ages Basic Concept with Solved Examples 09 minLecture17.1
-
Ages ConceptLecture17.2
-
Ages Part #1 12 minLecture17.3
-
Ages Part #2 08 minLecture17.4
-
Ages Practice Problems 18 minLecture17.5
-
Ages [ Formula ]Lecture17.6
-
Ages Problem [ Notes]Lecture17.7
-
Ages Problem [Practice Problems]Lecture17.8
-
-
Section A [ Quantitative ] - Alligations and Mixtures 5
-
Alligation and Mixture Part #1 18 minLecture18.1
-
Alligation and Mixture Part #2 19 minLecture18.2
-
Alligation and Mixtures [Formula]Lecture18.3
-
Alligation and Mixtures [Handmade Notes]Lecture18.4
-
Alligation and Mixtures [Practice Problems]Lecture18.5
-
-
Section A [ Quantitative ] - Chain rule 4
-
Chain Rule 15 minLecture19.1
-
Chain rule [ Formula]Lecture19.2
-
Chain Rule [Handmade Notes]Lecture19.3
-
Chain Rule [Practice Problems]Lecture19.4
-
-
Section A [ Quantitative ] - HCF and LCM 6
-
HCF and LCM Part #1 13 minLecture20.1
-
HCF and LCM Part #2 16 minLecture20.2
-
HCF and LCM Part #3 18 minLecture20.3
-
HCF and LCM [Formula]Lecture20.4
-
HCM and LCM [Handmade Notes]Lecture20.5
-
HCM and LCM [Practice Problems]Lecture20.6
-
-
Section A [ Quantitative ] - Percentage Problem 9
-
Percentage Part 1 08 minLecture21.1
-
Percentage Part 2 08 minLecture21.2
-
Percentage Part 3 09 minLecture21.3
-
Percentage Part 4 08 minLecture21.4
-
Percentage Part 5 09 minLecture21.5
-
Percentage Practice Questions 27 minLecture21.6
-
Percentage Problem [Formula]Lecture21.7
-
Percentage Problem [ Notes ]Lecture21.8
-
Percentage Problem [Practice Problems]Lecture21.9
-
-
Section A [ Quantitative ] - Permutation and Combination 6
-
Permutation and Combination Part #1 25 minLecture22.1
-
Permutation and Combination Part #2 19 minLecture22.2
-
Permutation and Combination Part #3 20 minLecture22.3
-
Permutation and Combination [Formula]Lecture22.4
-
Permutation and Combination [Handmade Notes]Lecture22.5
-
Permutation and Combination [Practice Problems]Lecture22.6
-
-
Section A [ Quantitative ] - Pipes and Cistern 7
-
Pipes and Cistern – 1 [ New Video ] 27 minLecture23.1
-
Pipes and Cistern – 2 [ New Video ] 23 minLecture23.2
-
Pipes and Cistern Part #1 27 minLecture23.3
-
Pipes and Cistern Part #2 16 minLecture23.4
-
Pipes and Cistern Part #3 12 minLecture23.5
-
Pipes and Cistern [Practice Problems]Lecture23.6
-
Pipes and Cistern [Handmade Notes]Lecture23.7
-
-
Section A [ Quantitative ] - Ratio and Proportion 8
-
Ratio & Proportion #1 13 minLecture24.1
-
Ratio & Proportion #2 12 minLecture24.2
-
Ratio & Proportion #3 13 minLecture24.3
-
Ratio & Proportion #4 10 minLecture24.4
-
Ratio & Proportion #5 08 minLecture24.5
-
Ratio and Proportion Practice Problem 33 minLecture24.6
-
Ratio and Proportion [ Notes ]Lecture24.7
-
Ratio and Proportion [Practice Problems]Lecture24.8
-
-
Section A [ Quantitative ] - Time and Work 10
-
Time and Work Part #1 26 minLecture25.1
-
Time and Work Part #2 26 minLecture25.2
-
Time and Work Part #3 27 minLecture25.3
-
Time and Work Part #4 22 minLecture25.4
-
Time and Work Part #1 [ Old Videos by Sumer ] 20 minLecture25.5
-
Time and Work Part #2 [ Old Videos by Sumer ] 13 minLecture25.6
-
Time and Work Part #3 [ Old Videos by Sumer ] 10 minLecture25.7
-
Time and Work[Formula]Lecture25.8
-
Time and Work [Practice Problems]Lecture25.9
-
Time and Work [Handmade Notes]Lecture25.10
-
-
Section A [ Quantitative ] - Train Problems 8
-
Train Problems Part #1 19 minLecture26.1
-
Train Problems Part #2 11 minLecture26.2
-
Train Problems Part #3 19 minLecture26.3
-
Problems on Train – 1 26 minLecture26.4
-
Problems on Train – 2 27 minLecture26.5
-
Train Problems [Formula]Lecture26.6
-
Train Problems [ Notes ]Lecture26.7
-
Train Problems [Practice Problems]Lecture26.8
-
-
Section A [ Verbal ] - Reading Comprehension 6
-
Reading Comprehension 13 minLecture27.1
-
Reading Comprehension [ Notes + Solved Examples + Practice Problem ]Lecture27.2
-
Reading Comprehension -1 24 minLecture27.3
-
Reading Comprehension -2 19 minLecture27.4
-
Reading Comprehension Notes 1Lecture27.5
-
Reading Comprehension Notes 2Lecture27.6
-
-
Section A [ Verbal ] - Synonyms And Antonyms 4
-
Synonyms and Antonyms 14 minLecture28.1
-
Synonyms And Antonyms [ Notes + Solved Examples + Practice Problem ]Lecture28.2
-
Synonyms 28 minLecture28.3
-
Antonyms 22 minLecture28.4
-
-
Section A [ Verbal ] - Sentence Rearrangement 3
-
Rearrangements – 1 21 minLecture29.1
-
Rearrangements – 2 21 minLecture29.2
-
Sentence Rearrangement NotesLecture29.3
-
-
Section A [ Verbal ] - Error Identification 2
-
Error Identification 13 minLecture30.1
-
Error Identification NotesLecture30.2
-
-
Section A [ Verbal ] - Paragraph 2
-
Paragraph 22 minLecture31.1
-
Paragraph FormationLecture31.2
-
-
Section A [ Verbal ] - Sentence Corrections 3
-
Sentence Corrections – 1 23 minLecture32.1
-
Sentence Corrections – 2 22 minLecture32.2
-
Sentence Correction NotesLecture32.3
-
-
Section A [ Verbal ] - Sentence Completion 2
-
Sentence Completion 18 minLecture33.1
-
Sentence Completion NotesLecture33.2
-
-
Section A [ Verbal ] - Fill in the Blanks 9
-
Conjunction 10 minLecture34.1
-
Prepositions 11 minLecture34.2
-
Articles 15 minLecture34.3
-
Tenses 21 minLecture34.4
-
Conjunction NotesLecture34.5
-
Prepositions NotesLecture34.6
-
Articles NotesLecture34.7
-
Tenses NotesLecture34.8
-
Tenses Practice ProblemsLecture34.9
-
-
Section A [ Verbal ] - Subject Verb Agreement 2
-
Subject Verb and Agreement 22 minLecture35.1
-
Subject Verb Agreement NotesLecture35.2
-
-
Section A [ Verbal ] - Roots words 2
-
Roots words [ Prefix and Suffix ] 13 minLecture36.1
-
Roots words [ Prefix and Suffix ] NotesLecture36.2
-
-
Section A [ Verbal ] - Idioms & Phrases 2
-
Idioms & Phrases – 1 24 minLecture37.1
-
Idioms & Phrases – 2 25 minLecture37.2
-
-
Section A [ Verbal ] - Verbal Ability Extra 9
-
Introduction to Verbal Ability + Tenses Part #1 12 minLecture38.1
-
Tenses Part #1 11 minLecture38.2
-
Tenses [ Notes + Solved Examples + Practice Problem ]Lecture38.3
-
Error Detection and Correction + Sentence Completion #1 14 minLecture38.4
-
Sentence Completion Part #2 13 minLecture38.5
-
Spotting Erorrs [ Notes + Solved Examples + Practice Problem ]Lecture38.6
-
Sentence Completion [ Notes + Solved Examples + Practice Problem ]Lecture38.7
-
Assumption in Verbal Reasoning 14 minLecture38.8
-
Deduction in Verbal Reasoning 26 minLecture38.9
-
-
Section A [ Reasoning ] - Blood Relation 6
-
Blood Relation Part #1 12 minLecture39.1
-
Blood Relation Part #2 10 minLecture39.2
-
Blood Relation Part #3 10 minLecture39.3
-
Blood Relation Part #4 09 minLecture39.4
-
Blood Relation [ Notes ]Lecture39.5
-
Blood Relation [ Practice Problem ]Lecture39.6
-
-
Section A [ Reasoning ] - Coding Decoding 7
-
Coding Decoding Part #1 07 minLecture40.1
-
Coding Decoding Part #2 08 minLecture40.2
-
Coding Decoding Part #3 08 minLecture40.3
-
Coding Decoding Part #4 06 minLecture40.4
-
Coding Decoding Part #5 10 minLecture40.5
-
Coding Decoding [Notes]Lecture40.6
-
Coding Decoding [ Practice Problem]Lecture40.7
-
-
Section A [ Reasoning ] - Data Sufficiency 3
-
Data Sufficiency 09 minLecture41.1
-
Data Sufficiency [ Practice Problem ]Lecture41.2
-
Data Sufficiency [ Notes ]Lecture41.3
-
-
Section A [ Reasoning ] - Direction 8
-
Direction Part #1 07 minLecture42.1
-
Direction Part #2 08 minLecture42.2
-
Direction Part #3 09 minLecture42.3
-
Direction Part #4 04 minLecture42.4
-
Direction Part #5 07 minLecture42.5
-
Direction Part #6 06 minLecture42.6
-
Direction [ Notes ]Lecture42.7
-
Direction [ Practice Problem ]Lecture42.8
-
-
Section A [ Reasoning ] - Number Series 6
-
Number Series Part #1 09 minLecture43.1
-
Number Series Part #2 08 minLecture43.2
-
Number Series Part #3 08 minLecture43.3
-
Number Series Part #4 04 minLecture43.4
-
Number Series [Notes]Lecture43.5
-
Number Series [Practice Problems]Lecture43.6
-
-
Section A [ Reasoning ] - Seating Arrangement 8
-
Seating Arrangement Part #1 08 minLecture44.1
-
Seating Arrangement Part #2 12 minLecture44.2
-
Seating Arrangement Part #3 11 minLecture44.3
-
Seating Arrangement Part #4 06 minLecture44.4
-
Seating Arrangement Part #5 07 minLecture44.5
-
Seating Arrangement Part #6 06 minLecture44.6
-
Seating Arrangement [Notes]Lecture44.7
-
Seating Arrangement [ Practice Problem ]Lecture44.8
-
-
Section A [ Reasoning ] - Visual Reasoning 6
-
Visual Reasoning Part #1 10 minLecture45.1
-
Visual Reasoning Part #2 12 minLecture45.2
-
Visual Reasoning Part #3 11 minLecture45.3
-
Visual Reasoning Part #4 11 minLecture45.4
-
Visual Reasoning [ Notes ]Lecture45.5
-
Visual Reasoning [ Practice Problem ]Lecture45.6
-
-
Section A [ Reasoning ] - Verbal Reasoning - Analogy 3
-
Analogy – 2 27 minLecture46.1
-
Analogy – 1 23 minLecture46.2
-
Analogy – 3 29 minLecture46.3
-
-
Section A - Computer Fundamental 12
-
1. Introduction 10 minLecture47.1
-
2. Computer Memory and its types 14 minLecture47.2
-
3. Motherboard and its component 08 minLecture47.3
-
4. Ports, Cables and Graphic Card 09 minLecture47.4
-
5. Storage Devices 07 minLecture47.5
-
6. Number System 11 minLecture47.6
-
7. Machine Language 06 minLecture47.7
-
8. Operating Systems 10 minLecture47.8
-
9. AR and VR 07 minLecture47.9
-
10. Computer Virus 08 minLecture47.10
-
Computer Fundamental [Notes]Lecture47.11
-
Computer Fundamental Practice ProblemLecture47.12
-
-
Section A - Concepts of Programming 3
-
Concepts of Programming NotesLecture48.1
-
Concepts of Programming Practice Problem 1Lecture48.2
-
Concepts of Programming Practice Problem 2Lecture48.3
-
-
Section B - [ C Programming ] 32
-
C Programming Part #1 10 minLecture49.1
-
C Programming Part #2 12 minLecture49.2
-
C Programming Part #3 16 minLecture49.3
-
C Programming Part #4 21 minLecture49.4
-
C Programming Part #5 23 minLecture49.5
-
C Programming Part #6 15 minLecture49.6
-
C Programming Part #7 15 minLecture49.7
-
C Programming Part #8 14 minLecture49.8
-
C Programming Part #9 15 minLecture49.9
-
C Programming Part #10 16 minLecture49.10
-
C Programming Part #11 12 minLecture49.11
-
C Programming Part #12 12 minLecture49.12
-
C Programming Part #13 19 minLecture49.13
-
C Programming Part #14 13 minLecture49.14
-
C Programming Part #15 15 minLecture49.15
-
C Programming Part #16 12 minLecture49.16
-
C Programming Part #17 13 minLecture49.17
-
C Programming Part #18 11 minLecture49.18
-
C Programming Part #19 16 minLecture49.19
-
C Programming Part #20 13 minLecture49.20
-
C Programming Part #21 23 minLecture49.21
-
C Programming Part #22 15 minLecture49.22
-
C Programming Part #23 14 minLecture49.23
-
C Programming Part #24 17 minLecture49.24
-
C Programming Part #25 11 minLecture49.25
-
C Programming Part #26 13 minLecture49.26
-
C Programming Part #27 14 minLecture49.27
-
C Programming Part #28 10 minLecture49.28
-
C Programming Part #29 10 minLecture49.29
-
C Programming Part #30 11 minLecture49.30
-
C Programming [Notes]Lecture49.31
-
C Programming Practice ProblemLecture49.32
-
-
Section B - [ Object Oriented Programming (C++) ] 27
-
Object Oriented Programming (C++) SampleLecture50.1
-
Object Oriented Programming (C++)Lecture50.2
-
Object Oriented Programming (C++) Practice ProblemLecture50.3
-
Introduction to C++ 11 minLecture50.4
-
Input & Output in C++ 14 minLecture50.5
-
Difference between Structure in C & C++ 14 minLecture50.6
-
Class & Objects C++ 14 minLecture50.7
-
Inspector, Mutators, Facilitators 16 minLecture50.8
-
Contructor & Destructor 15 minLecture50.9
-
Default Arguments & Inline Function 16 minLecture50.10
-
Array of Objects 16 minLecture50.11
-
Dynamic Memory Allocation 15 minLecture50.12
-
Static Member and function 15 minLecture50.13
-
Exception handling 18 minLecture50.14
-
Composition 22 minLecture50.15
-
Friend Class and function 13 minLecture50.16
-
Function Overloading 15 minLecture50.17
-
Operator Overloading 13 minLecture50.18
-
Copy Constructor 05 minLecture50.19
-
Inheritance 15 minLecture50.20
-
Pure Virtual Function 13 minLecture50.21
-
Types of Inheritance 26 minLecture50.22
-
Virtual Function 12 minLecture50.23
-
Template 15 minLecture50.24
-
RTTI 11 minLecture50.25
-
Casting Operators 19 minLecture50.26
-
Dynamic Array of Object 13 minLecture50.27
-
-
Section B - [ C Snippet Problems with Solutions Video] 10
-
Code Snippet 1 – 5 22 minLecture51.1
-
Code Snippet 6 -10 20 minLecture51.2
-
Code Snippet 11 – 15 19 minLecture51.3
-
Code Snippet 16 – 20 15 minLecture51.4
-
Code Snippet 21 – 25 24 minLecture51.5
-
Code Snippet 26 – 30 18 minLecture51.6
-
Code Snippet 31 – 35 25 minLecture51.7
-
Code Snippet 36 – 40 25 minLecture51.8
-
Code Snippet 41 – 45 13 minLecture51.9
-
Code Snippet 46 – 50 18 minLecture51.10
-
-
Section B - [ Operating System ] 40
-
1. Introduction of Operation System , Function , Objectives 18 minLecture52.1
-
2. OS Structure [ Monolithic , Layer , Microkernel ] 17 minLecture52.2
-
3. System Call its Types 10 minLecture52.3
-
4. Process State Transition Diagram 11 minLecture52.4
-
5. PCB ( Process Control Block ) 12 minLecture52.5
-
6. Threading and Multi-Threading 09 minLecture52.6
-
7. Scheduler and Types of Process Scheduling Algorithm 13 minLecture52.7
-
8. Various Scheduling Criteria 21 minLecture52.8
-
9. SJF – Scheduling Criteria 16 minLecture52.9
-
10. Priority Scheduling Non-Preemptive 15 minLecture52.10
-
11. SRTN Scheduling Algo 18 minLecture52.11
-
12. Round Robin Scheduling Criteria 15 minLecture52.12
-
13. Priority Scheduling Preemptive 14 minLecture52.13
-
14. Process Syncronization and IPC 13 minLecture52.14
-
15. Deadlock 08 minLecture52.15
-
15. 1 – Dead Lock Recovery 05 minLecture52.16
-
15.2 – Bankers algorithm with Solve Example Part 1 13 minLecture52.17
-
15.3 – Bankers Algorithm Part 2 (Resource Request algorithm) 09 minLecture52.18
-
16. Semaphore Producer Consumer Problem 12 minLecture52.19
-
17. OS Reader Writer & Dinning Philospher Problem 16 minLecture52.20
-
18. Memory Management & Partitioning 11 minLecture52.21
-
19. Memory Allocation Techniques 11 minLecture52.22
-
20. Paging & TLB 17 minLecture52.23
-
21. Segmentation 14 minLecture52.24
-
22. Virtual Memory & Demand Paging 13 minLecture52.25
-
23. Pagen Replacement Algorithms 16 minLecture52.26
-
24. File Managment File System 09 minLecture52.27
-
25. Disk Allocation Methods 11 minLecture52.28
-
26. Disk scheduling Algorithm 06 minLecture52.29
-
27. FCFS Disk Scheduling Algorithm 13 minLecture52.30
-
28. SSTF Disk Scheduling Algorithm 07 minLecture52.31
-
29. SCAN Disk Scheduling Algorithm 06 minLecture52.32
-
30. C SCAN Disk Scheduling Algorithm 05 minLecture52.33
-
31. Look Disk Scheduling Algorithm 04 minLecture52.34
-
32. C Look Disk Scheduling Algorithm 04 minLecture52.35
-
33. All in One ( FCFS SSTF SCAN CSCAN LOOK CLOOK ) 08 minLecture52.36
-
34. Input Output Management 10 minLecture52.37
-
Operating System Sample [Notes]–Lecture52.38
-
Operating System [Notes]Lecture52.39
-
Operating System Practice ProblemLecture52.40
-
-
Section B - [ Data Structures ] 92
-
Introduction [ Introduction ] 08 minLecture53.1
-
Types Of Data Structures [ Introduction ] 06 minLecture53.2
-
Operations Of Data Structures [ Introduction ] 06 minLecture53.3
-
Concept Of Abstract Data Type [ Introduction ] 06 minLecture53.4
-
Arrays – Part 1 [ Introduction ] 16 minLecture53.5
-
Arrays – Part 2 [ Introduction ] 19 minLecture53.6
-
Introduction To Stack [ Stacks ]Lecture53.7
-
Operations Of Stack ADT [ Stacks ] 06 minLecture53.8
-
Stack Implementation Using Array Part – 1 [ Stacks ] 10 minLecture53.9
-
Stack Implementation Using Array Part – 2 [ Stacks ] 12 minLecture53.10
-
Introduction Of Queue [ Queues ] 04 minLecture53.11
-
Operations Of Queue ADT [ Queues ] 04 minLecture53.12
-
Queue Implementation Using Array Part – 1 [ Queues ] 11 minLecture53.13
-
Queue Implementation Using Array Part – 2 [ Queues ] 09 minLecture53.14
-
Circular Queue Implementation Part – 1 [ Queues ] 12 minLecture53.15
-
Circular Queue Implementation Part – 2 [ Queues ] 09 minLecture53.16
-
Introduction To Linked List [ Linked Lists ] 05 minLecture53.17
-
Array Vs Linked List [ Linked Lists ] 07 minLecture53.18
-
Linked List Implementation Part – 1 [ Linked Lists ] 17 minLecture53.19
-
Linked List Implementation Part – 2 [ Linked Lists ] 10 minLecture53.20
-
Linked List Implementation Part – 3 [ Linked Lists ] 10 minLecture53.21
-
Linked List Implementation Part – 4 [ Linked Lists ] 14 minLecture53.22
-
Linked List Implementation Part – 5 [ Linked Lists ] 09 minLecture53.23
-
Linked List Implementation Part – 6 [ Linked Lists ] 10 minLecture53.24
-
Stack Linked List #1 [ Linked Lists ] 09 minLecture53.25
-
Stack Linked List #2 [ Linked Lists ] 06 minLecture53.26
-
Queue Using Linked List Part – 1 [ Linked Lists ] 10 minLecture53.27
-
Queue Using Linked List Part – 2 [ Linked Lists ] 07 minLecture53.28
-
Circular Queue Using Linked List [ Linked Lists ] 10 minLecture53.29
-
Doubly Linked List – Part 1 [ Linked Lists ] 14 minLecture53.30
-
Doubly Linked List – Part 2 [ Linked Lists ] 08 minLecture53.31
-
Doubly Linked List – Part 3 [ Linked Lists ] 10 minLecture53.32
-
Doubly Linked List – Part 4 [ Linked Lists ] 10 minLecture53.33
-
Doubly Linked List – Part 5 [ Linked Lists ] 12 minLecture53.34
-
Introduction to Tree Data Structure & Binary Tree [ Trees ] 06 minLecture53.35
-
Binary Tree Implementation Part 1 – Insertion & Traversing [ Trees ] 14 minLecture53.36
-
Binary Tree Implementation Part 2 – Traversing & Deletion [ Trees ] 12 minLecture53.37
-
Binary tree Traversal [ Trees ] 14 minLecture53.38
-
Tree traversal methods: Pre, post and in-order traversal [ Trees ] 14 minLecture53.39
-
(Binary Search Tree) – Traverse the Tree in In-Order, Pre-Order and Post-Order [ Trees ] 11 minLecture53.40
-
Height Balaced Binary Search Tree [ Trees ] 12 minLecture53.41
-
AVL Tree [ Trees ] 16 minLecture53.42
-
AVL Tree Solved Example – #1 [ Trees ] 17 minLecture53.43
-
AVL Tree Solved Example – #2 [ Trees ] 17 minLecture53.44
-
B-Tree Introduction [ Trees ] 13 minLecture53.45
-
B-Tree Solved Example – #1 [ Trees ] 14 minLecture53.46
-
B-Tree Solved Example – #2 [ Trees ] 12 minLecture53.47
-
Huffman Coding [ Trees ] 07 minLecture53.48
-
Graphs Introduction [ Graphs ] 13 minLecture53.49
-
BFS & DFS – #1 [ Graphs ] 14 minLecture53.50
-
BFS & DFS – #2 [ Graphs ] 12 minLecture53.51
-
Topological Sorting [ Graphs ] 11 minLecture53.52
-
Topological Sorting – Solved Example [ Graphs ] 09 minLecture53.53
-
Hashing Concept [ Searching & Sorting ] 06 minLecture53.54
-
Hashing Collision [ Searching & Sorting ] 12 minLecture53.55
-
Linear Probing – #1 [ Searching & Sorting ] 13 minLecture53.56
-
Linear Probing – #2 [ Searching & Sorting ] 12 minLecture53.57
-
Linear Probing With Collisions – Solved [ Searching & Sorting ] 10 minLecture53.58
-
Linear + Quadratic Probing – Solved Example [ Searching & Sorting ] 14 minLecture53.59
-
Searching & Sorting Introduction [ Searching & Sorting ] 11 minLecture53.60
-
Selection Sorting – #1 [ Searching & Sorting ] 12 minLecture53.61
-
Selection Sorting – #2 [ Searching & Sorting ] 12 minLecture53.62
-
Insertion Sort – #1 [ Searching & Sorting ] 12 minLecture53.63
-
Insertion Sort – #2 [ Searching & Sorting ] 12 minLecture53.64
-
Merge Sort – #1 [ Searching & Sorting ] 12 minLecture53.65
-
Merge Sort – #2 [ Searching & Sorting ] 12 minLecture53.66
-
Merge Sort – #3 [ Searching & Sorting ] 10 minLecture53.67
-
Quick Sort – #1 [ Searching & Sorting ] 10 minLecture53.68
-
Quick Sort – #2 [ Searching & Sorting ] 09 minLecture53.69
-
Radix Sort – #1 [ Searching & Sorting ] 10 minLecture53.70
-
Radix Sort – #2 [ Searching & Sorting ] 10 minLecture53.71
-
Introduction to Buddy System [Recursion and Storage Management] 10 minLecture53.72
-
Problems on Buddy System [Recursion and Storage Management] 08 minLecture53.73
-
Recursion – Winding & Unwinding [Recursion and Storage Management] 11 minLecture53.74
-
Binary Search [Recursion and Storage Management] 10 minLecture53.75
-
Linear Search [Recursion and Storage Management] 05 minLecture53.76
-
Recursion – Winding & Unwinding [Recursion and Storage Management] 11 minLecture53.77
-
Heap Data Structure 11 minLecture53.78
-
Min & Max Heap 11 minLecture53.79
-
Infix Notation & Conversion 11 minLecture53.80
-
Prefix, Postfix Notation & Conversion 12 minLecture53.81
-
Prim’s & Kruskal’s #1 18 minLecture53.82
-
Prim’s & Kruskal’s #2 10 minLecture53.83
-
Divide & Conquer With Example 06 minLecture53.84
-
DP Approaches -1 10 minLecture53.85
-
DP Approaches -2 07 minLecture53.86
-
Asymptotic Notations 03 minLecture53.87
-
Time Complexity and Big O 22 minLecture53.88
-
Space Complexity 14 minLecture53.89
-
Data Structures & AlgorithmsLecture53.90
-
Practice Problems Set 1 – Data Structures & AlgoLecture53.91
-
Practice Problems Set 2 – Data Structures & AlgoLecture53.92
-
-
Section B -[Data Community & Networking] 18
-
1. Introduction To Computer Networks 11 minLecture54.1
-
2. Network Topology Types 12 minLecture54.2
-
3. Network Connecting Devices [ Repeater , Hub , Bridge , Switch ] 10 minLecture54.3
-
4. Types of Network – LAN, MAN, WAN 07 minLecture54.4
-
5. Virtual LAN 07 minLecture54.5
-
6. OSI Reference Model 06 minLecture54.6
-
7. TCP-IP Reference model 06 minLecture54.7
-
8. IPv4 Header Format 12 minLecture54.8
-
9. IP Address v/s MAC Address 08 minLecture54.9
-
10. IPv4 v/s IPv6 09 minLecture54.10
-
11. ARP & RARP 07 minLecture54.11
-
12. Simple Mail Transfer Protocol – SMTP 05 minLecture54.12
-
13. User Datagram Protocol 07 minLecture54.13
-
14. File Transfer Protocol – FTP 05 minLecture54.14
-
15. Domain Name Server – DNS 06 minLecture54.15
-
16. Hypertext Transfer Protocol – HTTP 08 minLecture54.16
-
Computer Network [Notes]Lecture54.17
-
Computer Network Practice ProblemLecture54.18
-
-
Section B - [ AI Notes ] 2
-
Artificial Intelligence NotesLecture55.1
-
Artificial Intelligence Practice ProblemsLecture55.2
-
-
Section B - [ Big Data Notes ] 5
-
Module 1 – Introduction to Big DataLecture56.1
-
Module 2 _ Hadoop HDFS and MapReduceLecture56.2
-
Module 3 _ NO SQLLecture56.3
-
Module 4 _ Mining Data StreamLecture56.4
-
Module 5 _ Real Time Big Data ModelsLecture56.5
-
-
Section B - [ Basics of Big Data and Artificial Intelligence ] 20
-
Agent and Peas Description [ Artificial Intelligence ] 08 minLecture57.1
-
Introduction to Fuzzy Logic [ Artificial Intelligence ] 04 minLecture57.2
-
Types of Agent [ Artificial Intelligence ] 08 minLecture57.3
-
Learning Agent [ Artificial Intelligence ] 08 minLecture57.4
-
Introduction to Machine Learning [ Artificial Intelligence ] 12 minLecture57.5
-
Types of Machine Learning [ Artificial Intelligence ] 05 minLecture57.6
-
Introduction to Neural Network [ Artificial Intelligence ] 06 minLecture57.7
-
Genetic Algorithm [ Artificial Intelligence ] 05 minLecture57.8
-
Introduction to Big Data [ Big Data ] 06 minLecture57.9
-
Hadoop Part 1 [ Big Data ] 10 minLecture57.10
-
Hadoop Part 2 [ Big Data ] 10 minLecture57.11
-
Map Reduce [ Big Data ] 11 minLecture57.12
-
Introduction to No SQL [ Big Data ] 08 minLecture57.13
-
Introduction to Datawarehouse [ Big Data ] 10 minLecture57.14
-
Meta Data [ Big Data ] 04 minLecture57.15
-
Data mart [ Big Data ] 06 minLecture57.16
-
Architecture of Data Warehouse [ Big Data ] 07 minLecture57.17
-
What is Olap Operation [ Big Data ] 08 minLecture57.18
-
OLAP vs OLTP [ Big Data ] 07 minLecture57.19
-
ETL – Extract Transform and Load [ Big Data ] 08 minLecture57.20
-
-
Section B - [ AI Notes for CCAT Exam ] 5
-
AI Domain [ Data Science , Computer Vision , NLP ]Lecture58.1
-
Basics of Artificial IntelligenceLecture58.2
-
Future of AI TrendsLecture58.3
-
Introduction to Neural Networks, Fuzzy Logic, and Genetic AlgorithmsLecture58.4
-
Ways to Implement AI – Machine Learning & Deep LearningLecture58.5
-
-
Section B - [ Big Data Notes for CCAT Exam ] 1
-
Big Data Notes for CCAT ExamLecture59.1
-
-
Quiz 6
-
Section A – Quiz #1 [Free]Lecture60.1
-
Section A – Quiz #2 [Premium]Lecture60.2
-
Section B – Quiz #1 [Free]Lecture60.3
-
Section B – Quiz #2 [Premium]Lecture60.4
-
Section C – Quiz #1 [Free]Lecture60.5
-
Section C – Quiz #2 [Premium]Lecture60.6
-
-
Previous Year Leak Papers 6
-
Section A8 18 dec 2016 morningLecture61.1
-
Section A-17 December 2017Lecture61.2
-
Section B – 17 December 2017Lecture61.3
-
Section B 10 December 2017Lecture61.4
-
Section B – 18 June 2017Lecture61.5
-
SectionB-23-june-2019Lecture61.6
-
-
CCAT Previous Year Leak Paper Solution 8
-
CCAT Section A SOLUTION – 2016Lecture62.1
-
CCAT Section A Solution – DEC 2017Lecture62.2
-
CCAT Sec A DEC 2017 Day 2 SolutionLecture62.3
-
CCAT Sec A June 2019 Paper SolutionLecture62.4
-
CCAT Sec B June 2017 SolutionLecture62.5
-
CCAT SEC B Dec 2017 SolutionLecture62.6
-
CCAT Sec B Dec 2017 Day 2 SolutionLecture62.7
-
CCAT Sec B June 2019 SolutionsLecture62.8
-

CPP Programming
1. Introduction To C++
• Limitations Of C Language
• A Brief History of C++ And Characteristics
• C++ Organization
• Object Oriented Programming
• Basic I/O in C++
• Data Types In C++
• Variable
• Escape sequences
• Constants And Keywords
2.
Object Oriented Programming System in C++
• OOPS in C++
• Classes in C++
• Objects in C++
• Abstraction In C++
• Encapsulation In C++
• Inheritance in C++
• Polymorphism in C++
3.
Functions, Constructors, Structures and
Keywords in C++
• Function definition

• Constructors In C++
• Structures in C++
• const Keyword in C++
• static Keyword in C++
4. [Bonus] Extra Topic
• Exception Handling in C++
• Initializer List in C++
• Header Guards in C++

1. Introduction To C++
★ Limitations Of C Language
The limitations of C programming languages are as follows:
• Difficult to debug.
• C allows a lot of freedom in writing code, and that is why you can put an
empty line or white space anywhere in the program. And because there is no
fixed place to start or end the line, so it isn't easy to read and understand the
program.
• C compilers can only identify errors and are incapable of handling exceptions
(run-time errors).
• C provides no data protection.
• It also doesn't feature the reusability of source code extensively.
• It does not provide strict data type checking (for example, an integer value can
be passed for floating datatype).
Categorisation Of High Level Languages
High-level programming languages
The high-level programming languages can be categorized into different types on
the basis of the application area in which they are employed as well as the
different design paradigms supported by them. The high-level programming
languages are designed for use in a number of areas. Each high-level language is
designed by keeping its target application area in mind. Some of the high-level
languages are best suited for business domains, while others are apt in the scientific
domain only. The high-level language can be categorized on the basis of the various
programming paradigms approved by them. The programming paradigms refer to the
approach employed by the programming language for solving the different types of
problem.
1. Categorisation based on Application
On the basis of application area the high level language can be divided into the
following types:
i) Commercial languages
These programming languages are dedicated to the commercial domain and are
specially designed for solving business-related problems. These languages can be

used in organizations for processing handling the data related to payroll, accounts
payable and tax building applications. COBOL is the best example of the commercial
based high-level programming language employed in the business domain.
ii) Scientific languages
These programming languages are dedicated to the scientific domain and are
specially designed for solving different scientific and mathematical problems. These
languages can be used to develop programs for performing complex calculation
during scientific research. FORTRAN is the best example of scientific based
language.
iii) Special purpose languages
These programming languages are specially designed for performing some dedicated
functions. For example, SQL is a high-level language specially designed to interact
with the database programs only. Therefore we can say that the special purpose
high-level language is designed to support a particular domain area only.
iv) General purpose languages
These programming languages are used for developing different types of software
applications regardless of their application area. The various examples of general
purpose high-level programming languages are BASIC, C, C++, and java.
2.
Categorisation based on Design paradigm
On the basis of design paradigms the high level programming languages can be
categorised into the following types:
i) Procedure-oriented languages
These programming languages are also called an imperative programming language.
In this language, a program is written as a sequence of procedures. Each procedure
contains a series of instructions for performing a specific task. Each procedure can be
called by the other procedures during the program execution. In this type of
programming paradigms, a code once written in the form of a procedure can be used
any number of times in the program by only specifying the corresponding procedure
name. Therefore the procedure-oriented language allows the data to move freely
around the system. The various examples of procedure-oriented language are
FORTRAN, ALGOL, C, BASIC, and ADA.
ii) Logic-oriented languages
These languages use logic programming paradigms as the design approach for
solving various computational problems. In this programming paradigm predicate

logic is used to describe the nature of a problem by defining the relationship between
rules and facts. Prolog is the best example of the logic-oriented programming
language.
iii) Object-oriented languages
These languages use object-oriented programming paradigms as the design approach
for solving a given problem. In this programming language, a problem is divided into
a number of objects which can interact by passing messages to each other. C++ and C# are
examples of object-oriented programming languages.
★ A Brief History of C++
• The history of C++ begins with C. The reason for this is easy to understand:
C++ is built upon the foundation of C. Thus, C++ is a superset of C.
• C++ expanded and enhanced the C language to support object-oriented
programming (which is described later in this module).
• C++ also added several other improvements to the C language, including an
extended set of library routines. However, much of the spirit and flavor of C++
is directly inherited from C. Therefore, to fully understand and appreciate C++,
you need to understand the “how and why” behind C.
• C++ is regarded as a middle-level language, as it comprises a combination of
both high-level and low-level language features.
• The C++ programming language was created by Bjarne Stroustrup and his team
at Bell Laboratories (AT&T, USA) to help implement simulation projects in an
object-oriented and efficient way. The earliest versions, which were originally
referred to as “C with classes,” date back to 1980. As the name C++ implies,
C++ was derived from the C programming language: ++ is the increment
operator in C.
Characteristics of C++
C++ is not a purely object-oriented language but a hybrid that contains the
functionality of the C programming language. This means that you have all the
features that are available in C:
• Universally usable modular programs
• Efficient, close to the machine programming
• Portable programs for various platforms.
★ C++ Organization

• C++ is designed as a bridge between the programmer and the raw computer.
• The idea is to let the programmer organize a program in a way that he or she
can easily understand.
• The compiler then translates the language into something the machine can use.
• Computer programs consist of two main parts: data and instructions. The
computer imposes little or no organization on these two parts.
• After all, computers are designed to be as general as possible. The idea is for
the programmer to impose his or her own organization on the computer and
not the other way around.
C++ Compilation Process
It is fundamental to know how C++ compilation works to understand how programs
are compiled and executed. Compiling C++ source code into machine-readable code
consists of the following four processes:
1. Preprocessing the source code.
2. Compiling the source code.
3. Assembling the compiled file.
4. Linking the object code file to create an executable file.
Let's start with a simple C++ program to understand how compilation happens.
#include <iostream>
int main(){
// This is a single line comment
/* This is a multi-line
comment */
std::cout << "Hello Universe" << std::endl;
return 0;
}
Let's demystify the C++ compilation process using the following diagram:
/Object+Oriented+Programming+(C%2B%2B)+Sample/background007.jpg)
1. When the C++ preprocessor encounters the #include <file> directive, it
replaces it with the content of the file creating an expanded source code file.
2. Then, this expanded source code file is compiled into an assembly language
for the platform.
3. The assembler converts the file that's generated by the compiler into the object
code file.
4. This object code file is linked together with the object code files for any
library functions to produce an executable file.
/Object+Oriented+Programming+(C%2B%2B)+Sample/background008.jpg)
Difference Between Header and Source Files
Source files contain the actual implementation code. Source files typically have the
extension .cpp, although other extensions such as .cc, .ccx, or .c++ are also quite
common.

On the other hand, header files contain code that describes the functionalities that are
available. These functionalities can be referred to and used by the executable code in
the source files, allowing source files to know what functionality is defined in other
source files.
Compiling And Linking Process
Compilation is a process that ensures that a program is syntactically correct, but it
does not perform any checks regarding its logical correctness. This means that a
program that compiles correctly might still produce undesired results:
Every C++ program needs to define a starting point, that is, the part of the code the
execution should start from. The convention is to have a uniquely named main
function in the source code, which will be the first thing to be executed. This function
is called by the operating system, so it needs to return a value that indicates the status of
the program; for this reason, it is also referred to as the exit status code.
★ Object-Oriented Programming
Central to C++ is object-oriented programming (OOP). As just explained, OOP was
the impetus for the creation of C++. Because of this, it is useful to understand OOP’s
basic principles before you write even a simple C++ program.
Object-oriented programming offers several major advantages to software
development:
• Reduced susceptibility to errors: an object controls access to its own data.
More specifically, an object can reject erroneous access attempts.
• Easy re-use: objects maintain themselves and can therefore be used as
building blocks for other programs.
• Low maintenance requirement: an object type can modify its own internal
data representation without requiring changes to the application.
A First Simple C++ Program
/* This is a simple C++ program. Call this file Sample.cpp. */
#include<iostream>
using namespace std;
// A C++ program begins at main().
int main()
{
cout << "C++ is power programming.";
/Object+Oriented+Programming+(C%2B%2B)+Sample/background010.jpg)
return 0;
}
Output
/* When run, the program displays the following output:*/
C++ is power programming.
★ Basic I/O in C++
The C++ standard libraries provide an extensive set of input/output capabilities which
we will see in subsequent chapters. This chapter will discuss very basic and most
common I/O operations required for C++ programming.
C++ I/O occurs in streams, which are sequences of bytes. If bytes flow from a device
like a keyboard, a disk drive, or a network connection etc. to main memory, this is
called input operation and if bytes flow from main memory to a device like a display
screen, a printer, a disk drive, or a network connection, etc., this is called output
operation.
I/O Library Header Files
There are following header files important to C++ programs −
The Standard Output Stream (cout)
The predefined object cout is an instance of ostream class. The cout object is said to
be "connected to" the standard output device, which usually is the display screen. The

cout is used in conjunction with the stream insertion operator, which is written as <<
which are two less than signs as shown in the following example.
#include <iostream>
using namespace std;
int main() {
char str[] = "Hello C++";
cout << "Value of str is : " << str << endl;
}
When the above code is compiled and executed, it produces the following result −
Value of str is : Hello C++
The C++ compiler also determines the data type of variable to be output and selects
the appropriate stream insertion operator to display the value. The << operator is
overloaded to output data items of built-in types integer, float, double, strings and
pointer values.
The insertion operator << may be used more than once in a single statement as shown
above and endl is used to add a new-line at the end of the line.
The Standard Input Stream (cin)
The predefined object cin is an instance of istream class. The cin object is said to be
attached to the standard input device, which usually is the keyboard. The cin is used
in conjunction with the stream extraction operator, which is written as >> which are
two greater than signs as shown in the following example.
#include <iostream>
using namespace std;
int main() {
char name[50];
cout << "Please enter your name: ";
cin >> name;
cout << "Your name is: " << name << endl;
}
When the above code is compiled and executed, it will prompt you to enter a name.
You enter a value and then hit enter to see the following result −
Please enter your name: cplusplus

Your name is: cplusplus
The C++ compiler also determines the data type of the entered value and selects the
appropriate stream extraction operator to extract the value and store it in the given
variables.
The stream extraction operator >> may be used more than once in a single statement.
To request more than one datum you can use the following −
cin >> name >> age;
This will be equivalent to the following two statements −
cin >> name;
cin >> age;
The Standard Error Stream (cerr)
The predefined object cerr is an instance of ostream class. The cerr object is said to
be attached to the standard error device, which is also a display screen but the object
cerr is un-buffered and each stream insertion to cerr causes its output to appear
immediately.
The cerr is also used in conjunction with the stream insertion operator as shown in
the following example.
#include <iostream>
using namespace std;
int main() {
char str[] = "Unable to read
";
cerr << "Error message : " << str << endl;
}
When the above code is compiled and executed, it produces the following result −
Error message : Unable to read
The Standard Log Stream (clog)
The predefined object clog is an instance of ostream class. The clog object is said to
be attached to the standard error device, which is also a display screen but the object
clog is buffered. This means that each insertion to clog could cause its output to be
held in a buffer until the buffer is filled or until the buffer is flushed.
/Object+Oriented+Programming+(C%2B%2B)+Sample/background013.jpg)
The clog is also used in conjunction with the stream insertion operator as shown in
the following example.
#include <iostream>
using namespace std;
int main() {
char str[] = "Unable to read
";
clog << "Error message : " << str << endl;
}
When the above code is compiled and executed, it produces the following result −
Error message : Unable to read
You would not be able to see any difference in cout, cerr and clog with these small
examples, but while writing and executing big programs the difference becomes
obvious. So it is good practice to display error messages using cerr stream and while
displaying other log messages then clog should be used.
★ Datatypes In C++
There are 4 types of data types in C++ language.
Basic Data Types
The basic data types are integer-based and floating-point based. C++ language
supports both signed and unsigned literals.
The memory size of basic data types may change according to the 32 or 64 bit
operating system.
Let's see the basic data types. Its size is given according to 32 bit OS.
/Object+Oriented+Programming+(C%2B%2B)+Sample/background014.jpg)
Derived Data Types
/Object+Oriented+Programming+(C%2B%2B)+Sample/background015.jpg)
The data-types that are derived from the primitive or built-in datatypes are referred to
as Derived Data Types. These can be of four types namely:
1. Function
2. Array
3. Pointer
4. Reference
Abstract or User-Defined Data Types
These data types are defined by user itself. Like, defining a class in C++ or a
structure. C++ provides the following user-defined datatypes:
1. Class
2. Structure
3. Union
4. Enumeration
5. Typedef defined DataType
Datatype Modifiers
As the name implies, datatype modifiers are used with the built-in data types to
modify the length of data that a particular data type can hold.
Data type modifiers available in C++ are:
Signed
• Unsigned
• Short
• Long
Below table summarizes the modified size and range of built-in datatypes when
combined with the type modifiers:
/Object+Oriented+Programming+(C%2B%2B)+Sample/background016.jpg)
★ Variables
A variable is a name of memory location. It is used to store data. Its value can be
changed and it can be reused many times.
It is a way to represent memory location through symbol so that it can be easily
identified.
Let's see the syntax to declare a variable:
1. int x;
2. float y;

3. char z;
Here, x, y, z are variables and int, float, char are data types.
We can also provide values while declaring the variables as given below:
1. int x=5,b=10; //declaring 2 variable of integer type
2. float f=30.8;
3. char c='A';
Rules for defining variables
1. A variable can have alphabets, digits and underscore.
2. A variable name can start with an alphabet and underscore only. It can't start
with a digit.
3. No white space is allowed within the variable name.
4. A variable name must not be any reserved word or keyword e.g. char, float
etc.
5. Valid variable names:
• int a;
• int _ab;
• int a30;
6. Invalid variable names:
• int 4;
• int x y;
• int double;
Scope Of Variables
In general, the scope is defined as the extent up to which something can be worked
with. In programming also the scope of a variable is defined as the extent of the
program code within which the variable can be accessed or declared or worked with.
There are mainly two types of variable scopes:
1. Local Variables
2. Global Variables
/Object+Oriented+Programming+(C%2B%2B)+Sample/background018.jpg)
Now let’s understand each of the scope at a greater detail:
Local Variables
Variables defined within a function or block are said to be local to those functions.
• Anything between ‘{‘ and ‘}’ is said to inside a block.
• Local variables do not exist outside the block in which they are declared, i.e.
they can not be accessed or used outside that block.
• Declaring local variables: Local variables are declared inside a block.
// CPP program to illustrate
// usage of local variables
#include<iostream>
using namespace std;
void func(){
// this variable is local to the
// function func() and cannot be
// accessed outside this function
int age=18;
}
int main() {
cout<<"Age is: "<<age;
return 0;
}

Output:
Error: age was not declared in this scope
The above program displays an error saying “age was not declared in this scope”. The
variable age was declared within the function func() so it is local to that function and
not visible to portion of program outside this function.
Rectified Program : To correct the above error we have to display the value of
variable age from the function func() only. This is shown in the below program:
// CPP program to illustrate
// usage of local variables
#include<iostream>
using namespace std;
void func()
{
// this variable is local to the
// function func() and cannot be
// accessed outside this function
int age=18;
cout<<age;
}
int main()
{
cout<<"Age is: ";
func();
return 0;
}
Output:
Age is: 18

Global Variables
As the name suggests, Global Variables can be accessed from any part of the
program.
• They are available throughout the lifetime of a program.
• They are declared at the top of the program outside all of the functions or
blocks.
• Declaring global variables: Global variables are usually declared outside of
all of the functions and blocks, at the top of the program. They can be
accessed from any portion of the program.
// CPP program to illustrate
// usage of global variables
#include<iostream>
using namespace std;
// global variable
int global = 5;
// global variable accessed from
// within a function
void display()
{
cout<<global<<endl;
}
// main function
int main()
{
display();
// changing value of global
// variable from main function
global = 10;
display();
}
Output:

5
10
In the program, the variable “global” is declared at the top of the program outside all
of the functions so it is a global variable and can be accessed or updated from
anywhere in the program.
What if there exists a local variable with the same name as that of global
variable inside a function?
Let us repeat the question once again. The question is : if there is a variable inside a
function with the same name as that of a global variable and if the function tries to
access the variable with that name, then which variable will be given precedence?
Local variable or Global variable? Look at the below program to understand the
question:
// CPP program to illustrate
// scope of local variables
// and global variables together
#include<iostream>
using namespace std;
// global variable
int global = 5;
// main function
int main()
{
// local variable with same
// name as that of global variable
int global = 2;
cout << global << endl;
}
Look at the above program. The variable “global” declared at the top is global and
stores the value 5 whereas that declared within the main function is local and stores a
value 2. So, the question is when the value stored in the variable named “global” is
printed from the main function then what will be the output? 2 or 5?
/Object+Oriented+Programming+(C%2B%2B)+Sample/background022.jpg)
• Usually when two variable with the same name are defined then the compiler
produces a compile time error. But if the variables are defined in different
scopes then the compiler allows it.
• Whenever there is a local variable defined with same name as that of a global
variable then the compiler will give precedence to the local variable
★ Escape Sequences
Escape sequences are used in the programming languages C and C++ , and their
design was copied in many other languages such as Java and C# . Escape sequences
are the special characters used in control string to modify the format of the output.
These characters are not displayed in output. These characters are used with
combination of backslash \. This backslash \ is called escape character.
Table of Escape sequence of C & C++ are as follows:
/Object+Oriented+Programming+(C%2B%2B)+Sample/background023.jpg)
★ Constants
Constants refer to fixed values that the program may not alter and they are called
literals.
Constants can be of any of the basic data types and can be divided into Integer
Numerals, Floating-Point Numerals, Characters, Strings and Boolean Values.
Again, constants are treated just like regular variables except that their values cannot
be modified after their definition.
Keywords
This is a list of reserved keywords in C++. Since they are used by the language, these
keywords are not available for re-definition or overloading.
/Object+Oriented+Programming+(C%2B%2B)+Sample/background024.jpg)


