Programming Fundamentals

The const keyword before a function's return type (const int f(...)) prevents the function result from being used as an lvalue - you cannot assign to it. This means expressions like f() = 5 would be compile errors. The const refers to the return value being treated as read-only, not that it cannot be modified by others (option D is misleading - the returned value can still be modified if it's a reference/pointer).

The function returns a pointer to a local variable i. Local variables have automatic storage duration and are destroyed when the function returns. The returned pointer becomes a dangling pointer pointing to invalid memory. Using this pointer causes undefined behavior. This is a classic C/C++ error - never return pointers to local variables.

The syntax const int* const ptr declares a pointer to a const int where both the pointer and the pointed-to value are const. The first const (before int) makes the value unchangeable through this pointer. The second const (after the *) makes the pointer itself unchangeable (it cannot point to a different address). Option A only protects the value, not the pointer.

In C++, assigning a void* to a char* without an explicit cast is not allowed. While this is valid in C (where void* can be implicitly converted to any other pointer type), C++ requires an explicit cast: c = (char*)vp; or c = static_cast(vp);. The other assignments are valid - void* can receive any pointer, and casts between pointer types are allowed.

The extern C linkage specification tells the C++ compiler that the enclosed functions were compiled by a C compiler and should use C linkage rules. This disables C++ name mangling, allowing C++ code to link with C functions. Without this, C++ would mangle the function names, and the linker couldn't find the C functions.

Value types in C# cannot normally represent null. However, the introduction of Nullable value types (e.g., int? or Nullable) allows them to hold null values. Because value types can be assigned null under these conditions, the statement is false.

In C#, a two-dimensional array is declared using the syntax 'type[,] arrayName' where the comma indicates the number of dimensions. 'int[,]' declares a 2D array, while 'int[][]' would be a jagged array (array of arrays).

A delegate in .NET is a type-safe object-oriented function pointer. Delegates hold references to methods (static or instance) and can be used to pass methods as parameters, implement callback mechanisms, and define events. Unlike raw function pointers, delegates are type-safe and can reference multiple methods (multicast delegates).

.NET prevents DLL Hell by allowing assemblies to specify both the name AND exact version of their dependencies in the manifest. This ensures that an application loads the specific versions of assemblies it was built and tested against, rather than whatever arbitrary version happens to be present. The runtime can then enforce versioning policy and redirect binding if configured.

The SSRANGE compiler option in COBOL generates code to check whether subscripts, indexes, or reference modifiers exceed the declared boundaries of an array at runtime, ensuring array bound checking. If subscripts are out of bounds, a runtime error is raised, preventing memory corruption or access to invalid locations.

In COBOL, array indexes (also called subscripts) are internal working-storage variables used to access table elements. These indexes are defined in the WORKING-STORAGE section and can be displayed using standard DISPLAY statements like other data items, but the question's wording suggests it refers to internal implementation details not directly visible.

Variables defined in a report are accessible across all tabs within that report by default. This global scope allows for consistent calculations and references throughout the document. The option about 'global or Private' is misleading terminology in this context.

Report-level variables have global scope within the report, making them accessible from all tabs. Tab-specific variables would be local to that tab only. Options A and C confuse variable scope with declaration type.

A COBOL IF statement can experience logical errors (incorrect condition formulation), runtime errors (type mismatches or invalid comparisons), and can potentially contribute to infinite loops if condition evaluation never becomes false. These represent the major categories of programming errors that can manifest within conditional logic.

The COBOL PERFORM loop is equivalent to a do-while loop found in languages like Java and C++. Both structures execute the loop body at least once before testing the continuation condition, making them different from while loops which test the condition before the first iteration.