Masters of Computer Applications (C++)

In C and C++, enumerated data types (enums) assign integer values starting from 0 by default. The first enumerator gets value 0, the next gets 1, and so on sequentially. However, programmers can explicitly assign different values if needed. This default behavior makes enums useful for array indexing and creating named constants.

A source file contains the original program code written by a programmer in a high-level language before compilation. It's called 'source' because it's the original human-readable code. The compiler translates source files into object files, which are then linked into executable files. The edit window in IDEs is where source code is written and modified.

In C++ inheritance, a protected member inherited in public mode remains protected in the derived class. Public inheritance maintains the access level - public members stay public, protected members stay protected, and private members remain inaccessible (though they exist in the derived class). This preserves encapsulation while allowing controlled access in the inheritance hierarchy.

C++ allows member functions to be defined either inside the class definition (implicitly inline) or outside the class using the scope resolution operator (::). Defining inside is convenient for short functions, while defining outside keeps the class interface clean. Both approaches are valid and commonly used depending on function complexity and coding style preferences.

The commonly cited types of inheritance in C++ are: single, multiple, multilevel, hierarchical, and hybrid (or virtual). This makes 5 main categories. Single involves one base class, multiple involves multiple base classes, multilevel involves chains of inheritance, hierarchical involves one base class with multiple derived classes, and hybrid combines different forms. Some textbooks may use slightly different terminology or categorizations.

The code has a typo: 'void mail()' instead of 'void main()'. This creates a linker error because the linker looks for the main() function as the program entry point but can't find it. The program compiles successfully but fails during linking. This is a common error that occurs when the required main() function is missing or misspelled, preventing the program from being properly linked into an executable.

The arrow operator (->) is used in C/C++ to access members of a structure or class through a pointer. If ptr is a pointer to a structure, ptr->member is equivalent to (*ptr).member. This is a fundamental pointer operation for structured data.

A linker combines multiple object files (compiled from source code) into a single executable program. It resolves references between modules and performs address binding. Compilers create object files, while linkers create the final executable.

The scope resolution operator (::) in C++ is used to access global variables when local variables have the same name, to define class methods outside the class definition, and to access static class members. The arrow operator (->) is for pointer member access, && is logical AND, and : is used in ternary operators.

The fputs function writes a string to a file stream and is declared in stdio.h, which contains standard input/output functions. This header includes file operations like fputs, fgets, fprintf, and fscanf. stdlib.h is for general utilities, process.h for process control, and dos.h for DOS-specific functions.

The isascii function checks if a character is an ASCII character (value 0-127) and is declared in ctype.h. This header contains character classification functions like isalpha, isdigit, islower, and isspace. alloc.h is for memory allocation, stdlib.h for general utilities, and dos.h for DOS-specific functions.

This array definition is invalid because it's missing the array size in the declaration. In C/C++, when initializing an array, you must specify its size either explicitly (int array1[2]={34,69}) or implicitly through initialization (int array1[]={34,69}). The syntax int array1={34,69} is not valid for array declaration.

The code initializes i=1 and j=1, then increments j to 2. The condition checks if i==11, but i equals 1, not 11. Therefore, the else branch executes, printing 'its not eleven'. The value of j is irrelevant to the conditional logic.

Classes in C++ offer three levels of accessibility: public (accessible from anywhere), private (accessible only within the class), and protected (accessible within the class and derived classes). These three access specifiers form the foundation of encapsulation in object-oriented programming.

Virtual functions enable runtime polymorphism through dynamic binding. When a virtual function is overridden in derived classes, the correct function version is called based on the actual object type, not the pointer type. This allows different behaviors for the same function call across different classes in an inheritance hierarchy.

Array elements are zero-indexed in C/C++ and most programming languages. Element myarray[4] is actually the fifth element because myarray[0] is the first, myarray[1] is the second, and so on. This zero-based indexing is a common source of off-by-one errors for beginners.

Tracing the function: initially a=6, b=30. After a=a*b: a=180. After b=b-a: b=30-180=-150. After a=a-b: a=180-(-150)=330. Since parameters are passed by reference, main's variables are modified. The final output is '330, -150'. The function effectively swaps and scales values through arithmetic operations.

Static member variables are initialized to 0 when the first object of the class is created, and this initialization happens only once. They are shared among all objects of the class and retain their values between object creations. They are not re-initialized to 1 each time, and they are not visible outside the class unless declared public.

In SQL and file systems, ? matches any single character and * matches any sequence of characters. These are the standard wildcard characters used in pattern matching.

In C++, 'virtual' is a reserved keyword used for polymorphism. Reserved keywords cannot be used as variable names, while 'assignment', 'pointer', and 'object' are valid identifiers.

The scope resolution operator (::) is used to access static members and namespace members, not for dereferencing. The other operators (* dereferences pointers, .* dereferences through objects, and ::* dereferences pointers to members) all perform dereferencing operations.

When input is 'a', case 'a' executes but has no break statement, causing fallthrough to case 'g' and then default. This outputs 'apple' + 'grapes' + 'invalid choice' without spaces.

The << operator is called the 'put to' or insertion operator in C++ stream operations. It directs data to an output stream. Conversely, >> is the 'get from' or extraction operator.

The inner value() function has static int j=40, so it prints 40. The outer value() function has static int j=5. When value() calls value(), the inner function's j (40) is printed first, then the outer's j (5). The global j=10 is shadowed by both function-local static variables.

The scope resolution operator (::) cannot be overloaded in C++ because it's essential for language syntax and name lookup. Operators like +, +=, and [] can all be overloaded for user-defined types.

Friend functions are declared inside a class but defined outside. They're not affected by public/private/protected sections - placement makes no difference to meaning. They're not member functions, so they need object references to access members, and can be called independently.

A default constructor takes no parameters. Option B has star() with no parameters, making it the default constructor. Options A and C have constructors with parameters (parameterized constructors), not default constructors.