Java and C++ Programming Fundamentals

In C, the order of evaluation of printf arguments is unspecified. However, the values are computed right-to-left before printing. Starting from i=5: i++ makes 6, i-- makes 4, ++i makes 5, --i makes 4, and i is 4. But compilers may vary. On systems producing 4 5 5 4 5, this matches option D. This tests understanding of increment/decrement operators and evaluation order.

The code declares 'p' as a pointer to a const int (int const *p), meaning the value pointed to cannot be modified. The line printf("%d",++(*p)) attempts to increment the value through the pointer, which violates the const qualifier. This results in a compilation error. Option D is correct.

The macro square(x) expands to xx. When used in 64/square(4), this becomes 64/44 due to macro expansion (not 64/(44)). Following C's left-to-right evaluation for same-precedence operators: 64/4 = 16, then 164 = 64. This is a classic macro pitfall - always use parentheses in macro definitions. Option C (64) is correct.

With base address 100, a is the array address (100). *a is the first 2D array address (also 100 due to same starting point). **a is the first 1D array address (still 100). ***a dereferences to the first element value (2). For the second printf: a+1 adds one full 3D array (size 12 integers = 48 bytes) giving 148... wait, let me recalculate. With base address 100 for a[2][3][2], each dimension's size varies. The output 100 100 100 2, 112 104 102 3 is consistent with pointer arithmetic on this multidimensional array structure.

This code uses an array of pointers and a pointer to a pointer. ptr starts pointing to p. After ptr++, ptr-p=1, *ptr-a=1, **ptr=1 (value at a[1]). The operations *ptr++, *++ptr, and ++*ptr manipulate these pointers in different ways. The output 111 222 333 444 shows the progression through the array elements as the pointer is advanced through each step.

Object and Math are fundamental classes in java.lang package. Object is the root class of all Java classes, and Math provides mathematical functions. Random is in java.util, and Stack is in java.util, not java.lang.

Byte, Integer, and Short are wrapper classes that wrap primitive types byte, int, and short respectively. String is not a wrapper class; it's a reference type, not a wrapper for a primitive.

In Java, String literals s1 and s2 refer to the same pooled instance, so s1 == s2 is true. s3 is created with 'new', so s3 == s1 is false. However, equals() compares character content, so s1.equals(s2) and s3.equals(s1) both evaluate to true. Three options are correct here.

wait() and notify() are defined in java.lang.Object class, making them available to all objects since every class inherits from Object. They are not in Thread, Runnable, or ThreadGroup classes.

Abstract classes cannot be instantiated directly because they contain at least one pure virtual function with no implementation. You can only create objects of concrete derived classes that implement all the pure virtual functions. The abstract class serves as a template for inheritance.

Virtual functions in parent classes do NOT need to be redefined in all child classes. A child class can inherit the parent's implementation if it doesn't need custom behavior. The override is optional - it's only required if the child class needs specific behavior.

This is valid C++ syntax because the string class has a constructor that accepts a const char* parameter. The double-quoted string literal "tcs" is automatically converted to a char array, which the string constructor can initialize from.

Static global variables have file scope and internal linkage. They cannot be accessed from another file using extern because extern is for variables with external linkage. Static at file scope specifically restricts visibility to the current translation unit.

"abc" is a string literal, which is an object/array of characters, not a primitive value. Primitive types are basic types like int, char, float, bool. Strings (even string literals) are compound types or objects depending on the language.

In object-oriented theory and most language implementations, every class is considered a trivial subclass of itself. The "is-a" relationship is reflexive - a class is itself. This is mathematically consistent with inheritance hierarchies and type systems.

Exceptions can be rethrown in catch blocks using the 'throw' keyword without arguments (preserving the original exception) or by throwing a new exception. Rethrowing allows handling at multiple levels - do some local handling then propagate up.

The $ and _ characters CAN be used as the first character of an identifier in most languages (C, C++, Java, C#, JavaScript, etc.). Only digits (0-9) cannot be the first character. Letters, underscore, and dollar sign are all valid starting characters.

this() is used in constructors to call another constructor of the same class (constructor chaining). It must be the first line in the constructor. This allows code reuse between overloaded constructors and avoids duplicating initialization logic.