CBSE Class 12 Computer Science: Object Oriented Programming in C++ NCERT Solutions

Data hiding is a programming technique that restricts the visibility of an object's data members from the outside world. This is typically achieved in C++ by declaring data members as private within a class. The primary goal is to protect the data from unauthorized or accidental modification, ensuring data integrity.

Data abstraction, on the other hand, is the process of exposing only the essential features of an object to the user while hiding the complex background implementation details. In C++, abstraction is achieved by defining a public interface (using public member functions) that users can interact with, without needing to know how these functions work internally or how the data is stored.

In essence, data hiding is a mechanism that helps in achieving data abstraction. While data hiding focuses on restricting access to data, data abstraction focuses on simplifying the user's interaction by providing a high-level view.

Abstraction refers to the concept of representing essential features of an object or system without including the background details or implementation specifics. It's about showing what an object does, not how it does it.

Encapsulation is the mechanism of bundling data (attributes) and the methods (functions) that operate on that data into a single unit, known as a class. This bundling protects the data from direct external access and ensures that data manipulation occurs only through the defined methods.

In C++, both abstraction and encapsulation are primarily implemented using classes.

Implementation in C++:

• Encapsulation: A class definition itself serves as the mechanism for encapsulation. Data members (variables) and member functions (methods) are declared within the class scope, effectively wrapping them together. Access specifiers like private and public control the visibility and accessibility of these members.
• Abstraction: Abstraction is achieved by using access specifiers. Data members are typically declared as private to hide them (data hiding), while essential functionalities are provided through public member functions. These public functions form the interface through which the outside world interacts with the object, abstracting away the internal complexity.

Example:

Consider a class representing a Rectangle:

class Rectangle {

int length, breadth;

public:

void Input() {

// Function to input dimensions

std::cin >> length >> breadth; } void Output() {

// Function to display dimensions

std::cout

In this example:

• Encapsulation: The data members length and breadth are bundled together with the member functions Input(), Output(), and CalculateArea() within the Rectangle class.
• Abstraction: Only the Input() and Output() functions are declared as public, providing a simple interface to the user. The user can input dimensions and display them without knowing how they are stored internally or how the area is calculated. The CalculateArea() function, though part of the class, might also be considered part of the abstraction if its internal logic is complex and not directly exposed. The actual storage of length and breadth is hidden (data hiding), contributing to abstraction.

Data hiding is a fundamental principle of Object-Oriented Programming (OOP) that involves restricting direct access to an object's internal data members. This is achieved by declaring these data members as private within a class. The purpose is to protect the data from being accidentally or intentionally modified by code outside the class, thereby maintaining the integrity and consistency of the object's state.

Only the member functions of the class itself can access and manipulate the private data members. This controlled access ensures that data modifications happen in a predefined and safe manner, often through public methods (like setters) that can include validation logic.

General Form in C++:

class ClassName {

private:

// Private data members (hidden from outside)

DataType dataMember;

public:

// Public member functions (interface to access/modify data)

void get() {

// Function to get input for dataMember

std::cout > dataMember; } void display() {

// Function to display dataMember

std::cout

Example Explanation:

In the Square class example (adapted from the source):

• The data member Num is declared under the private section. This means that Num cannot be directly accessed or modified from outside the Square class, for instance, from the main function.
• The member functions Get() (to input a number) and potentially another function to display or use Num are declared under the public section.
• Users of the Square class can call the Get() function to set the value of Num, but they cannot directly assign a value to Num. This controlled access is data hiding.

This mechanism prevents scenarios where Num might be assigned an invalid value (e.g., a negative number if it's supposed to represent a count) without any checks, thus protecting the internal state of the object.