Adding a Constructor to `ch_stack` (Exercise)

Objective: Add a constructor to the class ch_stack based on a supplied function prototype.

What you are building

In this module you’ve been constructing a dynamically sized stack. In earlier lessons you added constructors for capacity and copying. In this exercise, you’ll add a string-initializing constructor so a stack can be created directly from a C-string.

Prototype to implement

Use the following prototype to add a constructor for ch_stack:

ch_stack::ch_stack(const char* c);

Expected behavior

The constructor receives a null-terminated C-string (const char*).
It initializes the internal stack storage from the characters in that string.
It should be safe when c is nullptr (treat as an empty initialization).
It must not write past the stack’s allocated capacity.

Implementation notes (C++23 best practices)

Prefer nullptr over NULL.
If your ch_stack stores characters in a buffer, compute the input length with std::strlen (guarding against nullptr), then copy only what fits.
In modern C++, consider offering an overload that accepts std::string_view in addition to const char*. (Keep the required prototype for this exercise.)

Design note: inheritance pitfalls

This module focuses on class construction and ownership, but design still matters. A common OO mistake is choosing inheritance where composition is required. For example, a Stack is not generally a subtype of a List if the list interface allows operations (like inserting in the middle) that violate stack semantics.

A Stack is not a kind-of List (if List allows insertion in the middle and Stack does not).
A ListOfApples is not a kind-of ListOfFruit (if any Fruit can be added to ListOfFruit).

The following relationships may or may not be valid depending on the contracts involved:

A Circle may not be a kind-of Ellipse.
An Ostrich may not be a kind-of Bird.
An Integer may not be a kind-of RationalNumber.

Submit your solution

Next, the exercise result page will display your submission and (optionally) provide guidance on the constructor’s correctness and edge cases (such as nullptr input and capacity limits).