173. Generic Sensor Pair

1. Function Templates

Write logic once, use it for different types.

// Template Declaration
// 'T' is a placeholder for a type (int, float, struct...)
template <typename T> 
void swap_values(T& a, T& b) {
    T temp = a;
    a = b;
    b = temp;
}

int main() {
    int x = 10, y = 20;
    swap_values(x, y);     // Compiler generates: void swap_values(int&, int&)

    float f1 = 1.5, f2 = 4.5;
    swap_values(f1, f2);   // Compiler generates: void swap_values(float&, float&)
}

2. Class Templates

Crucial for creating generic data structures (Buffers, Queues, Linked Lists) where the logic is the same regardless of what data is stored inside.

// A Circular Buffer that can hold 'T' type objects
// 'Size' is a Non-Type Template Parameter (Constant Integer)
template <typename T, int Size>
class RingBuffer {
private:
    T buffer[Size]; // Array size fixed at compile time
    int head = 0;

public:
    void push(T val) {
        buffer[head] = val;
        head = (head + 1) % Size;
    }
};

// Usage
RingBuffer<int, 64> adc_buf;       // Buffer of 64 integers
RingBuffer<float, 10> sensor_avg;  // Buffer of 10 floats
RingBuffer<Packet, 128> uart_rx;   // Buffer of 128 custom Structs

Templates do not exist in the final binary until they are used.

When you write RingBuffer<int, 64>, the compiler acts like a code generator:

1. It takes the "Blueprint".

2. It replaces T with int and Size with 64.

3. It compiles that new specific class.

Sometimes generic code works for 99% of types, but fails for one specific type (like bool or char*). You can provide a special version for that type.

// Generic
template <typename T>
T add(T a, T b) { return a + b; }

// Specialization for 'char' (e.g., to prevent overflow or change logic)
template <>
char add<char>(char a, char b) {
    // Saturated addition logic for 8-bit audio
    int res = a + b;
    if (res > 127) return 127; 
    return (char)res;
}

• Type-Safe Drivers (Zero Cost Abstraction)

  In C, drivers often use void* buffers and require casting (dangerous) or macros (hard to debug).

  Templates give you type safety with zero runtime overhead. The compiler resolves types during compilation, so the resulting assembly is as fast as hand-written C code.

• Compile-Time Configuration

  You can use "Non-Type Template Parameters" (integers, pointers) to configure hardware.

  template <uint32_t BaseAddr>
  class GPIO {
  public:
      static void setHigh() { 
          *(volatile uint32_t*)(BaseAddr) = 1; 
      }
  };
  
  using LED_Port = GPIO<0x40021000>;
  // LED_Port::setHigh() compiles to a direct memory write instruction!

• Avoids malloc

  Standard containers (std::vector) use the Heap (malloc). In embedded, we hate malloc.

  With templates, you can pass the size as a parameter (RingBuffer<int, 64>), allowing the buffer to be allocated on the Stack or BSS (Static Memory).

• The Fear: "Templates generate a copy of the code for every type, filling up my Flash memory."

• The Reality: Yes, vector<int> and vector<float> are two separate code blocks.

  • However, if you manually wrote IntVector and FloatVector structs in C, you would have the exact same amount of code.

  • Optimization: If different template instantiations result in identical assembly (e.g., MyClass<unsigned int> vs MyClass<int> on some architectures), the linker can sometimes merge them.