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

Data hiding is a mechanism that restricts direct access to an object's data from outside the class. This is typically achieved by declaring data members as 'private', ensuring they can only be accessed or modified through the class's member functions. This protects the data from accidental or unauthorized changes.

Data abstraction, on the other hand, focuses on providing a simplified, high-level view of an object by exposing only the essential features and functionalities to the outside world. It hides the complex implementation details behind a clean interface, allowing users to interact with the object without needing to understand its internal workings.

Abstraction refers to the concept of representing essential features of an object while hiding the background details and implementation complexities. Encapsulation is the mechanism of bundling data (attributes) and the methods (functions) that operate on that data into a single unit, called a class.

In C++, both abstraction and encapsulation are primarily implemented using classes. A class acts as a blueprint that encapsulates data members and member functions. Abstraction is achieved by controlling the visibility of these members using access specifiers. By declaring data members and certain functions as 'private', they are hidden from the outside world, and only the 'public' member functions serve as the interface, providing an abstract view.

Example:

Consider a class designed to represent a rectangle:

class Rectangle {

int length, breadth;

public:

void Input() {

// Function to get input for length and breadth

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

// Function to display length and breadth

std::cout

In this example:

1. Encapsulation: The data members length and breadth are bundled together with the member functions Input() and Output() within the Rectangle class.

2. Abstraction: Only the Input() and Output() functions are declared as public, making them accessible from outside the class. The actual data members length and breadth are implicitly private (or would be explicitly declared private for stronger data hiding), hiding the internal representation and allowing interaction only through the defined public interface.

Data hiding is a fundamental principle of Object-Oriented Programming (OOP) that involves restricting the direct access to an object's data members from outside the class. This is achieved by declaring the data members as 'private'. By making data private, the class controls how its data is accessed and modified, typically through public member functions (getters and setters), thereby protecting the data's integrity and preventing unintended side effects.

General Form in C++:

class ClassName {

private:

// Private data members (hidden from outside)

datatype data_member1;

datatype data_member2;

public:

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

void get_data() {

// ... code to get data ... } void display_data() {

// ... code to display data ... } };

Example:

Consider a class Square where we want to hide the number used to calculate its area.

#include <iostream>

class Square {

private:

int num; // Data member 'num' is hidden

public:

void getNumber() {

std::cout > num; } int calculateArea() {

// Accessing private member 'num' within the class

return num * num; } };

int main() {

Square s;

s.getNumber(); // Public function to set the private data

int area = s.calculateArea(); // Public function to use the private data

std::cout

In this example, the data member num is declared as private. It cannot be accessed directly from the main function (as indicated by the commented-out line). Instead, the public member functions getNumber() and calculateArea() are used to interact with num, demonstrating data hiding.