Write a user-defined function Pop(Book B[], int T), which pops the details of a Book, from the static stack of

Question

Q. Write a user-defined function Pop(Book B[], int &T), which pops the details of a Book, from the static stack of Book B, at the location T (representing the Top end of the stack), where every Book of the stack is represented by the following structure: struct Book { int Bno; char Bname[20]; };

(OR)

For the following structure of Books in C++ struct Book { int Bno; char Bname[20]; Book *Link; }; Given that the following declaration of class BookStack in C++ represents a dynamic stack of Books: class BookStack { Book *Top; //Pointer with address of Topmost Book of Stack public: BookStack() { Top = NULL; } void Push(); //Function to push a Book into the dynamic stack void Pop(); //Function to pop a Book from the dynamic stack ~BookStack(); }; Write the definition for the member function void BookStack::Push(), that pushes the details of a Book into the dynamic stack of BookStack.

CBSECBSE Class XII Board 2019Subjective· 4mImportance★★★★★

🔒 Locked · start free trial →

You're viewing a preview — the full solution, concept, methods & PYQ mapping are locked.

Start your 14-day free trial to unlock the full solution →

Part (a)Concept understanding — Stack

The Stack: A Simple but Powerful Idea

Think about a stack of plates in a cafeteria. You place a clean plate on top. When someone needs a plate, they take the one from the top — the last one you put there. You cannot pull a plate from the middle or the bottom without causing a mess. That everyday action is the exact logic of a stack in computing.

A stack is a collection of items that follows one strict rule: the last item added is the first item removed. This is often called LIFO — Last In, First Out. The only item you can access at any moment is the one on top. To get to anything below, you must first remove everything above it.

How It Works

A stack has two fundamental operations:

Push: Add an item to the top of the stack.
Pop: Remove the item from the top of the stack.

That is all. There is no way to peek at the middle, no way to remove from the bottom. The stack only cares about what is on top.

Note

Some systems also allow a Peek operation — you look at the top item without removing it. But the core idea remains: only the top is visible.

Why Does This Matter?

You might wonder: why would anyone want such a restrictive structure? The answer is that many real-world processes naturally work this way.

Consider the Undo feature in a word processor. Every action you perform — typing a word, deleting a sentence, changing a font — is pushed onto a stack. When you press Undo, the most recent action is popped off and reversed. You cannot undo an action from an hour ago without first undoing everything that came after it. That is the stack at work.

Another example is a web browser's Back button. Each page you visit is pushed onto a stack. Clicking Back pops the current page and takes you to the previous one. You retrace your steps in reverse order — exactly LIFO.

Important

The stack is not just a data structure; it is a model for how many systems manage order and priority. Whenever you need to remember a sequence of events and later reverse through them, a stack is the natural choice. …

Part (b)Concept understanding — Stack

The Stack: A Simple but Powerful Idea

How It Works

A stack has two fundamental operations:

Push: Add an item to the top of the stack.
Pop: Remove the item from the top of the stack.

That is all. There is no way to peek at the middle, no way to remove from the bottom. The stack only cares about what is on top.

Note

Some systems also allow a Peek operation — you look at the top item without removing it. But the core idea remains: only the top is visible.

Why Does This Matter?

You might wonder: why would anyone want such a restrictive structure? The answer is that many real-world processes naturally work this way.

Important

Start your 14-day free trial to unlock the full solution →

Both alternatives implement a fundamental stack operation on the Book structure; only the storage model differs.

Part (a)

A static (array) stack: Book B[] holds the books and T is the top index (passed by reference so the change is visible to the caller). To pop, check for underflow, display the top book, then decrement T.

struct Book { int Bno; char Bname[20]; };

void Pop(Book B[], int &T) {
    if (T < 0) {                         // stack is empty
        cout << "Stack Underflow" << endl;
    } else {
        cout << "Popped: " << B[T].Bno << " " << B[T].Bname << endl;
        T--;                             // move top down
    }
}
``` …

Start your 14-day free trial to unlock the full solution →

Part (a): pop a static array stack — display B[T] then T-- (T by reference). Part (b): push into a dynamic linked stack — new node, nb->Link = Top, then Top = nb.

Both alternatives revolve around the same LIFO idea; the difference is how memory is held and how the "top" is tracked.

Part (a)

Here the stack is an array Book B[] with an integer T (passed by reference, int &T) marking the index of the topmost element. Popping means removing the element at index T, so we first guard against an empty stack, display the top book, and then decrement T. The array data is not physically erased — the logical top simply moves down.

struct Book { int Bno; char Bname[20]; };

void Pop(Book B[], int &T) {
    if (T < 0) {                          // underflow guard (T == -1 means empty)
        cout << "Stack Underflow" << endl;
    } else {
        cout << "Popped Book Number: " << B[T].Bno << endl;
        cout << "Popped Book Name  : " << B[T].Bname << endl;
        T--;                              // new top is one below
    }
}
``` …

Start your 14-day free trial to unlock the full solution →

Same / Similar Concept — real previous-year questions on the same or a closely similar concept, not this exact question.

CBSE 2023Set 91/11 markMCQ
$Q. Q. 17 and 18 are Assertion (A) and Reasoning (R) based questions. Mark the correct choice as$
(a) Both (A) and (R) are true and (R) is the correct explanation for (A).
(b) Both (A) and (R) are true and (R) is not the correct explanation for (A).
(c) (A) is true but (R) is false.
(d) (A) is false but (R) is true. Assertion (A): A stack is a LIFO structure. Reason (R): Any new element pushed into the stack always gets positioned at the index after the last existing element in the stack.
›Reveal solutionSolution

A stack is indeed LIFO, but the reason given confuses implementation detail (index positioning) with the defining principle (last-in, first-out access), so both are true yet the reasoning does not explain the assertion.

A stack is one of the most elegant data structures in computer science, defined entirely by how you interact with it rather than how it is built underneath. The assertion calls it a LIFO structure—Last In, First Out—which captures the essence perfectly. Imagine a stack of plates: you add a new plate on top, and when you need one, you take from the top. The last plate you placed is the first one you remove. That access discipline, that rule of engagement, is what makes a stack a stack.

The reason statement shifts the conversation to implementation. It says that when you push a new element, it gets positioned at the index after the last existing element. This is true if you implement a stack using an array or list, where elements occupy consecutive indices and the "top" pointer advances with each push. But here is the subtle disconnect: the LIFO nature of a stack is not because elements are stored sequentially in memory. LIFO is a logical property, a contract about the order of retrieval. You could implement a stack with a linked list where elements are scattered across memory, each pointing to the one below it, and it would still be LIFO. The sequential indexing is an artifact of one common implementation, not the reason the structure behaves as last-in, first-out.

Note

The defining characteristic of a stack is the restriction on access—only the top element is reachable for removal. Whether that top is tracked by an index, a pointer, or any other mechanism is secondary. …

Start your 14-day free trial to see the full solution →

Q.Write a user-defined function Pop(Book B[], int &T), which pops the details of a Book, from the static stack of Book B, at the location T (representing the Top end of the stack), where every Book of the stack is represented by the following structure: struct Book { int Bno; char Bname[20]; };

Part (a)

🎓Unlock everything free for 14 days

Unlock everything free for 14 days