Masters of Computer Application (C++)

In C++, functions can return references or pointers to variables, allowing for modifications to the original data through the return value. This is useful for operator overloading and chaining operations. However, care must be taken not to return references to local variables that go out of scope.

The fail() function returns true when a stream operation fails, including when an input/output operation on a file fails. This sets the failbit in the stream state. The bad() function is for serious errors like stream corruption, good() returns true if no errors occurred, and eof() checks for end-of-file condition specifically.

The * operator in C++ is called the indirection operator or dereference operator because it accesses the value at the address stored in a pointer. It is the opposite of the address-of operator (&). Address and reference operators are different concepts.

C++ does not support nested comments. Once the compiler encounters the first closing */, it considers the comment complete. The remaining text becomes invalid syntax, causing compilation error.

Virtual functions in base classes enable runtime polymorphism through dynamic binding. Even if not directly used in the base class, they must be declared to establish the interface for derived classes to override.

Multilevel inheritance occurs when a derived class itself becomes a base class for another class, forming a chain. Hierarchical inheritance has multiple derived classes from one base. Multiple inheritance means deriving from multiple base classes.

The expression x-- uses the postfix decrement operator, which returns the current value (7) before decrementing x to 6. So z = 7 - 6 = 1. If it were --x, the answer would be 0.

Inside the parentheses: q+r=50, r-10=20. 50>20 evaluates to true (1). The ! operator negates this to false (0). In C++, true is 1 and false is 0.

cin.getline(a,10) reads up to 9 characters plus null terminator. 'Ram Krishan Verma' is truncated to 'Ram Krish' (9 chars) then null-terminated. getline stops at the buffer limit, preserving whatever fits.

Following operator precedence: 13=3, 15=5. Then: 0+3-5 = -2. Multiplication has higher precedence than addition and subtraction.

Object pointers cannot directly access private members. Access specifiers apply regardless of whether you use an object or a pointer to an object. Private members are only accessible within member functions or friends.

ios::ate (at end) opens the file and positions the pointer at end, but allows reading/writing anywhere in the file. ios::app only allows appending at end. ios::trunc discards existing content. ios::ate provides random access.

p points to z[0]=5. *p+1 dereferences p (getting 5) then adds 1, giving 6. The precedence is: (*p) + 1, not *(p+1). The latter would give z[1]=6, but that's not what's written.

C++ has exactly four storage classes: auto (default for local variables), register (suggests CPU register storage), static (preserves value between function calls), and extern (for global/external linkage).

External variables (declared with extern keyword) are automatically zero-initialized in C/C++. This ensures global and external variables start with a predictable value when no explicit initialization is provided.

The loop runs exactly once: a starts at 100, condition (a>=100) is true, 'hello' is printed, then --a decrements a to 99. On the next iteration, condition (99>=100) is false, so the loop exits.

seekg() sets the current get (input) position in an input stream. The companion function seekp() sets the put (output) position for output streams. The 'g' stands for 'get'.

Enums assign integers starting from 0: parrot=0, crow=1, pigeon=2, sparrow=3. Since b is assigned pigeon (the third element), it has value 2. The output is the numeric value, not the name.

Tracing the nested conditions with p=10, q=20, r=30: First if (p>10)||(q<30) evaluates to (false)||(false) = false, so we skip to the final cout statement and print 'Autumn'. The inner if-else blocks are never executed.

The pointer p points to z[0] (value 5). The expression *p+1 dereferences p first (getting 5), then adds 1, resulting in 6. Dereference has higher precedence than addition.

The pointer p points to m (value 10). (*p)++ increments m to 11. Then cout<<(*p)++ prints 11 (post-increment returns the value before incrementing). Final value of m is 12, but output is 11.

This code has a compilation error due to diamond inheritance ambiguity. Class stars inherits from both sun and moon, each having a result() method. Calling s.result() is ambiguous - the compiler cannot determine which result() to use. This requires scope resolution (s.sun::result() or s.moon::result()) or virtual inheritance.

This code has a compilation error due to diamond inheritance ambiguity. Class stars inherits from both sun and moon, each having a result() method. Calling s.result() is ambiguous - the compiler cannot determine which result() to use. This requires scope resolution (s.sun::result() or s.moon::result()) or virtual inheritance.

Ada (in its original versions) was not designed as an object-oriented programming language. It was primarily a structured, imperative language with strong typing. Smalltalk, Java, and Object Pascal all support object-oriented programming. Note: Ada 95 later added OOP features, but the original language did not have them.

In C++, structures (struct) have public access by default, unlike classes where members are private by default. This is a fundamental distinction between struct and class. Protected is used for inheritance scenarios, and 'none of these' is incorrect since public is the default.

In C, external (global) variables are automatically initialized to 0 if not explicitly initialized. This applies to both external variables and static variables. Local variables, however, are not automatically initialized and contain garbage values.