Consider Column-I and Column-II in context of C++:
Column-I - Column-II
i. Private - a. Data type modifier
ii. Sizeof - b. Visibility specifier
iii. Static - c. Operator
iv. Long - d. Storage class.
Match of Column-I and Column-II is:

Question

Consider Column-I and Column-II in context of C++: 
Column-I - Column-II
i. Private - a. Data type modifier
ii. Sizeof - b. Visibility specifier
iii. Static - c. Operator
iv. Long - d. Storage class.
Match of Column-I and Column-II is:

Accepted Answer

The correct option is (4):
The correct matches establish the core function of each keyword or operator in C++. The term **'Private' (i)** is a fundamental Object-Oriented Programming (OOP) concept, acting as a **Visibility specifier (b)** that controls access to class members, ensuring that they are only accessible from within the class itself. Next, **'Sizeof' (ii)** is correctly identified as an **Operator (c)**; specifically, it is a unary operator used to determine the memory size, in bytes, required for a data type or expression. Moving on, **'Static' (iii)** functions as a **Storage class (d)** specifier, controlling the lifetime and visibility of variables, such as making local variables persist or giving global scope to class members. Finally, **'Long' (iv)** is accurately categorized as a **Data type modifier (a)**, a keyword used to alter the size and, consequently, the range of primary data types like `int` and `double`. Therefore, the match i-b, ii-c, iii-d, iv-a is the only one that correctly aligns all C++ concepts with their proper roles.

The incorrect option is (1):
Option (1) proposes the match i-d, ii-c, iii-a, iv-b. This is incorrect because it miscategorizes three of the four terms. **'Private' (i)** is incorrectly matched with 'Storage class (d)'; it is an access/visibility specifier, not a storage specifier like `auto` or `extern`. Furthermore, **'Static' (iii)** is wrongly linked to 'Data type modifier (a)', as its primary role is to define the storage duration and scope, making it a storage class specifier. Lastly, **'Long' (iv)** is incorrectly associated with 'Visibility specifier (b)'; `long` modifies the size of a data type, while `private`, `public`, and `protected` are the actual visibility specifiers. The only correct alignment in this option is ii-c, linking `sizeof` to 'Operator'.

The incorrect option is (2):
Option (2) suggests the mapping i-c, ii-d, iii-b, iv-a, which is wrong on three counts. It incorrectly classifies **'Private' (i)** as an 'Operator (c)'; access specifiers and operators serve completely different purposes in a class definition. It also incorrectly matches **'Sizeof' (ii)** with 'Storage class (d)'; `sizeof` is an expression evaluation tool, whereas storage classes manage memory allocation and scope. Most significantly, **'Static' (iii)** is wrongly identified as a 'Visibility specifier (b)'; while it does affect scope, its fundamental classification is as a storage class specifier, not an access control keyword. Only the final match iv-a, linking `long` to 'Data type modifier', is correct.

The incorrect option is (3):
Option (3) presents the match i-a, ii-d, iii-b, iv-c, which contains three fundamental errors. It wrongly states that **'Private' (i)** is a 'Data type modifier (a)'; its function is to restrict access, not to change a type's properties. It also incorrectly pairs **'Sizeof' (ii)** with 'Storage class (d)', confusing a size-determining operator with a keyword that defines a variable's memory attributes. Finally, **'Long' (iv)** is erroneously matched to 'Operator (c)', a category reserved for symbols or keywords that perform an operation, not for keywords that modify data types. The matches i-b, ii-c, and iv-a are the correct classifications.