[Term Entry] C++ Queue: emplace()

content/cpp/concepts/queues/terms/emplace/emplace.md

@@ -0,0 +1,142 @@
+---
+Title: 'emplace()'
+Description: 'Constructs a new element at the end of the queue in-place using forwarded arguments.'
+Subjects:
+  - 'Code Foundations'
+  - 'Computer Science'
+Tags:
+  - 'Containers'
+  - 'Methods'
+  - 'Queues'
+CatalogContent:
+  - 'learn-c-plus-plus'
+  - 'paths/computer-science'
+---
+
+The **`emplace()`** method of the `std::queue<T,Container>` container adaptor constructs a new element directly in the underlying container at the back of the queue, forwarding the provided arguments to the constructor of `T`. Because the object is constructed in place, this can improve performance for types with expensive copy or move operations.
+
+## Syntax
+
+```pseudo
+queue.emplace(args...)
+```
+
+**Parameters:**
+
+- `args...` (variadic template parameters): Arguments forwarded to construct the new element of type `T`.
+
+**Return value:**
+
+None (void). The new element is added to the end of the queue, and the queue size increases by one.
+
+## Example 1: Enqueueing log entries into a queue
+
+In this example, log messages are constructed in place and enqueued for later processing:
+
+```cpp
+#include <iostream>
+#include <queue>
+#include <string>
+
+struct LogEntry {
+  std::string level;
+  std::string message;
+  LogEntry(std::string lvl, std::string msg)
+    : level(std::move(lvl)), message(std::move(msg)) {}
+};
+
+int main(){
+  std::queue<LogEntry> logs;
+  logs.emplace("INFO", "Application started");
+  logs.emplace("WARN", "Low disk space");
+  logs.emplace("ERROR", "Out of memory");
+
+  while(!logs.empty()){
+    const auto& entry = logs.front();
+    std::cout << "[" << entry.level << "] " << entry.message << "\n";
+    logs.pop();
+  }
+}
+```
+
+The output of this code is:
+
+```shell
+[INFO] Application started
+[WARN] Low disk space
+[ERROR] Out of memory
+```
+
+## Example 2: Constructing tasks in a task queue
+
+In this example, tasks with multiple constructor parameters are constructed directly inside the queue:
+
+```cpp
+#include <iostream>
+#include <queue>
+#include <functional>
+
+struct Task {
+  int id;
+  std::string description;
+  Task(int i, std::string desc)
+    : id(i), description(std::move(desc)) {}
+  void run() const { std::cout << "Running task #" << id << ": " << description << "\n"; }
+};
+
+int main(){
+  std::queue<Task> taskQueue;
+  taskQueue.emplace(1, "Load configuration");
+  taskQueue.emplace(2, "Initialize modules");
+  taskQueue.emplace(3, "Start services");
+
+  while(!taskQueue.empty()){
+    taskQueue.front().run();
+    taskQueue.pop();
+  }
+}
+```
+
+The output of this code is:
+
+```shell
+Running task #1: Load configuration
+Running task #2: Initialize modules
+Running task #3: Start services
+```
+
+## Codebyte Example: Buffering sensor data with emplace
+
+In this example, sensor readings are constructed and enqueued as soon as they arrive, minimizing overhead:
+
+```codebyte/cpp
+#include <iostream>
+#include <queue>
+#include <tuple>
+
+struct SensorData {
+  int sensorId;
+  double value;
+  long timestamp;
+  SensorData(int id, double val, long ts)
+    : sensorId(id), value(val), timestamp(ts) {}
+  void print() const {
+    std::cout << "Sensor#" << sensorId
+              << " value=" << value
+              << " time=" << timestamp << "\n";
+  }
+};
+
+int main(){
+  std::queue<SensorData> buffer;
+  buffer.emplace(101, 23.5, 1617181920L);
+  buffer.emplace(102, 19.8, 1617181930L);
+
+  while(!buffer.empty()){
+    buffer.front().print();
+    buffer.pop();
+  }
+
+  return 0;
+}
+```