Question 1

In VSAM, what does a RETURN-CODE value of 28 generally indicate during a read operation on a data set?

Accepted Answer

Introduction / Context: VSAM (Virtual Storage Access Method) is a file access method used on IBM mainframe systems. It returns specific codes to indicate the outcome of operations such as OPEN, READ, WRITE, and CLOSE. Understanding these return codes is important for diagnosing problems in batch jobs and online programs. This question focuses on the meaning of a VSAM RETURN-CODE value of 28 during a read operation. Given Data / Assumptions: The environment involves VSAM data sets on a mainframe. The operation of interest is a read request. The RETURN-CODE value is 28. We assume normal application level interpretation of VSAM codes. Concept / Approach: Many VSAM return codes correspond to logical or physical conditions encountered when accessing data sets. A common situation is attempting to read beyond available records, which produces an end of file condition. When a program calls VSAM to read the next record and there are no more records, the returned code signals this state so that the program can stop reading gracefully. Therefore, an answer that describes reading beyond the last record and end of file semantics is the most appropriate, rather than answers about network, backups, or compile time errors. Step-by-Step Solution: 1. Recall that VSAM distinguishes between successful reads and conditions such as end of file or record not found. 2. Understand that when the last record has already been read, a subsequent read attempts to move past the end of the data set. 3. This results in a special return code that tells the program there are no more records. 4. Examine the options and choose the one that states an attempt to read beyond the last record and signals an end of file condition. 5. Confirm that other options describe situations unrelated to VSAM record access, such as network failures or compile time syntax errors. Verification / Alternative check: You can verify by thinking of a typical COBOL program that reads a VSAM file in a loop. The loop continues as long as the read operation returns a success or non end of file status. When the program reaches the last record, the next read returns a code indicating the end of file, and the program exits the loop. No network, backup, or compile time activity is involved in this runtime condition. This confirms that record exhaustion and end of file semantics are the key ideas for the return code in question. Why Other Options Are Wrong: Option B is wrong because a VSAM return code does not directly describe network connection status; network issues are handled at different layers. Option C is wrong because VSAM return codes are not used to indicate automatic backups that permanently block access to data sets. Option D is wrong because compiler syntax errors are discovered before runtime and are not signaled by VSAM during file operations. Common Pitfalls: A common pitfall is treating all non zero return codes as general errors without understanding their specific meaning. For example, an end of file condition is not necessarily an error; it is a normal part of controlled sequential processing. Another mistake is confusing VSAM file status codes and other system return codes, which may have different numbering and interpretation. Reading and interpreting VSAM documentation carefully helps avoid misdiagnosing conditions like end of file as hardware or network failures. Final Answer: The correct answer is That an attempt was made to read beyond the last record in the VSAM data set, indicating an end of file condition, because this describes the logical situation that VSAM signals with this return code during read operations.

Question 2

In C++ object oriented programming, which of the following is not a valid access specifier keyword (public, protected, or private)?

Accepted Answer

Introduction / Context: Access control is a core concept in C++ object oriented programming. It allows a class designer to decide which parts of a class are visible to other classes or to external code. The C++ language provides a small, fixed set of access specifiers that control whether members are accessible publicly, only by derived classes, or only inside the class itself. This question checks whether you remember exactly which keywords are valid access specifiers and can therefore distinguish them from other C++ keywords that have completely different roles. Given Data / Assumptions: The language is standard C++. We are talking specifically about access specifiers for class members. The commonly used access specifiers in C++ are public, protected, and private. Any other keyword listed alongside these may be a distractor and not an access specifier. Concept / Approach: In C++, the three valid access specifier keywords are public, protected, and private. These keywords appear in class or struct definitions followed by a colon and apply to the members declared after them. Public members are accessible from anywhere the class is visible. Protected members are accessible inside the class itself and by derived classes, but not by unrelated external code. Private members are accessible only inside the class and by designated friends. The keyword default does exist in C and C++ but it is used in switch statements, not as an access specifier. Any answer that suggests default as an access specifier is therefore incorrect. Step-by-Step Solution: Step 1: List the standard C++ access specifiers: public, protected, and private. Step 2: Compare each option with this list. Public appears in the list, so it is a valid access specifier. Step 3: Protected also appears in the list, so it is a valid access specifier. Step 4: Private appears in the list as well and is therefore another valid access specifier. Step 5: Default is not in the list of access specifiers and is instead used in switch statements, so it is not an access specifier. Verification / Alternative check: If you recall the typical layout of a class, you will remember code such as class Example { public: int x; private: int y; protected: void helper(); }. There is no place in this syntax where default appears. Similarly, in documentation and tutorials about C++ access control, only public, protected, and private are described. This consistent absence of default in the context of member access control confirms that it is not a valid access specifier keyword. Why Other Options Are Wrong: Option public: This is a valid access specifier and cannot be the correct choice for a question asking which one is not an access specifier. Option protected: This is also a valid access specifier that controls access for derived classes and is therefore not the right answer. Option private: This is the default access specifier for classes and is a central part of encapsulation, so it is clearly valid. Common Pitfalls: Many learners confuse the concept of a default access level with a keyword named default. In C++, classes default to private access for members if no specifier is given, and structs default to public, but there is no keyword default used to declare this. Another pitfall is mixing up the default label in a switch statement with access control keywords. Keeping in mind that switch uses the case and default labels, while classes use public, protected, and private, helps avoid this confusion. Final Answer: The option that is not a valid C++ access specifier is default.

Question 3

In data structures, which of the following operations is not the name of a standard sorting method or sorting algorithm?

Accepted Answer

Introduction / Context: Sorting algorithms are a fundamental topic in data structures and algorithms. Common names such as insertion sort, selection sort, and exchange sort appear frequently in textbooks and interviews. At the same time, common operations like insertion and deletion are used with many data structures but are not themselves the names of specific sorting methods. This question is designed to check whether you can distinguish between standard sorting algorithm names and generic operations on data structures. Given Data / Assumptions: The context is classic comparison based sorting in introductory data structures. Some options correspond to well known sorting algorithm names. Other options may describe generic operations rather than specific sorting algorithms. We assume standard terminology from textbooks, not invented custom methods. Concept / Approach: Insertion sort is a well known algorithm that builds a sorted list one element at a time by inserting each new element into its correct position within the already sorted portion. Selection sort repeatedly selects the smallest (or largest) element from the remaining unsorted part and moves it to the correct position. Exchange sort is a general term sometimes used for algorithms where elements are repeatedly compared and swapped, including bubble sort like behaviour. Deletion, on the other hand, is a basic operation that removes an element from a data structure and is not the name of a standard sorting algorithm. Therefore the correct answer must be the option that represents a generic operation rather than a recognised sorting method name. Step-by-Step Solution: Step 1: Identify known sorting algorithms: insertion sort, selection sort, and exchange based sorts are all present in algorithm lists. Step 2: Recognise that insertion sort is a classic O(n^2) algorithm taught in almost every course, so it is clearly a sorting method. Step 3: Recognise that selection sort is another classic O(n^2) sorting method that repeatedly picks the next smallest element. Step 4: Note that exchange sort refers to sorting by swapping out of order pairs and is used as a category name for some simple sorting techniques. Step 5: Realise that deletion describes the removal of an element from a data structure and is not a sorting algorithm name, so it must be the correct answer. Verification / Alternative check: If you consult any standard algorithms textbook, the chapter on sorting will include entries for insertion sort and selection sort and may mention exchange based or swap based sorts. There will not be an algorithm chapter titled deletion sort, because deletion is a primitive operation, not a full sorting strategy. This cross check between memory and standard references supports the conclusion that deletion is not a sorting method name. Why Other Options Are Wrong: Option Insertion sort: This is a standard sorting algorithm where elements are inserted into a growing sorted portion of the array. Option Exchange sort: This describes a family of algorithms that work by exchanging out of order elements, so it is a recognised sorting term. Option Selection sort: This is another classic sorting algorithm that repeatedly selects the minimum or maximum element. Common Pitfalls: A common mistake is to focus on words like insertion and deletion and assume that if there is an insertion sort, there must also be a deletion sort. Another pitfall is to over interpret the word exchange and assume it is not a proper term, even though it is used for certain simple algorithms. To avoid such errors, it helps to memorise the standard list of sorting methods and treat operations like deletion as generic actions rather than algorithm names. Final Answer: The operation that is not the name of a standard sorting method is Deletion.

Question 4

A binary tree with 7 nodes will have how many null child pointers (empty branches) in its linked representation?

Accepted Answer

Introduction / Context: Binary trees are widely used in data structures, and a common way to represent them in memory is through linked nodes. Each node typically has two pointer fields, one for the left child and one for the right child. Many exam questions test the relationship between the number of nodes in a binary tree and the number of null child pointers, because this gives insight into how sparse or full a tree is and helps in reasoning about memory usage and structural properties. Given Data / Assumptions: We have a binary tree with exactly 7 nodes. Each node has two child pointers: left and right. A null branch means a child pointer that does not point to another node, that is, it is empty or null. The tree is a general binary tree, not necessarily a full or complete binary tree, but the null pointer formula still applies. Concept / Approach: There is a standard property of binary trees represented with linked nodes: for any non empty binary tree with n nodes, the total number of null child pointers is n + 1. This can be reasoned from the fact that every node (except the root) is pointed to by exactly one child pointer, and there are 2n total child pointer positions. The number of used pointers is n - 1 because the root is not pointed to by any parent. The remaining pointers, which are null, are 2n - (n - 1) = n + 1. This simple relationship holds for every binary tree, regardless of its shape. Step-by-Step Solution: Step 1: Note that the binary tree has n = 7 nodes. Step 2: Recognise that each node contributes two child pointer slots, for a total of 2n = 2 * 7 = 14 pointer positions. Step 3: Understand that each node except the root is pointed to exactly once by some parent, so there are n - 1 = 6 non null child pointers. Step 4: Compute the number of null pointers as total child pointers minus non null pointers: 14 - 6 = 8. Step 5: Alternatively apply the direct formula n + 1 = 7 + 1 = 8 for the number of null branches. Verification / Alternative check: As a second check, imagine a full binary tree with 7 nodes. A perfect tree of height 2 has one root, two children at level 1, and four children at level 2. The bottom level nodes have no children, so each of the 4 leaf nodes contributes two null child pointers, for a total of 8 null pointers. This visual example matches the n + 1 formula and confirms that the answer of 8 null branches is correct for 7 nodes. Why Other Options Are Wrong: Option 6: This would correspond to n - 1 and counts only the non null child pointers, not the null pointers. Option 7: This is equal to n and does not match the derived expression n + 1 for null pointers. Option 5: This has no standard relationship with the number of nodes in the tree and does not arise from the pointer counting argument. Common Pitfalls: Students sometimes confuse the number of edges in a tree, which is n - 1, with the number of null pointers, which is n + 1. Another common mistake is to try to reason by listing children manually without a formula, which becomes error prone for larger trees. Remembering the simple relationship that a binary tree with n nodes has n + 1 null child links helps quickly answer many similar questions without drawing the entire structure every time. Final Answer: A binary tree with 7 nodes will have 8 null child pointers or empty branches.

Question 5

In external sorting and sequential file organisation, which of the following methods are used when storing or merging sequential files on secondary storage?

Accepted Answer

Introduction / Context: When data sets become too large to fit entirely into main memory, external sorting techniques are used. These methods rely on storing data in sequential files on secondary storage such as disks or tapes and then performing multiway merges of sorted runs. Concepts like natural merging, polyphase sorting, and distribution of initial runs are closely associated with external merge sort implementations. This question tests whether you can recognise that these techniques all belong to the family of methods used in the organisation and processing of sequential files. Given Data / Assumptions: We are dealing with sequential file organisation and external sorting. Natural merging, polyphase sort, and distribution of initial runs are all mentioned as possible methods. The question asks which of these are used in the context of storing and processing sequential files. We assume standard textbook descriptions of external merge sort techniques. Concept / Approach: External merge sort typically proceeds in two phases. In the first phase, the input file is scanned, and sorted runs are created, either by reading chunks into memory and sorting them or by using replacement selection to produce longer runs. This stage is sometimes referred to as the distribution of initial runs, because these runs are written out to multiple work tapes or temporary files. In the second phase, these runs are repeatedly merged to produce longer and longer sorted runs until a final sorted file is obtained. Natural merging uses the natural ordering of the data to identify runs that are already sorted and merges them. Polyphase sorting is an optimised form of multiway merging that makes efficient use of multiple tapes or files by varying the number of runs on each device. All three techniques are standard tools in the design of sequential file processing systems. Step-by-Step Solution: Step 1: Recognise that distribution of initial runs is part of the first phase of external sorting, where sorted subfiles are created. Step 2: Recall that natural merging is a variant of merge sort that takes advantage of segments of the file that are already in sorted order and merges these natural runs. Step 3: Remember that polyphase sort is a multiway merging strategy that uses variable run distributions on several tapes or files to reduce the number of passes. Step 4: Note that each of these methods is directly related to the handling and processing of sequential files in external sorting scenarios. Step 5: Conclude that the best answer must include all three methods, which leads to the choice All of the above. Verification / Alternative check: If you review any standard text on file organisation and external sorting, you will see chapters that first discuss how to generate and distribute initial runs, then how to merge them with techniques like natural merging and polyphase merge. The fact that these techniques appear together and are all described as parts of external merge sort confirms that treating them as a unified group is correct. Therefore, it is reasonable that all three are considered methods available when storing and processing sequential files. Why Other Options Are Wrong: Option Natural merging: This is a valid method, but it is only one part of the full set of techniques and does not cover run distribution or optimised multiway merging on its own. Option Polyphase sort: Also a valid method, but again only one approach within the broad topic of external sorting. Option Distribution of initial runs: This describes only the first phase of external sorting and does not include the merging strategies themselves. Common Pitfalls: Students sometimes memorise one or two external sorting techniques and assume that other names refer to unrelated concepts. Another common mistake is to think that only merging is relevant and to overlook the crucial role of generating and distributing initial runs. Remember that real external sorting implementations are pipelines, not single steps, and names like natural merging, polyphase sort, and distribution of initial runs all point to different stages or optimisations within that pipeline. Final Answer: All of the listed methods are used in sequential file handling and external sorting, so the correct choice is All of the above.

Question 6

In hash file organisation, what could the bucket size be if a single collision immediately causes an overflow (collision and overlapping occur at the same time)?

Accepted Answer

Introduction / Context: Hash file organisation is a common technique for storing records in files so that they can be accessed quickly by a hash key. Records are placed into buckets according to the value of a hash function. The capacity of each bucket, often expressed as the bucket size, determines how many records can be stored before an overflow occurs. This question focuses on an extreme case where every collision directly results in an overflow condition, and it asks you to infer the bucket size from that description. Given Data / Assumptions: We have a hash file organisation with buckets of some fixed capacity. A collision means that two different records hash to the same bucket address. Overlapping or overflow means that the bucket cannot hold additional records and some overflow handling technique is triggered. The question states that collision and overflow happen at the same time whenever a second record hashes to the same bucket. Concept / Approach: In a hash file, bucket size determines how many records can be stored in a bucket before overflows appear. If bucket size is greater than one, then a collision, which is simply two keys hashing to the same bucket, does not automatically cause overflow because both records can fit inside the bucket. Overflow will occur only when the bucket capacity is exceeded. If, however, every collision immediately produces an overflow, it must be the case that the bucket cannot hold more than one record. In that situation, the very first record occupies the single slot in the bucket, and the second record that collides will not fit and must go to an overflow area. Step-by-Step Solution: Step 1: Define bucket size as the number of records that a bucket can hold without overflow. Step 2: Consider bucket size equal to 2. The first record occupies one slot, the second record that hashes to the same bucket occupies the second slot, so collision does not cause immediate overflow yet. Step 3: Consider bucket size equal to 4. The first few collisions can be absorbed, and overflow would only occur after four records hash to the same bucket. Step 4: Consider bucket size equal to 1. The very first record uses the only available slot in the bucket. Step 5: When a second record hashes to the same bucket, a collision occurs and there is no free slot, so overflow happens at the same moment as the collision. Therefore the bucket size must be 1. Verification / Alternative check: Another way to verify is to think about the definition of collision and overflow. Collision simply means that two or more keys map to the same hash address. Overflow occurs when the bucket cannot store all of those records. For collision and overflow to always coincide on the second record, the bucket must become full as soon as the first record is inserted. This is only possible when the bucket capacity is exactly one record. Any larger bucket capacity would allow at least one collision to occur without overflow, contradicting the condition stated in the question. Why Other Options Are Wrong: Option 2: With bucket size 2, the first two colliding records fit into the bucket, so collision does not necessarily imply immediate overflow. Option 0: A bucket size of zero is not meaningful in practice because it would not allow any records to be stored and is not a standard assumption in hash file design. Option 4: With bucket size 4, multiple collisions can occur before any overflow happens, so collision and overflow do not occur at the same time. Common Pitfalls: A frequent misunderstanding is to assume that any collision in a hash table automatically means overflow or a problem, which is not true when buckets can hold multiple records or when open addressing is used. Another pitfall is to overlook that the question describes a very specific scenario where overflow always coincides with collision, which forces a minimal capacity interpretation. Carefully reading such qualifiers in exam questions is essential to avoid choosing a plausible but incorrect bucket size. Final Answer: If collision and overflow always occur at the same time in hash file organisation, the bucket size must be 1.

Question 7

In C++ classes, a default constructor is defined as a constructor that can be called with how many explicit arguments?

Accepted Answer

Introduction / Context: Constructors are special member functions in C++ that initialise objects when they are created. Among them, the default constructor plays a particularly important role because it allows objects to be created without providing any arguments at the call site. Understanding what qualifies as a default constructor is essential for topics such as automatic object creation, container classes, and aggregate initialisation. This question asks you to focus on how many explicit arguments a default constructor accepts by definition. Given Data / Assumptions: The language is standard C++. We are talking about default constructors in classes. A default constructor is one that can be invoked without passing any arguments in the object creation expression. Constructors may have parameters with default values, but the key property is whether a call can be made with no arguments. Concept / Approach: In C++, a default constructor is defined as a constructor that can be called with no arguments. This includes a constructor that has no parameters at all, as well as a constructor whose parameters all have default values so that the caller does not need to supply any arguments. In either case, from the caller perspective, there are zero explicit arguments in the constructor call. Therefore, when the question asks how many arguments a default constructor accepts, the correct interpretation is that it accepts zero explicit arguments at the point of invocation. Step-by-Step Solution: Step 1: Recall the formal definition: a default constructor is a constructor that can be called without any arguments. Step 2: Consider the simplest form, a constructor declared with an empty parameter list, such as Example(). When an object is created with Example obj;, the call uses no arguments. Step 3: Consider a constructor with parameters that all have default values, for example Example(int x = 0). This constructor can still be invoked as Example obj; without providing any explicit argument. Step 4: In both cases, from the caller side, the number of explicit arguments supplied is zero, which matches the definition used in the question. Step 5: Therefore, the correct choice is the option that states zero arguments or no parameters. Verification / Alternative check: You can verify this by thinking about how standard library containers behave. Many containers require that the stored type have a default constructor so that they can create arrays of objects or resize themselves without needing explicit arguments. When a vector of Example is resized, it constructs new Example objects by calling the default constructor without any arguments, which confirms that a default constructor is one that is callable with a zero argument call expression. Why Other Options Are Wrong: Option One argument: A constructor that always requires one explicit argument is not a default constructor, although it may be an overloaded constructor. Option Two arguments: Similarly, a constructor that needs two explicit arguments cannot be invoked with an empty call and so does not qualify as a default constructor. Option Three arguments: A constructor that always expects three explicit arguments also fails the requirement of being callable without arguments. Common Pitfalls: A typical confusion arises when constructors have parameters with default values. Some learners think that such constructors cannot be default constructors because parameters are present, but the true test is whether a call with no arguments is valid. Another pitfall is to confuse the term default constructor with copy constructor or parameterised constructor. Remember that the word default here refers to the absence of explicit arguments in the call expression, not to any default value of member variables. Final Answer: A default constructor in C++ can be called with Zero arguments (no parameters).

Question 8

In languages such as C++ and Java, where is a typical reference or pointer variable for a local object stored at runtime?

Accepted Answer

Introduction / Context: Understanding where data is stored in memory is an important part of learning systems programming and managed runtime environments. In languages such as C++ and Java, developers frequently work with references or pointers to objects. The objects themselves are usually allocated on the heap, while the variables that refer to them tend to live in a different region of memory. This question checks your understanding of the typical storage location of a reference or pointer variable for a local object in common implementations. Given Data / Assumptions: We are talking about local variables declared inside a function or method. The variable in question is a reference or pointer to an object. The object itself is assumed to be dynamically allocated on the heap in the common case. We are interested in the usual implementation model for mainstream compilers and virtual machines. Concept / Approach: In typical C++ implementations, local variables inside a function, including pointer variables and reference variables, are stored in the function's stack frame. The stack frame holds parameters, return addresses, and local variables. When you allocate an object with new, the storage for that object comes from the heap, but the pointer variable that points to it remains on the stack. Similarly, in Java, local reference variables that refer to objects are stored in the stack frame of the currently executing method, while the actual objects live on the heap managed by the garbage collector. This separation between where the object is stored and where the reference is stored is a key concept. Step-by-Step Solution: Step 1: Consider a simple C++ function that declares int *p and then assigns p = new int;. Step 2: The new int expression allocates an integer in the heap memory region, which persists beyond the lifetime of the function if not deleted. Step 3: The pointer variable p itself is a local variable that resides in the function's stack frame and is automatically cleaned up when the function returns. Step 4: Translate this idea to Java, where MyClass obj = new MyClass(); creates an object on the heap, and the reference variable obj is stored in the current stack frame. Step 5: From these examples, conclude that the reference or pointer variable is typically stored on the stack frame, not on the heap with the object. Verification / Alternative check: Debuggers and low level tools can confirm this model. When you inspect a running program with a debugger, you will see local pointer or reference variables listed in the stack frame display, while heap allocated objects are shown in separate memory views. Documentation for Java also describes that local variables and reference variables are stored on the stack, and only the actual objects and arrays are placed on the heap. These observations align with the idea that the reference itself is on the stack frame of the function or method. Why Other Options Are Wrong: Option On the heap together with the object: While the object is on the heap, the local variable that references it is not stored inside the object but in the stack frame. Option In a queue data structure: A queue is an abstract data structure and not a standard memory region used by compilers to store local variables. Option None of these are generally correct: This is incorrect because the stack frame is precisely where local reference variables are commonly stored. Common Pitfalls: A common misunderstanding is to assume that because an object is created on the heap, the reference variable itself must also be on the heap. Another pitfall is to confuse the term reference with the underlying memory location. It is important to separate the concept of an object's lifetime from the storage class of the variable that refers to it. Local references or pointers have automatic storage duration on the stack, while the objects they refer to may outlive the function and be managed separately on the heap. Final Answer: In typical C++ and Java implementations, a local reference or pointer variable is stored On the stack frame of the function.

Question 9

How does variable declaration in C++ differ from traditional C (before C99) with respect to where inside a block variables may be declared?

Accepted Answer

Introduction / Context: The rules for where variables can be declared in a block are slightly different between traditional C and C++. This difference often appears in interview questions, because it affects coding style, readability, and how easily developers can introduce variables close to where they are used. Knowing the historical distinction helps you understand older C code and appreciate the more flexible style encouraged in C++ and modern C standards. Given Data / Assumptions: We are comparing classic C (for example C89) with C++. The focus is on the position of variable declarations inside a function or compound statement. Global and file scope declarations are not the main concern here. We assume pre C99 C rules, which are stricter than modern C in this regard. Concept / Approach: In traditional C (such as C89), all variable declarations inside a block had to appear before any executable statements. That means you would typically see a cluster of declarations at the top of a function or code block, followed by the statements that use those variables. C++ relaxed this rule and allows variables to be declared at any point in a block, as long as they are declared before they are used. This allows declarations to be placed closer to their first use, which can make code easier to read and maintain. Modern C (C99 and later) adopted similar flexibility, but many exam questions still refer to the original C89 behaviour when contrasting with C++. Step-by-Step Solution: Step 1: Recall that in older C standards, a function body begins with a series of declarations followed by statements, and declarations cannot appear after statements in the same block. Step 2: Recognise that this forces programmers to declare all local variables at the top of a function or block, even if they are used only in a narrow portion of the code. Step 3: In C++, the language standard explicitly allows you to introduce a new variable at almost any point in a block as long as it is declared before its first use. Step 4: This means you can write a loop or conditional and declare variables directly inside those structures, which improves locality and clarity. Step 5: Comparing these behaviours, the correct description is that C++ allows declarations anywhere in the block, whereas classic C requires them at the beginning. Verification / Alternative check: Consider a small example. In C++, code such as for (int i = 0; i < n; ++i) { int temp = compute(i); use(temp); } is valid and idiomatic. In C89, declaring int temp inside the body after other statements would not be allowed; instead, you would need to declare temp at the top of the block before any statements. This practical example shows how C++ rules are more flexible and confirms the difference described in the correct option. Why Other Options Are Wrong: Option B: Reverses the roles of C and C++ and therefore does not match the actual language rules. Option C: Claims that both languages require all variables to be global, which is false because both languages support local variables inside functions. Option D: States there is no difference, which ignores the well known historical distinction between traditional C and C++ variable declaration placement. Common Pitfalls: A common pitfall is to forget that C99 changed the rules for C, allowing mixed declarations and code similar to C++. Because of this, some learners think there has never been any difference. Exam questions, however, often specifically refer to classic C behaviour. Another mistake is to think that placing declarations anywhere is always best; while it can improve clarity, overusing this freedom can also make code harder to scan. The key point for this question is simply the historical rule: C++ allowed declarations anywhere in a block from the beginning, whereas older C required them at the top. Final Answer: In summary, C++ allows variables to be declared anywhere inside a block, while C requires declarations at the beginning of a block in the traditional standard.

Question 10

In C++ object oriented programming, what is a friend function of a class?

Accepted Answer

Introduction / Context: Friend functions are a unique feature of C++ that relate to the encapsulation and access control system. Normally, private and protected members of a class cannot be accessed from outside the class except by member functions and friends. Declaring a function as a friend of a class is a deliberate step taken by the class designer to allow that function to bypass normal access restrictions. This question checks whether you can correctly describe what a friend function is and how it relates to class membership. Given Data / Assumptions: The language is C++. We are dealing with the concept of friend functions and not friend classes. We assume standard access rules: private and protected members are not visible to unrelated external functions. Friendship is explicitly granted inside the class definition using the friend keyword. Concept / Approach: A friend function is not a member of the class, but it is declared inside the class with the keyword friend. This declaration tells the compiler that the function should be allowed to access the class's private and protected data members, just like a member function can. The function itself is usually defined outside the class, and it is called like any other regular function, not with member access syntax. The key point is that friendship provides a controlled way to break encapsulation when needed, for example for operator overloading or helper functions that need intimate knowledge of a class's internals. Step-by-Step Solution: Step 1: Recall that class members can be private, protected, or public, and that private and protected members are normally hidden from non-member functions. Step 2: Remember that the keyword friend can appear in a class definition to declare that a particular external function is a friend of the class. Step 3: Understand that a friend function does not become a member of the class; it remains a normal function, but with special access rights. Step 4: Note that the friend function is allowed to read or modify private and protected members of the class, which is the main reason for granting friendship. Step 5: Compare the options and choose the one that states that a friend function is a non-member function with access to private and protected members. Verification / Alternative check: A typical example is overloading the stream insertion operator for a class. You might write a function like ostream and operator<<(ostream and os, const MyClass and obj), and declare it as a friend inside MyClass. This function is not a member of MyClass, but it needs access to private fields for printing. Declaring it as a friend gives it that access. This common pattern confirms that a friend function is external to the class but granted special access privileges. Why Other Options Are Wrong: Option A member function that can only be called by objects of the same class: This describes neither friend functions nor any standard access control concept. Option A function defined inside main that can access all global variables: Any function can access global variables in scope, and this has nothing to do with friendship. Option Any function that is overloaded more than once: Overloading has no inherent relationship with the friend keyword or access rights. Common Pitfalls: One common mistake is to think that friend functions are members of the class, which leads to confusion about how they are called. Another pitfall is to overuse friendship and break encapsulation unnecessarily, which can make code harder to maintain. A good design uses friend functions sparingly and only when there is a clear need for an external function to access private implementation details. Understanding this balance is important for writing clean C++ code. Final Answer: A friend function in C++ is A non-member function that is granted access to the private and protected members of a class.

Question 11

What is the output of the following C++ program using a struct and a pointer to the struct? #include using namespace std; struct sec { int a; char b; }; int main() { sec s = {25, 50}; sec *ps = &s; cout << ps->a << …

Accepted Answer

Introduction / Context: This question presents a small C++ program that defines a struct, initialises its members, and then prints them using a pointer to the struct. Understanding the output requires knowledge of how aggregate initialisation works, how characters are represented using ASCII codes, and how the stream insertion operator prints different types. The code looks simple, but the subtlety lies in interpreting the integer value assigned to the char field and how it appears in the output. Given Data / Assumptions: The struct sec has two members: an int named a and a char named b. The variable s is initialised as s = {25, 50}, so a receives 25 and b receives the character with code 50. The pointer ps points to s and is used with the arrow operator to access the fields. The line cout << ps->a << ps->b; prints the integer followed by the character with no spacing or newline in between. Concept / Approach: In C++, when you initialise a struct with a brace enclosed list, the values are assigned to members in the order of declaration. Thus, s.a becomes 25 and s.b becomes the character whose numeric code is 50. In the ASCII character set, the decimal code 50 corresponds to the character digit 2. The expression ps->a yields the integer 25, and ps->b yields a char with value 50, which is printed as the character 2 by cout. Therefore the stream outputs the characters representing 25 followed by the character 2, all concatenated without any spaces. Step-by-Step Solution: Step 1: Identify the struct definition: sec contains int a and char b. Step 2: Apply aggregate initialisation sec s = {25, 50}; which assigns 25 to a and 50 to b. Step 3: Remember that assigning 50 to a char does not store the digits five and zero, but rather the character with ASCII code 50. Step 4: Look up or recall that ASCII code 50 corresponds to the character digit 2. Step 5: Evaluate cout << ps->a << ps->b; which prints the integer 25 as the characters 2 and 5, and then prints b as the character 2, yielding the combined output 252. Verification / Alternative check: You can verify this reasoning by writing a small test program that prints static_cast(b) alongside b. Doing so would show that b has the numeric value 50 while displaying as the character 2 when streamed to cout. Since ps->a prints as 25 and ps->b prints as 2, the concatenation in the output stream must be 252. Trying other ASCII codes in similar examples reinforces the idea that cout treats chars as characters, not as their numeric codes, unless you explicitly cast them to an integer type. Why Other Options Are Wrong: Option 253: This would imply that the char with code 50 prints as 3, which is incorrect because ASCII code 51 corresponds to the character 3, not 50. Option 254: This would match a scenario where b had ASCII code 52, which corresponds to the character 4, but in the program b is initialised with 50. Option 262: This suggests that b prints as 2 but that the tens digit of a has changed from 2 to 6, which does not match any operation in the code. Common Pitfalls: Learners sometimes confuse the numeric literal used in initialisation with the actual characters printed. Assigning 50 to a char does not print 50, it prints the character that has that numeric code in the character set. Another pitfall is to forget that cout uses different overloads of the insertion operator for int and char, so chars are treated as characters by default. To see the numeric value, you must cast the char to int explicitly. Keeping these behaviour details in mind avoids many small bugs and helps in solving questions like this one quickly. Final Answer: The program prints the integer 25 followed by the character whose code is 50, which is 2, so the final output is 252.

Question 12

When declaring a function pointer in C or C++, which of the following is mandatory to specify so that the pointer type is correctly defined?

Accepted Answer

Introduction / Context: Function pointers in C and C++ allow programs to store the address of a function in a variable and call that function indirectly through the pointer. This is widely used for callbacks, event handlers, and implementing tables of functions. In order to declare a function pointer correctly, you must specify its type so that the compiler knows which functions are compatible with that pointer. This question focuses on the essential type information that must be included in a function pointer declaration. Given Data / Assumptions: The language is C or C++. We are declaring a pointer that can point to functions. We want to know what parts of the function type are mandatory in the pointer declaration. Symbolic details such as ampersands or actual runtime return values are potential distractors. Concept / Approach: A function pointer type is determined by the function's return type and the types of its parameters. For example, int (*fp)(double, char) is a pointer to a function that returns an int and takes a double and a char as arguments. The ampersand symbol is not required in the declaration, because the function name in an expression automatically decays to a pointer to the function. The pointer declaration therefore must show the correct return type and parameter type list so that the compiler can enforce type safety when the function pointer is assigned or called. Step-by-Step Solution: Step 1: Recall that a typical function prototype looks like int f(double x, char c); where int is the return type and double and char are parameter types. Step 2: For a pointer to that function, you might write int (*pf)(double, char); which mirrors the return type and parameter type list. Step 3: Notice that the declaration does not use the ampersand symbol on the function name; the parentheses around *pf are used to indicate that pf is a pointer variable, not the function itself. Step 4: Understand that actual return values, such as specific integers that a function returns at runtime, are not part of the type and are irrelevant to the pointer declaration. Step 5: Conclude that the mandatory information for the function pointer type is the return type and the parameter types, which fully describe the function signature. Verification / Alternative check: You can check this by trying to assign a function with a different signature to the pointer. For example, if pf is declared as int (*pf)(double, char) and you attempt to assign a function that returns void or takes different parameter types, the compiler will emit a type mismatch error or warning. This confirms that the pointer type is defined entirely by the return type and parameter list, and that these data types are mandatory in the declaration. The ampersand operator is used when taking the address explicitly, but not required in the type specification. Why Other Options Are Wrong: Option Ampersand symbol before the function name: The ampersand operator is optional when taking the address of a function, since the function name by itself converts to a pointer; it is not a required part of the type declaration. Option Actual return values of the function: Concrete values returned at runtime are not part of the function type and are irrelevant when declaring pointers. Option None of these are necessary: This is incorrect because omitting return and parameter types would leave the pointer type undefined, which modern compilers do not allow. Common Pitfalls: Students frequently confuse the syntax for declaring function pointers with ordinary pointer declarations and may forget to include the parameter list. Another pitfall is thinking that using the ampersand symbol is mandatory whenever functions and pointers are involved, which it is not. A clear mental model that a function pointer type is defined by the same information as the function prototype, minus the function name, helps avoid errors in both exams and real projects. Final Answer: To declare a function pointer correctly, you must specify Return type and parameter types (data types) in the pointer declaration.

Question 13

What is the output of the following C++ program that calls a function through a function pointer?  #include <iostream> using namespace std;  int n(char c, int i);  int (*p)(char, int) = n;  int main() {     (*p)('d', 9);     p('d', 9);     return 0;…

Accepted Answer

Introduction / Context: This program demonstrates the use of a function pointer in C++ to call a function in two different ways. It is a common style of interview question because it checks your understanding of function pointer syntax, how function names relate to pointers, and what actually gets printed when the function is called through the pointer. The code calls the same function twice, so recognising that both calls produce the same output is key to answering correctly. Given Data / Assumptions: The function n takes a char and an int, prints them using cout, and returns an int. A function pointer p of type int (*)(char, int) is initialised with the address of n. In main, the function is invoked first as (*p) with arguments and then as p with arguments. We assume that the program compiles successfully without errors. Concept / Approach: In C++, a function name such as n can decay to a pointer to the function, and assigning n to a function pointer p with the correct type is allowed. Calling a function through a pointer can be done using either the explicit dereference syntax (*p)(arguments) or simply p(arguments); both forms are equivalent. Each call to n prints the character argument followed by the integer argument with no space between them. Since the same arguments are used in both calls, the two outputs are identical and appear back to back in the output stream. Step-by-Step Solution: Step 1: Examine the function prototype: int n(char c, int i). The function prints c and i and then returns 0. Step 2: Look at the pointer declaration int (*p)(char, int) = n; which creates a pointer to a function with the same signature and assigns it the address of n. Step 3: In main, the first call is (*p)('d', 9); which invokes n with c equal to the character d and i equal to 9, so it prints the character d followed by the digit 9, giving d9. Step 4: The second call p('d', 9); is simply a shorter syntax for dereferencing the pointer and calling the same function with the same arguments, so it again prints d9. Step 5: Because the two outputs are concatenated with no spaces or newlines, the final result on the screen is d9d9. Verification / Alternative check: You can verify that (*p)(...) and p(...) are equivalent by consulting C++ language references, which state that both forms are valid and call the function pointed to by p. If you modify the function body to insert a marker before the print, such as printing a symbol each time n is entered, you will see that n is entered twice. This confirms that the function executes twice with the same arguments, and therefore prints the same d9 sequence two times, yielding d9d9 overall. Why Other Options Are Wrong: Option d99: This would suggest that only one d is printed and that the two integers are combined into 99, which does not match the function body that prints c and i each time in order. Option d9: This output corresponds to only one call to n, but the code clearly calls the function twice. Option compile time error: The code uses correct function pointer syntax and a matching signature, so there is no reason for a compilation failure under standard C++ rules. Common Pitfalls: Some learners mistakenly believe that you must always dereference a function pointer explicitly and think that p(arguments) is not allowed, which can lead them to predict an error incorrectly. Others forget that the function is called twice and therefore only account for one d9 sequence. Another source of confusion is mixing up the type of the pointer and the arguments; however, in this example they match exactly, so the code behaves in a straightforward way. Careful reading and stepwise tracing of each call help avoid these mistakes. Final Answer: The program prints d9 for each of the two calls to n, so the complete output is d9d9.

Question 14

In C and C++, which preprocessor directive keyword is used to define macros?

Accepted Answer

Introduction / Context: Macros are a feature of the C and C++ preprocessor that allow developers to define symbolic names or parameterised snippets of code that are expanded before compilation. They are widely used for constants, conditional compilation, and simple code generation. To define a macro, you must use a specific preprocessor directive. This question checks whether you know the exact keyword and syntax used for macro definition. Given Data / Assumptions: The context is the C or C++ preprocessor, which runs before the compiler. Macros can be object-like (simple replacement) or function-like (parameterised). We are focusing on the directive used to introduce a macro definition. Spelling and the presence of the hash symbol character are important. Concept / Approach: In C and C++, preprocessor directives begin with a hash symbol at the start of the line. The directive used to define macros is #define. It is followed by the macro name and optionally by a replacement list or parameter list. For example, #define PI 3.14159 defines a constant-like macro, and #define SQR(x) ((x) * (x)) defines a function-like macro. The word define by itself is not recognised as a directive unless it is preceded by the hash symbol, and macro is not a keyword in the language. Step-by-Step Solution: Step 1: Recall that all preprocessor directives start with the hash character at the beginning of a line. Step 2: Identify the directive used for macro definitions, which appears in examples as #define MACRO_NAME value. Step 3: Recognise that the hash symbol is part of the directive keyword and cannot be omitted. Step 4: Compare the options and see that #define matches the known directive exactly, including the hash symbol. Step 5: Confirm that neither macro nor define alone are valid directives in C or C++ source code. Verification / Alternative check: If you write a small program and use define without the hash symbol, the compiler will treat it as an identifier, not as a directive, leading to compilation errors. However, when you use #define at the start of a line, the preprocessor recognises it and replaces occurrences of the macro name according to the definition. This behaviour can be tested easily and matches the explanation that #define is the correct keyword for macro definition. Why Other Options Are Wrong: Option macro: This word looks descriptive but is not a reserved keyword and has no special meaning to the preprocessor. Option define: Without the hash symbol, define is just an identifier and not a preprocessor directive. Option none of these: This is incorrect because #define is a standard and widely used directive in C and C++. Common Pitfalls: A common mistake is to forget the hash symbol, especially when first learning preprocessor directives. Another pitfall is to rely heavily on macros for tasks better handled by const variables or inline functions in C++, which can lead to harder to debug code. Nevertheless, knowing the basic syntax of #define is important for understanding legacy code and conditional compilation patterns. Final Answer: The keyword used in C and C++ to define macros is #define.

Question 15

In C and C++, how many basic types of preprocessor macros are commonly described (object-like macros and function-like macros)?

Accepted Answer

Introduction / Context: Macros in C and C++ provide a powerful but simple textual substitution mechanism through the preprocessor. When learning about macros, textbooks usually classify them into a small number of basic types. Being familiar with this classification helps you understand how different macro definitions behave and what kind of arguments they accept. This question asks for the number of commonly described macro types and implicitly expects you to know what they are. Given Data / Assumptions: The language is C or C++ with a standard preprocessor. We are interested in basic macro categories, not every possible usage pattern. The two best known categories in textbooks are object-like macros and function-like macros. We assume the usual terminology used in compiler documentation and teaching materials. Concept / Approach: Object-like macros behave like simple symbolic names. They do not take arguments and are replaced by a constant or an expression. An example is #define MAX_VALUE 100. Function-like macros, on the other hand, take parameters and resemble function calls in their usage: #define SQR(x) ((x) * (x)). When the preprocessor encounters SQR(5), it expands it according to the replacement list. Although there are many ways to combine macros with conditional directives, concatenation, and stringisation, the core classification is into these two basic types. Therefore, the number of basic macro types commonly described is two. Step-by-Step Solution: Step 1: Recall the definition of an object-like macro as a simple name replacement without parameters. Step 2: Recall the definition of a function-like macro as a macro that includes a parameter list in its definition and is invoked with arguments. Step 3: Recognise that most educational resources group macros into these two categories. Step 4: Count these categories: object-like and function-like, which yields a total of two basic types. Step 5: Choose the option that corresponds to this count, which is 2. Verification / Alternative check: Looking at official documentation for compilers or the C standard, you will find that the syntax for macro definitions distinguishes between definitions with and without parameter lists. Practical examples of macros in real code also fall into these two groups: constant style macros and parameterised expression macros. While there are many macros in large codebases, they usually conform to one of these two base forms, reinforcing the idea that two is the correct number of primary macro types. Why Other Options Are Wrong: Option 1: Suggests there is only one macro type, which ignores the clear syntactic difference between macros with and without parameters. Option 3: Implies a third standard macro category that is not generally recognised in the basic classification. Option 4: Overstates the number of macro types and does not match standard teaching material. Common Pitfalls: Learners sometimes confuse macro types with other preprocessor features such as conditional compilation or include directives, leading them to think there are many more categories. Another pitfall is to misuse function-like macros for complex expressions without proper parentheses, which can cause subtle bugs. Knowing that there are two basic macro shapes helps keep reasoning about preprocessor behaviour clear while encouraging the use of safer alternatives such as constants and inline functions in modern C++. Final Answer: There are 2 basic types of macros commonly described in C and C++: object-like and function-like macros.

Question 16

In C++, what is the primary purpose of using namespaces in a program?

Accepted Answer

Introduction / Context: Namespaces are a core feature of C++ that help manage the complexity of large programs and libraries. As code bases grow, the risk of name collisions between functions, classes, and variables from different modules increases. Namespaces provide a mechanism to group related identifiers and to control how they are made visible. This question focuses on the main motivation for using namespaces in everyday C++ development. Given Data / Assumptions: The language is C++ and the feature in question is the namespace construct. We are considering typical use cases, not obscure corner cases. Encapsulation of identifiers and logical program structure are both mentioned as possible purposes. We assume familiarity with the standard namespace std as a real world example. Concept / Approach: A namespace in C++ provides a named scope for identifiers. All names defined inside the namespace are encapsulated within that namespace, which prevents conflicts with identical names defined elsewhere. At the same time, namespaces allow developers to organise code into logical units, such as grouping all library functions for a module under a single namespace name. This dual role of encapsulation and structuring is the primary reason namespaces were introduced into the language. Without namespaces, large projects would require complex naming conventions or risk frequent name clashes. Step-by-Step Solution: Step 1: Recall that a namespace is introduced with the keyword namespace followed by a name and a block of declarations. Step 2: Understand that everything declared inside the namespace is accessed using the scope resolution operator, such as mylib::Function. Step 3: Recognise that this mechanism encapsulates identifiers, because code outside the namespace must either qualify names or use directives so that they do not accidentally clash with other code. Step 4: Notice that namespaces also serve to group related functionality, making it easier to understand that certain classes and functions belong to the same logical module. Step 5: Conclude that both encapsulation and logical structuring are key purposes, so the best answer is the option that includes both. Verification / Alternative check: Consider the standard namespace std. It contains the standard library's streams, containers, algorithms, and many other components. If these names were all declared at global scope without a namespace, they would collide with user-defined identifiers far more often. The namespace groups all standard names logically together while protecting them behind the std:: qualifier. This practical example confirms that the main purpose of namespaces is both to encapsulate and to structure identifiers into coherent units. Why Other Options Are Wrong: Option To encapsulate data: This is partially correct, but it ignores the equally important role of providing a logical structure for modules and libraries. Option To structure a program into logical units: Also partially correct, but it does not explicitly acknowledge the role of namespaces in preventing name clashes. Option None of these: This is incorrect because both encapsulation and logical grouping are documented design goals for namespaces. Common Pitfalls: One pitfall is to use using namespace std in global scope in header files, which can pollute the global namespace and defeat some benefits of namespaces. Another mistake is to create many small namespaces without clear structure, which can make code harder to navigate. A disciplined use of namespaces, where each namespace meaningfully groups related code and limits name collisions, leads to cleaner and more maintainable C++ projects. Final Answer: The primary purpose of namespaces is Both a and b (encapsulation and logical grouping), that is, to encapsulate data and to structure a program into logical units.

Question 17

In C++, what is the general syntax for accessing a variable or function that is defined inside a namespace?

Accepted Answer

Introduction / Context: Once a namespace has been defined in C++, you must know how to access the names declared inside it. The language provides a specific operator for qualifying names with their namespace, which is the same operator used for qualifying class members. This question tests your familiarity with that syntax and reinforces the idea that namespaces introduce a new scope which must be explicitly referenced unless a using declaration is employed. Given Data / Assumptions: A namespace has been defined with some identifier, for example namespace mylib { int value; }. We want to access a variable or function declared inside that namespace. The options show different ways of combining the namespace identifier with the member name. We assume that no using declaration or directive is in effect to shorten the syntax. Concept / Approach: In C++, the scope resolution operator :: is used to qualify names with their enclosing scope, whether that scope is a namespace, a class, or the global namespace. To access a member of a namespace, you write namespace_id::member_name. For example, if value is declared inside the namespace mylib, you would refer to it as mylib::value. Commas or hash symbols are not used for this purpose in C++. This syntax enforces clarity by making it obvious in which namespace a particular identifier is defined. Step-by-Step Solution: Step 1: Recall that the standard library uses syntax like std::cout and std::string to access members of the namespace std. Step 2: Recognise that the pattern is namespace name, followed by the scope resolution operator ::, followed by the member name. Step 3: Apply this pattern to a generic namespace identifier namespace_id, resulting in namespace_id::member_name. Step 4: Compare this with the options and see that only one option reflects this syntax correctly. Step 5: Choose namespace_id::member_name as the correct general form. Verification / Alternative check: You can verify this by writing a small program in which you define namespace test { int x = 5; } and then try to print x. If you write cout << test,x; the compiler will emit a syntax error. The correct statement is cout << test::x; which compiles and runs as expected. This direct experiment confirms that the scope resolution operator :: is the appropriate way to access namespace members. Why Other Options Are Wrong: Option namespace,member_name: The comma has no special meaning in C++ for scope qualification and would not compile. Option namespace#member_name: The hash symbol is used for preprocessor directives, not for namespace member access, so this syntax is invalid. Option none of the mentioned: This is incorrect because namespace_id::member_name is a valid and standard C++ syntax. Common Pitfalls: One common mistake is forgetting the namespace qualification and relying too heavily on using directives, which can lead to name clashes and ambiguity in larger projects. Another pitfall is to mix up the member access operator . or the pointer member access operator -> with ::, which is reserved specifically for scopes like namespaces and classes. Remembering the pattern used by std::cout is usually enough to keep the namespace syntax straight. Final Answer: The general syntax for accessing a name inside a namespace is namespace_id::member_name.

Question 18

For user-defined header files in C and C++, which file extension is most commonly used in source code examples such as #include "myheader.h"?

Accepted Answer

Introduction / Context: Header files in C and C++ are used to declare functions, classes, and other interfaces that can be shared across multiple source files. The naming convention for header files, especially user-defined ones, often includes a particular file extension. This question asks you to identify the most commonly used extension when you see examples like #include "myheader.h" in textbooks and code samples. Given Data / Assumptions: We are dealing with user-created header files, not necessarily system headers. #include "file" syntax is used, which usually refers to a local or project header file. We are interested in the conventional extension used in many C and C++ examples. Alternative extensions such as .hpp or .hh exist, but the question focuses on the most common classic form. Concept / Approach: Historically, C programs have used the .h extension for header files, and this convention carried over into C++ as well. While C++ projects sometimes use .hpp or similar extensions to distinguish C++ headers from pure C headers, the simple .h suffix remains very widespread, especially in teaching material and mixed language code bases. When you see tutorial examples like #include "myheader.h", the .h extension is used to mark user-defined header files that contain declarations to be shared. Therefore, among the options given, .h is the most appropriate answer. Step-by-Step Solution: Step 1: Recall that standard C headers are things like stdio.h and math.h, which clearly use the .h extension. Step 2: Note that many user-defined headers in tutorials are named with the same convention, for example mylib.h or utilities.h. Step 3: Recognise that .cpp is commonly used for C++ source files, not header files. Step 4: Observe that .hf is not a standard or widely used extension in C or C++ projects. Step 5: Choose .h as the conventional extension for user-defined headers in classic examples. Verification / Alternative check: You can quickly verify this by browsing existing open source C and C++ projects. You will see many header files ending in .h and source files ending in .c or .cpp. Some modern C++ projects indeed use .hpp, but that extension is not among the options in this question. Additionally, most textbooks and exam questions that show simple #include "header" syntax use .h, confirming it as the most recognisable answer here. Why Other Options Are Wrong: Option cpp: This extension is associated with C++ source files that are compiled directly, not header files included by other files. Option hf: This is not a standard or commonly adopted extension in C or C++ development. Option none of these: This is incorrect because .h is widely used and clearly fits the example given in the question. Common Pitfalls: Learners sometimes think that any file used in a project can have any extension, which is technically possible but breaks conventions and tooling expectations. Another pitfall is to confuse .cpp and .h, especially when organising project structures. Following conventional naming patterns, such as pairing file.cpp with file.h, makes it easier for other developers, build systems, and editors to understand and work with the code. For exams, remembering that .h is the classic header extension is usually sufficient. Final Answer: The most commonly used extension for user-defined header files in examples like #include "myheader.h" is h.

Question 19

In C++, what is an inline function and why is it used by the compiler?

Accepted Answer

Introduction / Context: Inline functions in C++ were introduced as a way to suggest to the compiler that the overhead of a function call might be avoided by substituting the function body directly at the call site. This can be especially beneficial for very small, frequently called functions such as accessors or simple arithmetic helpers. However, the inline keyword is ultimately only a request, and modern compilers perform their own inlining decisions. This question asks you to identify the correct conceptual description of an inline function. Given Data / Assumptions: The language is C++. We are focusing on the inline keyword and the idea of inlining functions. The question is about the semantics and purpose of inline, not about storage or threading. We assume common compiler behaviour where inline is primarily an optimisation and linkage hint. Concept / Approach: An inline function is one for which the compiler may replace a call with the function's body during compilation. This replacement can eliminate the overhead associated with setting up a stack frame, passing arguments, and jumping to another address. In practice, modern optimisers decide which functions to inline based on cost models, whether or not they are marked inline. The keyword inline also affects linkage and allows functions to be defined in header files without violating the one definition rule, as long as every definition is identical. The key idea, however, remains that inline functions are candidates for call site expansion. Step-by-Step Solution: Step 1: Recall that the typical syntax is inline int add(int a, int b) { return a + b; } or a definition inside a class body, which is implicitly inline. Step 2: Understand that the compiler is allowed to substitute the function body wherever add is called, instead of generating an actual call instruction. Step 3: Recognise that this potential expansion can improve performance for small, simple functions, especially in tight loops. Step 4: Compare the options and identify the one that captures the concept of call site expansion and reduced overhead. Step 5: Choose the option that states that an inline function is one whose body may be expanded at each call site. Verification / Alternative check: You can verify the effect of inlining by compiling a small program with optimisation enabled and inspecting the generated assembly. Functions defined as inline or inside a header and called frequently may not appear as distinct call instructions; instead, their logic is embedded directly within callers. However, it is important to note that the compiler can inline functions even without the inline keyword and can ignore the keyword if it decides inlining is not profitable. This confirms that inline is primarily a hint and a linkage feature, not an absolute command. Why Other Options Are Wrong: Option A function stored only in an external library file: Storage location in a library is unrelated to the inline keyword. Option A function that can be called only from inside the same class: That describes concepts like private member functions or possibly static member functions, not inline semantics. Option A function that always runs in a separate thread: Threading is controlled by libraries and system calls, not by the inline keyword. Common Pitfalls: A common misunderstanding is to believe that marking a function inline guarantees inlining, which is not true in modern compilers. Another pitfall is to inline very large functions manually, which can increase code size and harm instruction cache performance. The best practice is to reserve inline for small, performance critical functions and to trust the compiler optimisation passes. For exam purposes, remembering that inline functions may have their bodies expanded at call sites is the key idea. Final Answer: An inline function is A function whose body may be expanded at each call site by the compiler to avoid function call overhead.

Question 20

In C++ classes, the special member function that is invoked automatically whenever an object goes out of scope or is explicitly deleted is called what?

Accepted Answer

Introduction / Context: Resource management is a crucial responsibility in C++ programming. When an object is created, its constructor initialises any necessary resources. When the object is destroyed, another special member function is responsible for cleaning up those resources. This automatic cleanup is a central part of the RAII (Resource Acquisition Is Initialisation) idiom in C++. The question asks you to identify the name of the special member that runs when an object goes out of scope or is explicitly destroyed. Given Data / Assumptions: The language is C++. We are referring to objects of a class type. We focus on the moment when an object's lifetime ends, either through scope exit or delete. We assume standard semantics where constructors and destructors manage resources. Concept / Approach: In C++, every class can define a destructor, which is a special member function that has the same name as the class, prefixed with a tilde character. The destructor is called automatically when an automatic object goes out of scope, when a delete expression is applied to a dynamically allocated object, or when an object is destroyed as part of another object's destruction. Its purpose is to free resources such as dynamic memory, file handles, or locks. This function contrasts with the constructor, which runs at object creation time to set up the object's initial state. Step-by-Step Solution: Step 1: Recall the naming pattern: for a class named MyClass, the destructor is written as ~MyClass(). Step 2: Understand that destructors take no parameters and have no return type. Step 3: Recognise that the destructor is invoked automatically by the runtime when an object's lifetime ends, including when delete is called on a pointer to that object. Step 4: Compare this role with that of the constructor, which runs at creation time, not at destruction time. Step 5: Select Destructor as the member function that matches the description in the question. Verification / Alternative check: You can verify destructor behaviour with a simple example. Define a class whose destructor writes a message to the output stream. Create an instance of the class in a local scope and observe that the message is printed when the scope ends. Similarly, allocate an instance with new and then call delete; you will see the destructor message at the point of deletion. This experiment confirms that the destructor is the function responsible for actions performed when objects are destroyed. Why Other Options Are Wrong: Option Constructor: This is the special member that runs at object creation, not at destruction, so it does not match the description. Option Friend function: Friendship grants access privileges but does not define lifecycle callbacks; a friend function is not automatically invoked when an object goes out of scope. Option None of the above: This is incorrect because the term destructor is a standard part of C++ vocabulary for this concept. Common Pitfalls: One pitfall is to forget to define a destructor when a class manages resources, leading to resource leaks. Another is to perform overly complex logic in destructors, which can cause problems when exceptions are thrown or when objects are partially constructed. It is also important not to call destructors directly in normal code; instead, you should rely on delete and scope exit to trigger them. Understanding the destructor's role is fundamental for writing safe and efficient C++ code. Final Answer: The special member function invoked when an object goes out of scope or is deleted is the Destructor.

Technology Questions