Project 4.10 Section 4 ⚡ Embedded Relevance: Core pop_back() insert() ETL Zero-Heap Deterministic Timing

4.10 pop_back(), insert() Cost & Zero-Heap Embedded Template Library (ETL) Containers

Executive Summary: Practicing vector modification operations: push_back, pop_back, and insert. We examine the O(N) element shifting cost of mid-vector insertions and demonstrate how the Embedded Template Library (ETL) delivers STL-like containers with zero heap allocations.

💻 1. Annotated Source Code

#include <iostream>
#include <string>
#include <vector>
using namespace std;

int main() {
	vector<string> names;

	names.push_back("Alice");
	names.push_back("Bob");
	names.push_back("Charlie");
	names.push_back("Diana");
	names.push_back("Eddie");

	names.insert(names.begin() + 2, "John Baugh");
	names.pop_back();  

	for (const string& name : names) {
		cout << name << endl;
	}

	return 0;
}

📐 2. Architecture & UML Class Model

📐 Vector Population & Accumulator Pipeline Model

+ Public - Private # Protected

<<compilation-unit>> VectorPracticeEngine Vector Pipeline

Attributes / Data Members

-numberList : std::vector<double>

Operations / Methods

+populateFromUser() : void

+computeStatistics(mean: double&, maxVal: double&) : void

📚 3. Core C++ Concepts Deep-Dive

1. `pop_back()` vs `insert()` Complexity

pop_back(): Destroys the last element in $O(1)$ constant time without shrinking capacity.
insert(pos, val): Shifts all trailing elements one position to the right ($O(N)$ time complexity).

⚡ 4. Embedded Systems & Hardware Reality

1. The Embedded Template Library (ETL)

The Embedded Template Library (ETL) is an open-source C++ library specifically designed for microcontrollers. It mirrors C++ STL containers (etl::vector, etl::list, etl::queue) but uses statically allocated internal storage, completely eliminating dynamic heap allocations.

💡 5. Production-Ready Embedded Refactoring

Deterministic ETL fixed-capacity vector usage:

💡 Production-Ready Refactor

#include <cstdint>
// Conceptually equivalent to etl::vector<uint32_t, 10>
template <typename T, size_t MAX_SIZE>
class EtlVectorDemo {
    T storage_[MAX_SIZE];
    size_t current_size_{0};

public:
    bool push_back(const T& item) noexcept {
        if (current_size_ >= MAX_SIZE) return false;
        storage_[current_size_++] = item;
        return true;
    }

    void pop_back() noexcept {
        if (current_size_ > 0) --current_size_;
    }

    size_t size() const noexcept { return current_size_; }
};

📝 Knowledge Verification Quiz

Test your understanding of the C++ concepts and embedded microcontroller trade-offs covered in this guide. Click any option for instant feedback.

Q1. What is the time complexity of inserting an element at the beginning of a std::vector?

A O(N) linear time because all existing elements must be shifted one slot to the right

B O(1) constant time

C O(log N) logarithmic time

D O(N^2) quadratic time

Detailed Explanation: Inserting at index 0 requires moving every existing element one index forward in memory to make room, taking $O(N)$ operations.

Q2. Does calling vector::pop_back() reduce the vector's heap memory capacity?

A No, pop_back() decrements size and destroys the element, but capacity remains unchanged

B Yes, it frees memory immediately

C Yes, it reallocates a smaller buffer

D It deletes all elements

Detailed Explanation: pop_back() only reduces size(); the allocated memory capacity() remains intact to avoid reallocation overhead on future insertions.

Q3. Why is the Embedded Template Library (ETL) widely adopted in automotive and medical device firmware?

A It provides STL-like containers that allocate all storage statically inside the object, guaranteeing zero heap fragmentation and deterministic execution

B It automatically generates microcontroller PCB layouts

C It replaces the C++ compiler

D It requires no CPU clock

Detailed Explanation: ETL provides standard container interfaces with fixed-capacity stack/static storage, meeting MISRA and safety-critical deterministic memory requirements.

Q4. Which method removes all elements from a vector while preserving its allocated capacity?

A .clear()

B .shrink_to_fit()

C .pop_back()

D .erase()

Detailed Explanation: vec.clear() resets the size to 0 and invokes destructors for all elements, but retains the allocated capacity buffer.