Chapitre 7 : modèles #

#include <iostream>

class Time
{
public:
    Time(int h = 0, int m = 0, int s = 0) : m_hour(h), m_minute(m), m_second(s) {}

    bool operator>(const Time& other) const
    {
        return toSeconds() > other.toSeconds();
    }

    int getHour() const { return m_hour; }
    int getMinute() const { return m_minute; }
    int getSecond() const { return m_second; }

    friend std::ostream& operator<<(std::ostream& os, const Time& t);

private:
    int toSeconds() const
    {
        return m_hour * 3600 + m_minute * 60 + m_second;
    }

    int m_hour{0};
    int m_minute{0};
    int m_second{0};
};

inline std::ostream& operator<<(std::ostream& os, const Time& t)
{
    return os << t.m_hour << "h" << t.m_minute << "'" << t.m_second << "\"";
}

#include <iostream>
#include "Time.h"

template <typename T>
T maxi(const T& a, const T& b)
{
    return (a > b) ? a : b;
}

int main()
{
    Time t1(9, 57, 59);
    Time t2(9, 58, 37);

    auto maxTime = maxi<Time>(t1, t2); // Explicit type specification
    maxTime = maxi(t1, t2);            // Automatic type deduction

    // Time has operator<< but no std::formatter, so use std::cout
    std::cout << maxTime << " = maxi(" << t1 << ", " << t2 << ")" << '\n';

    return 0;
}

#include <print>
#include <iostream>

class Rectangle
{
public:
  Rectangle(double w = 0, double h = 0) : m_width(w), m_height(h) {}

  bool operator>=(const Rectangle &other) const
  {
    return (m_width * m_height) >= (other.m_width * other.m_height);
  }

  friend std::ostream &operator<<(std::ostream &os, const Rectangle &r);

private:
  double m_width{0};
  double m_height{0};
};

std::ostream &operator<<(std::ostream &os, const Rectangle &r)
{
  return os << "[" << r.m_width << ", " << r.m_height << "]";
}

template <typename T>
T maxi(const T &a, const T &b)
{
  return (a >= b) ? a : b;
}

int main()
{
  auto i1 = 3;
  auto i2 = 4;
  auto d1 = 2.34;
  auto d2 = 2.35;
  Rectangle r1(10, 20);
  Rectangle r2(20, 30);

  auto maxInt = maxi(i1, i2);             // Automatic type deduction
  auto maxDouble1 = maxi(d1, d2);         // Automatic type deduction
  auto maxDouble2 = maxi<double>(i1, d1); // Explicit: compiler can't deduce mixed types
  // maxi(i1, d1);                        // Would not compile: ambiguous types
  auto maxRectangle = maxi(r1, r2); // Rectangle must overload operator>=

  std::println("maxi(int, int)           : ({}, {}) --> {}", i1, i2, maxInt);
  std::println("maxi(double, double)     : ({}, {}) --> {}", d1, d2, maxDouble1);
  std::println("maxi<double>(int, double): ({}, {}) --> {}", i1, d1, maxDouble2);

  // Rectangle has operator<< but no std::formatter
  std::cout << "maxi(Rectangle, Rectangle): (" << r1 << ", " << r2 << ") --> " << maxRectangle << '\n';

  return 0;
}

#include <iostream>
#include <typeinfo>

template <typename T>
class Wrapper
{
public:
  Wrapper(const T &val = T()) : m_value(val) {}

  // Cross-type converting constructor (not a copy constructor)
  template <typename U>
  Wrapper(const Wrapper<U> &other) : m_value(static_cast<T>(other.getValue())) {}

  T getValue() const { return m_value; }

  template <typename T2>
  friend std::ostream &operator<<(std::ostream &os, const Wrapper<T2> &w);

private:
  T m_value;
};

template <typename T2>
std::ostream &operator<<(std::ostream &os, const Wrapper<T2> &w)
{
  return os << w.m_value << " (type: " << typeid(w.m_value).name() << ")";
}

#include <iostream>
#include "Wrapper.h"

int main()
{
    Wrapper<float> a(3.1f);   // Value is float
    Wrapper<int> b(a);        // Value is int (converted from float)
    Wrapper<float> f = a;     // Copy constructor (same type)

    // Wrapper has operator<< but no std::formatter
    std::cout << a << '\n';   // Prints 3.1 (float)
    std::cout << b << '\n';   // Prints 3 (int, truncated)
    std::cout << f << '\n';   // Prints 3.1 (float)

    return 0;
}

#include <print>

// Class template with non-type template parameter (compile-time constant)
template <typename T, int Size>
class Array
{
public:
  Array() = default;

  T getAt(int pos) const
  {
    if (pos >= 0 && pos < Size)
    {
      return m_data[pos];
    }
    // Invalid position: could throw an exception instead
    return T{-1};
  }

  void setAt(int pos, T val)
  {
    if (pos >= 0 && pos < Size)
    {
      m_data[pos] = val;
    }
  }

  int getSize() const { return Size; }

private:
  T m_data[Size];
};

#include <print>
#include "Array.h"

int main()
{
  Array<double, 5> t1;
  t1.setAt(0, 1.5);
  using TabInt7 = Array<int, 7>;
  TabInt7 t2;

  std::println("Array of double, size = {}", t1.getSize());
  std::println("Values outside bounds return -1\n");
  for (int i = -1; i <= t1.getSize(); i++)
  {
    t1.setAt(i, i / 2.0);
    std::print("{}\t", t1.getAt(i));
  }

  std::println("\n");

  std::println("Array of int, size = {}", t2.getSize());
  std::println("Values outside bounds return -1\n");
  for (int i = -1; i <= t2.getSize(); i++)
  {
    t2.setAt(i, i / 2);
    std::print("{}\t", t2.getAt(i));
  }
  std::println("");

  return 0;
}

#include <print>

template <typename T>
class Point
{
public:
    Point(T x = 0, T y = 0) : m_x(x), m_y(y) {}
    void show();

private:
    T m_x;
    T m_y;
};

template <typename T>
void Point<T>::show()
{
    std::println("Point<T>::show()    Coordinates: {} {}", m_x, m_y);
}

// Full specialization of member function for char
template <>
void Point<char>::show()
{
    std::println("Point<char>::show() Coordinates: {} {}", static_cast<int>(m_x), static_cast<int>(m_y));
}

int main()
{
    Point<int> ptInt(3, 5);
    ptInt.show();

    Point<char> ptChar('d', 'y');
    ptChar.show();

    Point<double> ptDbl(3.5, 2.3);
    ptDbl.show();

    return 0;
}

#include <print>
#include <cstring>

// Generic template function
template <typename T>
T minVal(T tab[], int n)
{
  std::println("minVal() template");
  auto min = tab[0];
  for (int i = 1; i < n; i++)
  {
    auto current = tab[i];
    if (current < min)
    {
      min = tab[i];
    }
  }
  return min;
}

// Non-template overload (not a specialization) — preferred over template<>
// for char* because it participates correctly in overload resolution
const char *minVal(const char *tab[], int n)
{
  std::println("minVal() overload for char*");
  auto result = tab[0];
  for (int i = 1; i < n; i++)
  {
    if (std::strcmp(tab[i], result) < 0)
    {
      result = tab[i];
    }
  }
  return result;
}

int main()
{
  int tabInt[5] = {5, 7, 2, 6, 9};
  char tabChar[10] = {'H', 'e', 'l', 'l', 'o', 'W', 'o', 'r', 'l', 'd'};
  const char *tabStr[] = {"Hello", "Bonjour", "Gruezi", "Buenos dias", "Konichiwa"};

  std::println("minVal<int>({{5,7,2,6,9}}, 5): {}", minVal<int>(tabInt, 5));
  std::println("minVal<char>(\"HelloWorld\", 10): {}", minVal<char>(tabChar, 10));
  std::println("minVal({{\"Hello\",\"Bonjour\",...}}, 5): {}", minVal(tabStr, 5));

  return 0;
}

#include <print>

// Non-template function
void f(int)
{
    std::println("Non-template");
}

// Template function
template <typename T>
void f(T)
{
    std::println("Template");
}

// Explicit specialization of the template for int
template <>
void f<int>(int)
{
    std::println("Specialization f<int>");
}

int main()
{
    f(1);    // Calls the non-template version (exact match preferred)
    f('c');  // Calls the template version (T = char)
    f<>(1);  // Calls the specialized template version (f<> forces template)

    return 0;
}