-
About the Course 0
LMT - SEBI GRADE A 2025 - IT This Course is Only Available
On Our AppDive in and start learning. Get offline access to all the course contents!
No items in this section -
[ Phase 1 Quantitative ] Quadratic Equation 3
-
Equations, Prerequisites for Quadratic Equations -1 14 minLecture2.1
-
Quadratic Equations Concepts -2 22 minLecture2.2
-
Quadratic Equation Questions – 3 27 minLecture2.3
-
-
[ Phase 1 Quantitative ] Discount 2
-
Discount – 1 22 minLecture3.1
-
Discount – 2 19 minLecture3.2
-
-
[ Phase 1 Quantitative ] Ratio and Proportion 10
-
Ratio & Proportion 17 minLecture4.1
-
Ratio & Proportion #1 13 minLecture4.2
-
Ratio & Proportion #2 12 minLecture4.3
-
Ratio & Proportion #3 13 minLecture4.4
-
Ratio & Proportion #4 10 minLecture4.5
-
Ratio & Proportion #5 08 minLecture4.6
-
Ratio & Proportion, Practice Questions 32 minLecture4.7
-
Ratio and Proportion [ Notes ]Lecture4.8
-
Ratio and Proportion [Practice Problems]Lecture4.9
-
Ratio and Proportion Practice Problems NotesLecture4.10
-
-
[ Phase 1 Quantitative ] Average 7
-
Average full Concept and Tricks Part 1 11 minLecture5.1
-
Average full Concept and Tricks Part 2 09 minLecture5.2
-
Average full Concept and Tricks Part 3 09 minLecture5.3
-
Averages Practice Questions 26 minLecture5.4
-
Averages [ Notes ]Lecture5.5
-
📌 Practice Problems [Quiz] – AverageLecture5.6
-
Average Practice ProblemsLecture5.7
-
-
[ Phase 1 Quantitative ] Allegations and Mixtures 6
-
Alligation and Mixture Part #1 18 minLecture6.1
-
Alligation and Mixture Part #2 19 minLecture6.2
-
📌 Practice Problems [Quiz] – Alligation and MixturesLecture6.3
-
Alligation and Mixtures [Handmade Notes]Lecture6.4
-
Allegation and Mixtures [Formula]Lecture6.5
-
Allegations and Mixtures Practice ProblemsLecture6.6
-
-
[ Phase 1 Quantitative ] Percentage 10
-
Percentage Part 1 08 minLecture7.1
-
Percentage Part 2 08 minLecture7.2
-
Percentage Part 3 09 minLecture7.3
-
Percentage Part 4 08 minLecture7.4
-
Percentage Part 5 09 minLecture7.5
-
Fast Tricks For Percentage 12 minLecture7.6
-
Percentage Practice Questions 27 minLecture7.7
-
Percentage [Notes]Lecture7.8
-
📌 Practice Problems [Quiz] – PercentageLecture7.9
-
Percentage Practice [Formula]Lecture7.10
-
-
[ Phase 1 Quantitative ] Profit and Loss 8
-
Profit & Loss – 1 [NEW VIDEO] 16 minLecture8.1
-
Profit & Loss – 2 [NEW VIDEO] 26 minLecture8.2
-
Profit & Loss – 3 [NEW VIDEO] 18 minLecture8.3
-
Profit and Loss Part #1 09 minLecture8.4
-
Profit and Loss Part #2 21 minLecture8.5
-
Profit and Loss Part #3 15 minLecture8.6
-
Profit and Loss [ Notes ]Lecture8.7
-
📌 Practice Problems [Quiz] – Profit and LossLecture8.8
-
-
[ Phase 1 Quantitative ] Time, Speed and Distance 4
-
Time, Speed & Distance – 1 18 minLecture9.1
-
Time, Speed & Distance – 2 23 minLecture9.2
-
Time, Speed & Distance – 3 28 minLecture9.3
-
Time, Speed and Distance Practice Problems 24 minLecture9.4
-
-
[ Phase 1 Quantitative ] Simple and Compound Interest 8
-
Simple Interest Part #1 20 minLecture10.1
-
Simple Interest Part #2 19 minLecture10.2
-
Compound Interest Part #1 25 minLecture10.3
-
Compound Interest Part #2 23 minLecture10.4
-
Simple Interest and Compound Interest 08 minLecture10.5
-
Simple and Compound Interest [ Notes]Lecture10.6
-
📌 Practice Problems [Quiz] – Simple and Compound InterestLecture10.7
-
Simple and Compound Interest [Handmade Notes]Lecture10.8
-
-
[ Phase 1 Quantitative ] Probability 7
-
Probability – 1 25 minLecture11.1
-
Probability – 2 26 minLecture11.2
-
Probability – 3 28 minLecture11.3
-
Probability – 4 28 minLecture11.4
-
Probability [ Formula and Solved Examples ]Lecture11.5
-
📌 Practice Problems [Quiz] – ProbabilityLecture11.6
-
Probability All PPT NotesLecture11.7
-
-
[ Phase 1 Quantitative ] Permutation and Combination 5
-
Permutation and Combination Part #1 25 minLecture12.1
-
Permutation and Combination Part #2 19 minLecture12.2
-
Permutation and Combination Part #3 20 minLecture12.3
-
Permutation and Combination [Handmade Notes]Lecture12.4
-
📌 Practice Problems [Quiz] – Permutation and CombinationLecture12.5
-
-
[ Phase 1 Quantitative ] Time and Work 10
-
Time and Work – 1 26 minLecture13.1
-
Time and Work – 2 26 minLecture13.2
-
Time and Work – 3 27 minLecture13.3
-
Time and Work – 4 23 minLecture13.4
-
Time and Work Part #1 26 minLecture13.5
-
Time and Work Part #2 26 minLecture13.6
-
Time and Work Part #3 27 minLecture13.7
-
Time and Work Part #4 22 minLecture13.8
-
Time and Work [Handmade Notes]Lecture13.9
-
📌 Practice Problems [Quiz] – Time and WorkLecture13.10
-
-
[ Phase 1 Quantitative ] Number Series 8
-
Number Series Part #1 09 minLecture14.1
-
Number Series Part #2 08 minLecture14.2
-
Number Series Part #3 08 minLecture14.3
-
Number Series Part #4 07 minLecture14.4
-
Number Series Practice Questions – 1 17 minLecture14.5
-
Number Series Practice Questions – 2 19 minLecture14.6
-
Number Series [ Notes ]Lecture14.7
-
📌 Practice Problems [Quiz] – Problems on Number SeriesLecture14.8
-
-
[ Phase 1 Quantitative ] Data Interpretation 9
-
Data Interpretation – 1 10 minLecture15.1
-
Data Interpretation – 2 07 minLecture15.2
-
Data Interpretation – 3 10 minLecture15.3
-
Data Interpretation – 4 09 minLecture15.4
-
Data Interpretation – 5 08 minLecture15.5
-
Data Interpretation – 6 08 minLecture15.6
-
Data Interpretation – 7 09 minLecture15.7
-
Data Interpretation – 8 12 minLecture15.8
-
Data Interpretation [Notes]Lecture15.9
-
-
[ Phase 1 Quantitative ] Number System 15
-
Number System – 1 [ New Video ] 25 minLecture16.1
-
Number System – 2 [ New Video ] 21 minLecture16.2
-
Number System – 3 [ New Video ] 19 minLecture16.3
-
Number System – 4 [ New Video ] 25 minLecture16.4
-
Number System – 1 13 minLecture16.5
-
Number System – 2 12 minLecture16.6
-
Number System – 3 07 minLecture16.7
-
Number System – 4 10 minLecture16.8
-
Number System – 5 10 minLecture16.9
-
Number System – 6 11 minLecture16.10
-
Number System – 7 07 minLecture16.11
-
Number System – 8 07 minLecture16.12
-
Number System – 9 09 minLecture16.13
-
Number System – 10 09 minLecture16.14
-
Number System, LCM & HCF Practice ProblemLecture16.15
-
-
[ Phase 1 Quantitative ] Simplifications 2
-
Simplification – 1 11 minLecture17.1
-
Simplification – 2 11 minLecture17.2
-
-
[ Phase 1 Quantitative ] Data Sufficiency 4
-
Data Sufficiency 09 minLecture18.1
-
Data Sufficiency [ Formulas + Notes ]Lecture18.2
-
📌 Data Sufficiency [Quiz] – Problems on data sufficiencyLecture18.3
-
Data Sufficiency [Notes]Lecture18.4
-
-
[ Phase 1 - English ] Reading Comprehension 6
-
Reading Comprehension 13 minLecture19.1
-
Reading Comprehension -1 24 minLecture19.2
-
Reading Comprehension -2 19 minLecture19.3
-
Reading Comprehension Notes 1Lecture19.4
-
Reading Comprehension Notes 2Lecture19.5
-
Reading Comprehension Practice Problem NotesLecture19.6
-
-
[ Phase 1 - English ] Sentence Rearrangement 3
-
Rearrangements – 1 21 minLecture20.1
-
Rearrangements – 2 21 minLecture20.2
-
Sentence Rearrangement NotesLecture20.3
-
-
[ Phase 1 - English ] Subject Verb and Agreement 2
-
Subject Verb and Agreement 22 minLecture21.1
-
Subject Verb Agreement NotesLecture21.2
-
-
[ Phase 1 - English ] Verbal Ability Extra 10
-
Introduction to Verbal Ability + Tenses Part #1 12 minLecture22.1
-
Tenses Part #2 11 minLecture22.2
-
Tenses NotesLecture22.3
-
Error Detection and Correction + Sentence Completion #1 14 minLecture22.4
-
Tenses Practice ProblemsLecture22.5
-
Sentence Completion #2 13 minLecture22.6
-
Spotting Erorrs [ Notes + Solved Examples + Practice Problem ]Lecture22.7
-
Sentence Completion [ Notes + Solved Examples + Practice Problem ]Lecture22.8
-
Assumption in Verbal Reasoning 14 minLecture22.9
-
Deduction Reasoning 26 minLecture22.10
-
-
[ Phase 1 - English ] Sentence Correction 3
-
Sentence Corrections – 1 23 minLecture23.1
-
Sentence Corrections – 2 22 minLecture23.2
-
Sentence Correction NotesLecture23.3
-
-
[ Phase 1 - English ] Fill In The Blanks 8
-
Conjunction 10 minLecture24.1
-
Prepositions 11 minLecture24.2
-
Articles 15 minLecture24.3
-
Tenses 21 minLecture24.4
-
Conjunction NotesLecture24.5
-
Prepositions NotesLecture24.6
-
Articles NotesLecture24.7
-
Tenses NotesLecture24.8
-
-
[ Phase 1 - English ] Error Identification 2
-
Error Identification 13 minLecture25.1
-
Error Identification NotesLecture25.2
-
-
[ Phase 1 - English ] Paragraph 2
-
Paragraph FormationLecture26.1
-
Paragraph 22 minLecture26.2
-
-
[ Phase 1 - English ] Sentence Completion 2
-
Sentence Completion 18 minLecture27.1
-
Sentence Completion NotesLecture27.2
-
-
[ Phase 1 - English ] Cloze Test 2
-
Cloze Test 1 23 minLecture28.1
-
Cloze Test 2 22 minLecture28.2
-
-
[ Phase 1 Reasoning ] Blood Relations 8
-
Blood Relations Part #1 12 minLecture29.1
-
Blood Relations Part #2 10 minLecture29.2
-
Blood Relations Part #3 10 minLecture29.3
-
Blood Relations Part #4 09 minLecture29.4
-
Blood Relations Part #5 11 minLecture29.5
-
Blood Relation Practice Questions 23 minLecture29.6
-
Blood relation [Notes]Lecture29.7
-
Blood Relation [Test]Lecture29.8
-
-
[ Phase 1 Reasoning ] Coding Decoding 7
-
Coding-Decoding – 1 07 minLecture30.1
-
Coding-Decoding – 2 08 minLecture30.2
-
Coding – Decoding – 3 08 minLecture30.3
-
Coding Decoding – 4 06 minLecture30.4
-
Coding – Decoding – 5 10 minLecture30.5
-
📌 Coding Decoding [Quiz] – Problems on coding decodingLecture30.6
-
Coding Decoding[Notes]Lecture30.7
-
-
[ Phase 1 Reasoning ] Data Sufficiency 3
-
Data Sufficiency 09 minLecture31.1
-
Data Sufficiency [ Formulas + Notes ]Lecture31.2
-
📌 Data Sufficiency [Quiz] – Problems on data sufficiencyLecture31.3
-
-
[ Phase 1 Reasoning ] Directions 9
-
Direction Part 1 07 minLecture32.1
-
Direction Part 2 08 minLecture32.2
-
Direction Part 3 09 minLecture32.3
-
Direction Part 4 04 minLecture32.4
-
Direction Part 5 07 minLecture32.5
-
Direction Part 6 06 minLecture32.6
-
Direction Practice Questions 21 minLecture32.7
-
📌 Direction [Quiz] – Problems on DirectionLecture32.8
-
Directions [Notes]Lecture32.9
-
-
[ Phase 1 Reasoning ] Seating Arrangement 8
-
Seating Arrangement Part 1 08 minLecture33.1
-
Seating Arrangement Part 2 12 minLecture33.2
-
Seating Arrangement Part 3 11 minLecture33.3
-
Seating Arrangement Part 4 06 minLecture33.4
-
Seating Arrangement Part 5 07 minLecture33.5
-
Seating Arrangement Part 6 06 minLecture33.6
-
📌 Seating Arrangement [Quiz] – Problems on seatingLecture33.7
-
Seating Arrangement[Notes]Lecture33.8
-
-
[ Phase 1 Reasoning ] Syllogism 6
-
Syllogism Part 1 08 minLecture34.1
-
Syllogism Part 2 06 minLecture34.2
-
Syllogism Part 3 07 minLecture34.3
-
Syllogism Part 4 06 minLecture34.4
-
📌 Syllogism [Quiz] – Problems on syllogismLecture34.5
-
Syllogism Part [Notes]Lecture34.6
-
-
[ Phase 1 Reasoning ] Puzzle 4
-
[ Phase 1 Reasoning ] Verbal Analogy 3
-
Analogy – 1 23 minLecture36.1
-
Analogy – 2 27 minLecture36.2
-
Analogy – 3 29 minLecture36.3
-
-
[ Phase 1 Reasoning ] Inequality 1
-
Inequalities 27 minLecture37.1
-
-
[ Phase 1 - IT Specialized ] Concepts of Programming 3
-
Concepts of Programming NotesLecture38.1
-
Concepts of Programming Practice Problem 1Lecture38.2
-
Concepts of Programming Practice Problem 2Lecture38.3
-
-
[ Phase 1 - IT Specialized ] Computer Fundamentals 15
-
1. Introduction 10 minLecture39.1
-
2. Computer Memory and its types 14 minLecture39.2
-
3. Motherboard and its component 08 minLecture39.3
-
4. Ports, Cables and Graphic Card 09 minLecture39.4
-
5. Storage Devices 07 minLecture39.5
-
6. Number System 11 minLecture39.6
-
7. Machine Language 06 minLecture39.7
-
8. Operating Systems 10 minLecture39.8
-
9. AR and VR 07 minLecture39.9
-
10. Computer Virus 08 minLecture39.10
-
Computer Fundamental [Notes]Lecture39.11
-
Computer Fundamental Practice ProblemLecture39.12
-
Concepts of Programming NotesLecture39.13
-
Concepts of Programming Practice Problem 1Lecture39.14
-
Concepts of Programming Practice Problem 2Lecture39.15
-
-
[ Phase 1 - IT Specialized ] OOP's Concept 4
-
Classes & Objects 19 minLecture40.1
-
Encapsulation 11 minLecture40.2
-
Abstraction 12 minLecture40.3
-
Inheritance 12 minLecture40.4
-
-
[ Phase 1 - IT Specialized ] Database + SQL 49
-
Introduction to DBMS Basic Concept [01 Introduction Database Concepts] 07 minLecture41.1
-
Advantages and Disadvantage of DBMS [01 Introduction Database Concepts] 08 minLecture41.2
-
Architecture of DBMS [01 Introduction Database Concepts] 07 minLecture41.3
-
Database Administrator Manager Storage Manager [01 Introduction Database Concepts] 06 minLecture41.4
-
Data Independence [01 Introduction Database Concepts] 07 minLecture41.5
-
Entity Relationship Modelling with solved example [02 Entity–Relationship Data Model] 09 minLecture41.6
-
Extended Entity Relationship Model with solved example [02 Entity–Relationship Data Model] 07 minLecture41.7
-
Data Modelling [03 Relational Model and relational Algebra] 08 minLecture41.8
-
Inference Rules [03 Relational Model and relational Algebra] 07 minLecture41.9
-
Keys [03 Relational Model and relational Algebra] 09 minLecture41.10
-
E-R To Relational Schema #1 [03 Relational Model and relational Algebra] 20 minLecture41.11
-
E-R To Relational Schema #2 [03 Relational Model and relational Algebra] 25 minLecture41.12
-
Introduction to SQL [04 Structured Query Language (SQL) ] 07 minLecture41.13
-
Data definition language [04 Structured Query Language (SQL) ] 10 minLecture41.14
-
DML ( data manipulation language ) [04 Structured Query Language (SQL) ] 07 minLecture41.15
-
DRL ( Data Retrieval Language) [04 Structured Query Language (SQL) ] 07 minLecture41.16
-
Aggregate Function in SQL [04 Structured Query Language (SQL) ] 09 minLecture41.17
-
Types Of Joins & Inner Join [04 Structured Query Language (SQL) ] 15 minLecture41.18
-
Left, Right & Full Join [04 Structured Query Language (SQL) ] 05 minLecture41.19
-
SQL Queries | Solved Example – 1 [04 Structured Query Language (SQL) ] 18 minLecture41.20
-
SQL Queries | Solved Example – 2 [04 Structured Query Language (SQL) ] 17 minLecture41.21
-
SQL Queries | Solved Example – 3 [04 Structured Query Language (SQL) ] 12 minLecture41.22
-
SQL Queries | Solved Example – 4 [04 Structured Query Language (SQL) ] 15 minLecture41.23
-
SQL Queries | Solved Example – 5 [04 Structured Query Language (SQL) ] 09 minLecture41.24
-
PL SQL | part 1 | [04 Structured Query Language (SQL) ] 08 minLecture41.25
-
PL SQL | part 2 | [04 Structured Query Language (SQL) ] 08 minLecture41.26
-
Query Processing And Query Optimisation [Part 1] [04 Structured Query Language (SQL) ] 11 minLecture41.27
-
Query Processing And Query Optimisation [Part 2] [04 Structured Query Language (SQL) ] 09 minLecture41.28
-
Query Processing And Query Optimisation [Part 3] [04 Structured Query Language (SQL) ] 06 minLecture41.29
-
Query Processing And Query Optimisation [Part4] [04 Structured Query Language (SQL) ] 03 minLecture41.30
-
Integrity Constraints [04 Structured Query Language (SQL) ] 07 minLecture41.31
-
Trigger [04 Structured Query Language (SQL) ] 08 minLecture41.32
-
Normalization and first normal form 1NF [05 – Relational-Database Design] 10 minLecture41.33
-
Second Normal Form 2NF example [05 – Relational-Database Design] 09 minLecture41.34
-
Third Normal Form 3NF with example [05 – Relational-Database Design] 09 minLecture41.35
-
BCNF | Boyce Cod Normal Form | with example [05 – Relational-Database Design] 10 minLecture41.36
-
Canonical Cover [05 – Relational-Database Design] 06 minLecture41.37
-
Decomposition And Dependency Preservation [05 – Relational-Database Design] 08 minLecture41.38
-
Concurrency Control [06 Transactions Management and Concurrence] 09 minLecture41.39
-
Concurrency Control – Lock Based Protocol in DBMS Transaction [06 Transactions Management and Concurrence] 08 minLecture41.40
-
Timestamp Based Protocol [06 Transactions Management and Concurrence] 11 minLecture41.41
-
Deadlock Full concept in DBMS transaction management [06 Transactions Management and Concurrence] 12 minLecture41.42
-
Shadow Paging in Database Recovery [06 Transactions Management and Concurrence] 12 minLecture41.43
-
Log Based Database Recovery [06 Transactions Management and Concurrence] 08 minLecture41.44
-
Shadow Copy Technique in Database recovery [06 Transactions Management and Concurrence] 05 minLecture41.45
-
Transaction State and Acid Properties [06 Transactions Management and Concurrence] 05 minLecture41.46
-
Transaction Schedule [06 Transactions Management and Concurrence] 07 minLecture41.47
-
View Serializability [06 Transactions Management and Concurrence] 05 minLecture41.48
-
Conflict Serializability [06 Transactions Management and Concurrence] 09 minLecture41.49
-
-
[ Phase 1 - IT Specialized ] Data Warehousing 15
-
Introduction to Data Warehouse 11 minLecture42.1
-
Meta Data 05 minLecture42.2
-
Data Mart 06 minLecture42.3
-
Data Warehouse Architecture 07 minLecture42.4
-
How to Draw Star , Smowflake and Fack Constelation Basics 10 minLecture42.5
-
Numericals on Star , Snowflake and Fact Constelation [ Part 1 ] 16 minLecture42.6
-
Numericals on Star , Snowflake and Fact Constelation [ Part 2 ] 11 minLecture42.7
-
What is Olap Operations 08 minLecture42.8
-
OLAP VS OLTP 08 minLecture42.9
-
Extract Transform and Load (ETL) 09 minLecture42.10
-
Introduction to Data Mining and Architecture 10 minLecture42.11
-
Data Visualization Part #1 11 minLecture42.12
-
Data Visualization Part #2 11 minLecture42.13
-
Data Preprocessing Part #1 17 minLecture42.14
-
Data Preprocessing Part #2 09 minLecture42.15
-
-
[ Phase 1 - IT Specialized ] Information & Cyber Security 1
-
Information & Cyber Security Concepts NotesLecture43.1
-
-
[ Phase 1 - IT Specialized ] Object Oriented Programming in C++ 27
-
Object Oriented Programming (C++) SampleLecture44.1
-
Object Oriented Programming (C++)Lecture44.2
-
Object Oriented Programming (C++) Practice ProblemLecture44.3
-
Introduction to C++ 11 minLecture44.4
-
Input & Output in C++ 14 minLecture44.5
-
Difference between Structure in C & C++ 14 minLecture44.6
-
Class & Objects C++ 14 minLecture44.7
-
Inspector, Mutators, Facilitators 16 minLecture44.8
-
Contructor & Destructor 15 minLecture44.9
-
Default Arguments & Inline Function 16 minLecture44.10
-
Array of Objects 16 minLecture44.11
-
Dynamic Memory Allocation 15 minLecture44.12
-
Static Member and function 15 minLecture44.13
-
Exception handling 18 minLecture44.14
-
Composition 22 minLecture44.15
-
Friend Class and function 13 minLecture44.16
-
Function Overloading 15 minLecture44.17
-
Operator Overloading 13 minLecture44.18
-
Copy Constructor 05 minLecture44.19
-
Inheritance 15 minLecture44.20
-
Pure Virtual Function 13 minLecture44.21
-
Types of Inheritance 26 minLecture44.22
-
Virtual Function 12 minLecture44.23
-
Template 15 minLecture44.24
-
RTTI 11 minLecture44.25
-
Casting Operators 19 minLecture44.26
-
Dynamic Array of Object 13 minLecture44.27
-
-
[ Phase 1 - IT Specialized ] C Programming 32
-
C Programming Part #1 10 minLecture45.1
-
C Programming Part #2 12 minLecture45.2
-
C Programming Part #3 16 minLecture45.3
-
C Programming Part #4 21 minLecture45.4
-
C Programming Part #5 23 minLecture45.5
-
C Programming Part #6 15 minLecture45.6
-
C Programming Part #7 15 minLecture45.7
-
C Programming Part #8 14 minLecture45.8
-
C Programming Part #9 15 minLecture45.9
-
C Programming Part #10 16 minLecture45.10
-
C Programming Part #11 12 minLecture45.11
-
C Programming Part #12 12 minLecture45.12
-
C Programming Part #15 15 minLecture45.13
-
C Programming Part #14 13 minLecture45.14
-
C Programming Part #13 19 minLecture45.15
-
C Programming Part #16 12 minLecture45.16
-
C Programming Part #17 13 minLecture45.17
-
C Programming Part #18 11 minLecture45.18
-
C Programming Part #19 16 minLecture45.19
-
C Programming Part #20 13 minLecture45.20
-
C Programming Part #21 23 minLecture45.21
-
C Programming Part #22 15 minLecture45.22
-
C Programming Part #23 14 minLecture45.23
-
C Programming Part #24 17 minLecture45.24
-
C Programming Part #25 11 minLecture45.25
-
C Programming Part #26 13 minLecture45.26
-
C Programming Part #27 14 minLecture45.27
-
C Programming Part #28 10 minLecture45.28
-
C Programming Part #29 10 minLecture45.29
-
C Programming Part #30 11 minLecture45.30
-
C Programming [Notes]Lecture45.31
-
C Programming Practice ProblemLecture45.32
-
-
[ Phase 1 - IT Specialized ] C Snippet Problems with Solutions Video 10
-
Code Snippet 1 – 5 21 minLecture46.1
-
Code Snippet 6 -10 20 minLecture46.2
-
Code Snippet 11 – 15 19 minLecture46.3
-
Code Snippet 16 – 20 15 minLecture46.4
-
Code Snippet 21 – 25 23 minLecture46.5
-
Code Snippet 26 – 30 18 minLecture46.6
-
Code Snippet 31 – 35 25 minLecture46.7
-
Code Snippet 36 – 40 25 minLecture46.8
-
Code Snippet 41 – 45 13 minLecture46.9
-
Code Snippet 46 – 50 18 minLecture46.10
-
-
[ Phase 1 - IT Specialized ] Shell Programming 7
-
1. Shell Script Basics 28 minLecture47.1
-
2. Shell Variables 24 minLecture47.2
-
3 – Shell Arguments 27 minLecture47.3
-
4 – If Statements 41 minLecture47.4
-
5 – Shell Loops 36 minLecture47.5
-
6 – Functions in Shell 26 minLecture47.6
-
7 – Basics UNIX Commands 24 minLecture47.7
-
-
[ Phase 1 - IT Specialized ] Algorithm for Problem Solving ( Data Structures ) 59
-
Hashing Collision [ Searching & Sorting ] 12 minLecture48.1
-
Hashing concept [ Searching & Sorting ] 06 minLecture48.2
-
Linear Probing – #1 [ Searching & Sorting ] 13 minLecture48.3
-
Linear Probing – #2 [ Searching & Sorting ] 12 minLecture48.4
-
Linear Probing With Collisions – Solved [ Searching & Sorting ] 10 minLecture48.5
-
Linear + Quadratic Probing – Solved Example [ Searching & Sorting ] 15 minLecture48.6
-
Searching & Sorting Introduction [ Searching & Sorting ] 12 minLecture48.7
-
Selection Sorting – #1 [ Searching & Sorting ] 12 minLecture48.8
-
Selection Sorting – #2 [ Searching & Sorting ] 12 minLecture48.9
-
Insertion Sort – #1 [ Searching & Sorting ] 12 minLecture48.10
-
Insertion Sort – #2 [ Searching & Sorting ] 12 minLecture48.11
-
Merge Sort – #1 [ Searching & Sorting ] 12 minLecture48.12
-
Merge Sort – #2 [ Searching & Sorting ] 12 minLecture48.13
-
Merge Sort – #3 [ Searching & Sorting ] 10 minLecture48.14
-
Quick Sort – #1 [ Searching & Sorting ] 10 minLecture48.15
-
Quick Sort – #2 [ Searching & Sorting ] 09 minLecture48.16
-
Radix Sort – #1 [ Searching & Sorting ] 10 minLecture48.17
-
Radix Sort – #2 [ Searching & Sorting ] 10 minLecture48.18
-
Introduction to Tree Data Structure & Binary Tree [ Trees ] 06 minLecture48.19
-
Binary Tree Implementation Part 1 – Insertion & Traversing [ Trees ] 14 minLecture48.20
-
Binary Tree Implementation Part 2 – Traversing & Deletion [ Trees ] 12 minLecture48.21
-
Binary tree Traversal [ Trees ] 14 minLecture48.22
-
Tree traversal methods: Pre, post and in-order traversal [ Trees ] 14 minLecture48.23
-
(Binary Search Tree) – Traverse the Tree in In-Order, Pre-Order and Post-Order [ Trees ] 11 minLecture48.24
-
Height Balaced Binary Search Tree [ Trees ] 12 minLecture48.25
-
AVL Tree [ Trees ] 16 minLecture48.26
-
AVL Tree Solved Example – #1 [ Trees ] 17 minLecture48.27
-
AVL Tree Solved Example – #2 [ Trees ] 17 minLecture48.28
-
B-Tree Introduction [ Trees ] 13 minLecture48.29
-
B-Tree Solved Example – #1 [ Trees ] 14 minLecture48.30
-
B-Tree Solved Example – #2 [ Trees ] 12 minLecture48.31
-
Huffman Coding [ Trees ] 07 minLecture48.32
-
Graphs Introduction [ Graphs ] 13 minLecture48.33
-
BFS & DFS – #1 [ Graphs ] 14 minLecture48.34
-
BFS & DFS – #2 [ Graphs ] 12 minLecture48.35
-
Topological Sorting [ Graphs ] 11 minLecture48.36
-
Topological Sorting – Solved Example [ Graphs ] 09 minLecture48.37
-
Prim’s & Kruskal’s #1 [ Applications of Data Structures ] 19 minLecture48.38
-
Prim’s & Kruskal’s #2 [ Applications of Data Structures ] 10 minLecture48.39
-
Divide & Conquer With Example [ Divide and Conquer ] 06 minLecture48.40
-
Binary Search [ Divide and Conquer ] 10 minLecture48.41
-
Max Min Problem with Solved Examples [ Divide and Conquer ] 09 minLecture48.42
-
Merge Sort Algorithm with Solved Examples [ Divide and Conquer ] 21 minLecture48.43
-
Multiplying Long Integers Using Divide and Conquer Technique [ Divide and Conquer ] 09 minLecture48.44
-
Quick Sort Algorithm Web [ Divide and Conquer ] 18 minLecture48.45
-
Quick Sort Algorithm Explained with Example [ Divide and Conquer ] 15 minLecture48.46
-
Prim’s Algorithm for Minimum Spanning Tree [ Greedy Method ] 19 minLecture48.47
-
Flow Shop Scheduling Explained [ Greedy Method ] 15 minLecture48.48
-
Dijkstra’s Algorithm with Solved Example [ Greedy Method ] 14 minLecture48.49
-
Kruskal algorithm for Minimum Spanning Tree With Example [ Greedy Method ] 13 minLecture48.50
-
Dynamic Programming [ Dynamic Programming ] 10 minLecture48.51
-
DP Approaches 1 [ Dynamic Programming ] 11 minLecture48.52
-
DP Approaches 2 [ Dynamic Programming ] 08 minLecture48.53
-
Multistage Graphs [ Dynamic Programming ] 20 minLecture48.54
-
Multistage Graphs Problem with Solved Example [ Dynamic Programming ] 21 minLecture48.55
-
Knapsack Problem part 1 [ Dynamic Programming ] 10 minLecture48.56
-
Knapsack Problem part 2 [ Dynamic Programming ] 10 minLecture48.57
-
Knapsack Problem part 3 [ Dynamic Programming ] 05 minLecture48.58
-
Travelling Salesperson Problem with Solved Example [ Dynamic Programming ] 15 minLecture48.59
-
-
[ Phase 1 - IT Specialized ] Networking Concepts 47
-
Introduction to Computer Networks [01 Introduction to Networks] 12 minLecture49.1
-
Network Topologies [01 Introduction to Networks] 12 minLecture49.2
-
Network Connecting Devices [01 Introduction to Networks] 11 minLecture49.3
-
Connection-Oriented vs Connection-Less Communication [01 Introduction to Networks] 09 minLecture49.4
-
OSI Reference Model [01 Introduction to Networks] 07 minLecture49.5
-
TCP-IP Reference Model [01 Introduction to Networks] 07 minLecture49.6
-
OSI vs TCP-IP Model Comparision [01 Introduction to Networks] 08 minLecture49.7
-
Network Classification LAN, MAN, WAN [01 Introduction to Networks] 08 minLecture49.8
-
Virtual Lan’s [01 Introduction to Networks] 08 minLecture49.9
-
CoAxial Cable [02 Physical Layer] 07 minLecture49.10
-
Twisted-Pair Cables [02 Physical Layer] 08 minLecture49.11
-
Transmission Media: Guided and Unguided [Difference] [02 Physical Layer] 09 minLecture49.12
-
Fiber Optics Part [01] [02 Physical Layer] 11 minLecture49.13
-
Fiber Optics Part [02] [02 Physical Layer] 11 minLecture49.14
-
Framing and it’s Methods [03 Data Link Layer] 08 minLecture49.15
-
Error Detection and its Methods [03 Data Link Layer] 08 minLecture49.16
-
Hamming Code [03 Data Link Layer] 12 minLecture49.17
-
Cyclic Redundancy Check Part [01] [03 Data Link Layer] 09 minLecture49.18
-
Cyclic Redundancy Check Part [02] [03 Data Link Layer] 05 minLecture49.19
-
Parity Checking and Checksum Error Detection [03 Data Link Layer] 09 minLecture49.20
-
Flow Control: Stop and Wait and Sliding Window Protocol [03 Data Link Layer] 08 minLecture49.21
-
Go Back- N ARQ System [03 Data Link Layer] 08 minLecture49.22
-
SDLC protocol [03 Data Link Layer] 05 minLecture49.23
-
HDLC protocol [03 Data Link Layer] 12 minLecture49.24
-
Carrier Sense Multiple Access-Collision Detection Procedure (CSMA-CD) [03 Data Link Layer] 07 minLecture49.25
-
IP address vs MAC address [04 Network Layer] 09 minLecture49.26
-
IPv4 Header Format [04 Network Layer] 12 minLecture49.27
-
IPv4 vs IPv6 [04 Network Layer] 10 minLecture49.28
-
Routing Algorithms Part 01 [04 Network Layer] 12 minLecture49.29
-
Routing Algorithms Part 02 [04 Network Layer] 10 minLecture49.30
-
ARP & RARP [04 Network Layer] 07 minLecture49.31
-
Leaky Bucket Algorithm [04 Network Layer] 05 minLecture49.32
-
Token Bucket Algorithm [04 Network Layer] 06 minLecture49.33
-
Berkeley Sockets [05 Transport Layer] 07 minLecture49.34
-
User Datagram Protocol [05 Transport Layer] 08 minLecture49.35
-
Domain Name Server – DNS [06 Application Layer] 06 minLecture49.36
-
Simple Mail Transfer Protocol – SMTP [06 Application Layer] 05 minLecture49.37
-
Hypertext Transfer Protocol – HTTP [06 Application Layer] 08 minLecture49.38
-
File Transfer Protocol – FTP [06 Application Layer] 05 minLecture49.39
-
Network Security Management [07 Network Security] 06 minLecture49.40
-
SNMP v3 Architecture [07 Network Security] 09 minLecture49.41
-
Network Access Control With Use Cases [07 Network Security] 09 minLecture49.42
-
IDS and its Types [08 System Security] 12 minLecture49.43
-
Firewall & types [08 System Security] 20 minLecture49.44
-
Firewall Design Principles [08 System Security] 17 minLecture49.45
-
Data Communication and NetworkingLecture49.46
-
Data Communication and Networking NotesLecture49.47
-
-
[ Phase 1 - IT Specialized ] Data Analytics Language ( R Language ) 12
-
Introduction – R Programming – #1 12 minLecture50.1
-
Introduction – R Programming – #2 16 minLecture50.2
-
Vectors in R Programming 17 minLecture50.3
-
Objects in R Programming 18 minLecture50.4
-
Interacting With Users 12 minLecture50.5
-
Script in R 13 minLecture50.6
-
Plot in R 17 minLecture50.7
-
Exploring Dataset in R 25 minLecture50.8
-
Dirty Data Detection In Exploration Phase 21 minLecture50.9
-
Data import and export in R 32 minLecture50.10
-
Visualization in R 16 minLecture50.11
-
Function in R 12 minLecture50.12
-
-
[ Phase 1 - IT Specialized ] Data Analytics Language ( Python Language) 27
-
[Module 1] Introduction and Installation 05 minLecture51.1
-
[Module 02 : Basic I/O, Operators & Using] Numbers and Strings 07 minLecture51.2
-
[Module 02 : Basic I/O, Operators & Using] Lists and Dictionaries 07 minLecture51.3
-
[Module 02 : Basic I/O, Operators & Using] Assignment Operators 06 minLecture51.4
-
[Module 02 : Basic I/O, Operators & Using] Development Environment 05 minLecture51.5
-
[Module 02 : Basic I/O, Operators & Using] Visual Studio Code: [VS_Code] 08 minLecture51.6
-
[Module 03: Conditional Statements & Loop] Conditional Statements 05 minLecture51.7
-
[Module 03: Conditional Statements & Loop] User Input 05 minLecture51.8
-
[Module 03: Conditional Statements & Loop] WHILE Loop 04 minLecture51.9
-
[Module 03: Conditional Statements & Loop] FOR Loop 03 minLecture51.10
-
[Module 03: Conditional Statements & Loop] FOR Loop: (Dictionary Enumeration) 05 minLecture51.11
-
[Module 04: Functions, Classes & Exception] Functions 07 minLecture51.12
-
[Module 04: Functions, Classes & Exception] Class and Objects 04 minLecture51.13
-
[Module 04: Functions, Classes & Exception] Constructors 03 minLecture51.14
-
[Module 04: Functions, Classes & Exception] Exception handling 07 minLecture51.15
-
[Module 05: Module & Experincin] Modules 07 minLecture51.16
-
[Module 05: Module & Experincin] Statistics Module 04 minLecture51.17
-
[Module 05: Module & Experincin] CSV Module 08 minLecture51.18
-
[Module 05: Module & Experincin] PIP 05 minLecture51.19
-
[Module 05: Module & Experincin] Jupyter Note Book 07 minLecture51.20
-
[Module 06: SQLite, Tkinter in Python] SQLite 11 minLecture51.21
-
[Module 06: SQLite, Tkinter in Python] Tkinter 11 minLecture51.22
-
[Module 06: SQLite, Tkinter in Python] Making [.exe] in Python 09 minLecture51.23
-
[Bonus Hands-On Projects+ Source Code] Rock Paper Scissor Python Game 12 minLecture51.24
-
[Bonus Hands-On Projects+ Source Code] Message Encode Decode in Python Project 15 minLecture51.25
-
[Bonus Hands-On Projects+ Source Code] Calculator in Python 25 minLecture51.26
-
[Bonus Hands-On Projects+ Source Code] Source Code of all 3 Projects [Notes]Lecture51.27
-
-
IT : 500+ Practice Questions [ Subjectwise ] 4
-
OOPs – PRACTICE QUESTIONSLecture52.1
-
DBMS Practice QuestionsLecture52.2
-
Networking – Practice QuestionsLecture52.3
-
Data Structure & Algorithm – Practice QuestionLecture52.4
-
-
[ Previous Year Question ] SEBI Grade A IT 3
-
[ PYQ ] 2024 Phase 1Lecture53.1
-
[ PYQ ] 2022 Phase 1Lecture53.2
-
[ PYQ ] 2020 Phase 1Lecture53.3
-

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)

