C++ Programming Fundamentals

In programming, functions can return various data types including primitive values (numbers, strings, booleans) and complex objects. Objects are a valid return type in languages like JavaScript, Python, and many others.

Inline functions eliminate the function call and return overhead by replacing the call site with the actual function body at compile time. This avoids stack frame creation, parameter passing, and jump instructions, which can improve execution speed for small, frequently called functions.

In C++, default arguments must be specified from right to left. If a parameter has a default value, all parameters to its right must also have default values. Here, parameter 'a' has a default value but parameter 'b' (to its right) does not, making this declaration invalid.

Union is a user-defined data type that allows different data types to share the same memory location. Arrays and pointers are built-in types provided by the language, while functions are program constructs, not data types. Union, along with struct, enum, and class, must be defined by the programmer before use.

In C++ inheritance, a protected member of the base class remains protected in the derived class when inherited in public mode. Public inheritance preserves the access level of protected members - they stay protected, not public. Private inheritance would make them private, and protected inheritance would keep them protected.

All statements A, B, and C are correct about static member functions: they can only access other static members, can be called using class name, and the static keyword appears before the return type in declaration (not before the function name). Since all individual statements are true, 'None of the above' is technically incorrect, making D the answer choice.

The sizeof operator is a unary operator because it operates on a single operand - either a type name or an expression. It returns the size in bytes of its operand at compile-time. Unary operators work with one operand, unlike binary operators which require two.

Assignment D (*p=&i) is invalid. The left side *p dereferences the pointer to access the integer value it points to, while &i gives the address of i. You cannot assign an address to an integer value. Assignments A and B require p to point to valid memory first, and C correctly stores i's address in p.

An object is indeed a self-contained abstraction that encapsulates data and behavior. In object-oriented programming, objects represent real-world items or concepts and combine attributes (data) and methods (operations) into a single unit, hiding internal implementation details from external access.

During function calls, the sequence (order) of actual and formal parameters must match exactly. You cannot rearrange the order of arguments - the first actual parameter maps to the first formal parameter, the second to the second, and so on. This is why option A is the incorrect statement.

The variables passed to a function during a function call are called actual parameters (or actual arguments). They are the values or expressions provided by the caller. Formal parameters are the variables declared in the function definition that receive these values. Local and global variables are storage duration specifiers, not call-related terms.

The fstream.h header file (or in standard C++) provides classes and functions for file input/output operations. The read() function reads data from a file, and open() opens a file stream. iostream.h handles console I/O, stdio.h is for C-style I/O, and iomanip.h is for I/O formatting.

The integer i=2 is non-zero, which evaluates to true in the if condition. The if branch executes, printing i++ using post-increment. Post-increment returns the current value (2) then increments, so 2 is printed. The else branch is never reached.

Polymorphism in OOP allows objects of different classes to be treated as objects of a common superclass. The core concept is one interface (function/operator name) with multiple implementations (forms). This includes function overloading, operator overloading, and virtual functions.

In C++, destructors are special member functions that have the same name as the class but preceded by a tilde (~). They are automatically called when an object is destroyed to clean up resources like memory or file handles.

In C and C++, uninitialized local array elements contain garbage values - whatever bits were previously in those memory locations. Only static and global arrays are automatically initialized to zero. This is why explicit initialization is important.

In C++, enum constants are assigned integer values starting from 0 by default. So pink=0, yellow=1, blue=2, black=3. When printed, the enum values are converted to their integer equivalents, producing '2 3' as output.

Arrays in C/C++ are stored in contiguous memory locations. This means elements are placed in adjacent memory cells, which enables pointer arithmetic and efficient array traversal. This contiguous allocation is a fundamental property of arrays.

The function fun receives global g (value 10) by reference and local g (value 5) by value. x=x-y makes x=10-5=5. Then y=x10 makes y=510=50. Output is '5,50'. The global g is modified to 5, but the local g in main remains unchanged.

Class C uses multiple inheritance, inheriting from both class A and class B (syntax: class C: public A,B). This makes A and B the base classes and C the derived class. Multiple inheritance allows a class to inherit from multiple base classes simultaneously.

In C and C++, structure definitions must end with a semicolon after the closing brace. This is because a structure declaration is a statement and requires proper termination. The semicolon is mandatory even when defining structure variables.

In most programming languages including C/C++, functions can only return exactly one value. While there are workarounds like returning pointers/arrays or using reference parameters, the formal return statement itself returns only one value. This is a fundamental limitation.

C++ allows variables to be declared anywhere in the program, not just at the beginning of a block. This is a key difference from C89. Variables can be declared at their point of first use, which improves code readability and allows initialization closer to where values are needed.