Class 12 Computer Science Solution Volume 1 | HS 2nd Year Computer Science Book Solution Assam | Class 12 Computer Science Answer Assamese Medium | C++Concepts | File Handling | Data Structures | Sumita Arora | Textbook XII 11th Edition | HS 2nd Year Computer Science Suggestion and Notes Assam |
-----------------------------------------------------
Class 12 Computer Science with Solution Volume 1
Class XII Computer Science with Question and Answer
Class 12 Computer Science writer Sumita Arora
-----------------------------------------------------
CONTENTS
-----------------------------------------------------
C++ Revision Tour
----------------------------------
1.1 Introduction----------------------------------
----------------------------------
1.2 C+ + Basics
1.2.1 C+ + Character Set
1.2.2 Tokens
----------------------------------
---------------------------------
1.3 Data Handling
1.3.1 C + + Data Types
1.3.2 Variables
1.3.3 Formatting Output
---------------------------------
---------------------------------
1.4 Operators and Expressions
1.4.1 I/O Operators
1.4.2 Arithmetic Operators
1.4.3 Increment/Decrement Operators
1.4.4 Relational Operators
1.4.5 Logical Operators
1.4.6 Conditional Operator
1.4.7 Some Other Operators
1.4.8 Precedence of Operators
1.4.9 Expressions
1.4.10 C + + Shorthand's
---------------------------------
---------------------------------
1.5 Flow of Control
1.5.1 Statements
1.5.2 Selection Statements
1.5.3 Iteration Statements
1.5.4 jump Statements
---------------------------------
---------------------------------
1.6 Console VO Operations
1.6.1 Unformatted Console I/O Functions
1.6.2 Unformatted Stream I/O Functions
---------------------------------
---------------------------------
1.7 Arrays
1.7.1 Single Dimensional Arrays
1.7.2 Two-Dimensional Arrays
1.7.3 Array Initialization
---------------------------------
---------------------------------
1.8 Functions
1.8.1 Function Definition
1.8.2 Default Arguments
1.8.3 Constant Arguments
1.8.4 Call by Value
1.8.5 Call by Reference
1.8.6 Calling Functions with Array
1.8.7 Recursion
1.8.8 Returning from a Function
1.8.9 Scope Rules
---------------------------------
---------------------------------
1.9 Standard Library and Header Files
---------------------------------
---------------------------------
1.10 Structures
1.10.1 Referencing Structure Elements
1.10.2 Nested Structures
1.10.3 Arrays of Structures
1.10.4 Arrays within Structures
1.10.5 Passing Structures to Functions
---------------------------------
-----------------------------------------------------
-----------------------------------------------------
---------------------------------
2.1 Introduction
---------------------------------
---------------------------------
2.2 Various Programming Paradigms
2.2.1 Procedural Programming
2.2.2 Object Based Programming
2.2.3 Object Oriented Programming
---------------------------------
---------------------------------
2.3 OOP Concepts
---------------------------------
---------------------------------
2.4 Basic Concepts of OOP
2.4.1 Data Abstraction
2.4.2 Encapsulation
2.4.3 Modularity
2.4.4 Inheritance
2.4.5 Polymorphism
---------------------------------
---------------------------------
2.5 Implementing OOP Concepts in C ++
2.5.1 Implementing Objects
2.5.2 Implementing Data Hiding , Data Abstraction and
Encapsulation
2.5.3 Implementing Inheritance
2.5.4 Implementation Polymorphism
---------------------------------
---------------------------------
2.6 Advantages and Disadvantages of OOP
---------------------------------
-----------------------------------------------------
-----------------------------------------------------
---------------------------------
3.1 Introduction
---------------------------------
---------------------------------
3.2 Function Overloading
3.2.1 Need for Function Overloading
3.2.2 Declaration and Definition
3.2.3 Restrictions on Overloaded Functions
---------------------------------
---------------------------------
3.3 Calling Overloaded Functions
3.3.1 Steps Involved in Finding the Best Match
3.3.2 Default Arguments versus Overloading
---------------------------------
-----------------------------------------------------
-----------------------------------------------------
---------------------------------
4.1 Introduction
---------------------------------
---------------------------------
4.2 Classes
4.2.1 Need for Classes
4.2.2 Declaration of Classes
4.2.3 Referencing Class Members
4.2.4 Arrays within a Class
4.2.5 Scope of Class and its Members
4.2.6 Types of Class Functions
4.2.7 Nested Classes
---------------------------------
---------------------------------
4.3 Data Hiding and Encapsulation
---------------------------------
---------------------------------
4.4 Functions in a Class
4.4.1 Inline Functions
4.4.2 Constant Member Functions
4.4.3 Nesting of Member Functions
4.4.4 The Scope Resolution Operator
---------------------------------
4.5 Using Objects
4.5.1 Memory Allocation of Objects
4.5.2 Array of Objects
4.5.3 Objects as Function Arguments
4.5.4 Functions Returning Objects
---------------------------------
4.6 Static Class Members
---------------------------------
-----------------------------------------------------
-----------------------------------------------------
---------------------------------
5.1 Introduction
---------------------------------
---------------------------------
5.2 Constructors
5.2.1 Need for Constructors
5.2.2 Declaration and Definition
5.2.3 Default Constructors
5.2.4 Parameterized Constructors
5.2.5 Significance of Default Constructors
5.2.6 Invocation of Constructors
5.2.7 Copy Constructor
5.2.8 Order of Constructor Invocation
5.2.9 Dynamic Initialization of Objects
5.2.10 Constructor Overloading
5.2.11 Special Characteristics of Constructors
---------------------------------
---------------------------------
5.3 Destructors
5.3.1 Need for Destructors
5.3.2 Declaration and Definition
5.3.3 Some Characteristics of Destructors
---------------------------------
-----------------------------------------------------
-----------------------------------------------------
---------------------------------
6.1 Introduction
---------------------------------
---------------------------------
6.2 Need for Inheritance
---------------------------------
---------------------------------
6.3 Different forms of Inheritance
---------------------------------
---------------------------------
6.4 Derived and Base Classes
6.4.1 Single Inheritance
6.4.2 Multiple Inheritance
6.4.3 Visibility Modes
---------------------------------
---------------------------------
6.5 Inheritance and Access Control
6.5.1 Access-Control in Publicly Derived Class
6.5.2 Access Control inn Privately Derived Class
6.5.3 Some Facts about Inheritance
6.5.4 Making a private Member Inheritable
6.5.5 Shadowing/Overriding Base Class Functions in Derived
Class
---------------------------------
---------------------------------
6.6 Multiple Inheritance Revisited
6.6.1 Constructors in Multiple Inheritance
6.6.2 Virtual Base Classes
---------------------------------
---------------------------------
6.7 Multilevel Inheritance
---------------------------------
---------------------------------
6.8 Nesting of Classes
6.8.1 The Relationship between Classes
---------------------------------
-----------------------------------------------------
-----------------------------------------------------
---------------------------------
7.1 Introduction
---------------------------------
---------------------------------
7.2 The fstream.h Header File
---------------------------------
---------------------------------
7.3 Data Files
---------------------------------
---------------------------------
7.4 Opening and Closing Files
7.4.1 Opening Files using Constructors
7.4.2 Opening Files using Open () function
7.4.3 Closing a File
---------------------------------
---------------------------------
7.5 Steps to Process a File in your Program
---------------------------------
---------------------------------
7.6 Changing the Behavior of Streams
---------------------------------
---------------------------------
7.7 Sequential I/O with Files
7.7.1 The get(), getline () and put () Functions
7.7.2 The read() and write () Functions
7.7.3 Reading and Writing Class Objects
---------------------------------
---------------------------------
7.8 Detecting EOF
---------------------------------
---------------------------------
7.9 File Pointers and Random Access
---------------------------------
---------------------------------
7.10 Basic Operations on Binary Files
7.10.1 Searching
7.10.2 Appending Data
7.10.3 Inserting Data in sorted file
7.10.4 Deleting a Record
7.10.5 Modifying Data
---------------------------------
---------------------------------
7.11 Error Handling During File I/O
---------------------------------
-----------------------------------------------------
-----------------------------------------------------
---------------------------------
8.1 Introduction
---------------------------------
---------------------------------
8.2 C++ Memory Map
8.2.1 Dynamic and Static Allocation of Memory
---------------------------------
---------------------------------
8.3 Free Store
---------------------------------
---------------------------------
8.4 Declaration and Initialization of Pointers
8.4.1 Memory Leaks
---------------------------------
---------------------------------
8.5 Dynamic Allocation Operators
8.5.1 Memory Leaks
---------------------------------
---------------------------------
8.6 Pointers and Arrays
8.6.1 Array of Pointers
---------------------------------
---------------------------------
8.7 Pointers and Const
---------------------------------
---------------------------------
8.8 Pointers and functions
8.8.1 Invoking Functions by Passing the References
8.8.2 Invoking Functions by Passing the Pointers
8.8.3 Functions Returning by Reference
8.8.4 Functions Returning Pointers
---------------------------------
8.9 Pointers and Structures
8.9.1 Declaration and Use of Structure Pointers
8.9.2 Self Referencial Structures
8.9.3 Dynamic Structures
---------------------------------
---------------------------------
8.10 Objects as Function Arguments
8.10.1 Passing Objects through Call-by-Value
8.10.2 Passing Objects through Reference
---------------------------------
---------------------------------
8.11 Pointers and Objects
8.11.1 Declaration and use of Object Pointers
8.11.2 The this Pointer
---------------------------------
-----------------------------------------------------
-----------------------------------------------------
---------------------------------
9.1 Introduction
---------------------------------
---------------------------------
9.2 Elementary Data representation
9.2.1 Primitive and Non-Primitive Data Types
---------------------------------
---------------------------------
9.3 Different Data Structures
9.3.1 Arrays
9.3.2 Structure
9.3.3 Stacks
9.3.4 Queues
9.3.5 Linked Lists
9.3.6 Trees
---------------------------------
---------------------------------
9.4 Operations on Data Structures
---------------------------------
---------------------------------
9.5 Arrays
9.5.1 Need for Arrays
9.5.2 Types of Arrays
---------------------------------
---------------------------------
9.6 One-dimensional Arrays
9.6.1 Implementation of One-dimensional Arrays in Memory
---------------------------------
---------------------------------
9.7 Basic Operations on One-dimensional Arrays
9.7.1 Searching
9.7.2 Insertion
9.7.3 Deletion
9.7.4 Traversal
9.7.5 Sorting
9.7.6 Merging
9.7.7 Some Logic Based Problems on 1D Arrays
---------------------------------
---------------------------------
9.8 Two-dimensional Arrays
9.8.1 Implementation of Two-dimensional Array in Memory
9.8.2 Operations Performed in Two-dimensional Arrays
---------------------------------
-----------------------------------------------------
-----------------------------------------------------
---------------------------------
10.1 Introduction
---------------------------------
---------------------------------
10.2 Need for Linked Lists
10.2.1 Memory Allocation (Dynamic vs. Static)
---------------------------------
---------------------------------
10.3 Singly Linked Lists
10.3.1 Representation of Linked List in Memory
10.3.2 Basic Operations on Singly linked Lists
---------------------------------
---------------------------------
10.4 Stack
10.4.1 stack as an Array
10.4.2 Stack as a Linked List (Linked Stack)
10.4.3 Application of Stackes
---------------------------------
---------------------------------
10.5 Queue
10.5.1 Queue as an Array
10.5.2 Linked Queues
---------------------------------
-----------------------------------------------------
-----------------------------------------------------
---------------------------------
Appendix A: C++ Standard Library Header Files
---------------------------------
---------------------------------
Appendix B: Turbo C++ Windows 7
---------------------------------
---------------------------------
Appendix C: Working with Code::Blocks Compiler-Functional Issues
---------------------------------
-----------------------------------------------------
Post ID : DABP006511
