Added TD2 and done question 1. Added Windows Support for run script.

README.md

@@ -34,6 +34,13 @@ Pour cela rendez vous à la racine du projet après avoir crée et préparer le
 ./run.sh <target_name>
 ```
 _Pour GNU GCC/G++ sur Linux_
->`<target_name>` étant soit `td_insa` ou `exercice_insa`
 
-_le script Windows n'est plus fonctionnel pour le moment_
+```
+./run.bat <target_name>
+```
+_Pour Powershell sur Windows_
+```
+run.bat <target_name>
+```
+_Pour CMD sur Windows_
+>`<target_name>` étant soit `td_insa` ou `exercice_insa`

run.bat

@@ -1,5 +1,5 @@
 echo off
-cmake --build build
+cmake --build build --target %1
 cd build/Debug
-cpp_insa.exe
+%1.exe
 cd ../..

td/td2/include/vector.h

@@ -0,0 +1,152 @@
+#ifndef HEADER_VECTOR
+#define HEADER_VECTOR
+
+#include <cstddef>
+#include <ostream>
+
+template <class T>
+class Vector {
+public:
+    Vector();
+    Vector(size_t capacity);
+    Vector(size_t capacity, T value);
+    Vector(const Vector<T>& other);
+    ~Vector();
+    size_t Size();
+    size_t Capacity();
+    void PushBack(T value);
+    template <class Tfriend>
+    friend std::ostream& operator<<(std::ostream& stream, const Vector<Tfriend>& vec);
+    template <class Tfriend>
+    friend std::istream& operator>>(std::istream& stream, Vector<Tfriend>& vec);
+
+    Vector<T>& operator=(const Vector<T>& other);
+    Vector<T>& operator()(const Vector<T>& other);
+    T operator[](const int indice);
+
+private:
+    size_t _capacity;
+    size_t _size;
+    T* _values;
+};
+
+template <class T>
+Vector<T>::Vector()
+    : _capacity(1)
+    , _size(0)
+    , _values(new T[1])
+{
+}
+
+template <class T>
+Vector<T>::Vector(size_t capacity)
+    : _capacity(capacity)
+    , _size(0)
+{
+    // Allocating the heap with the given capacity
+    _values = new T[capacity];
+}
+
+template <class T>
+Vector<T>::Vector(size_t capacity, T value)
+    : _capacity(capacity)
+    , _size(capacity)
+{
+    // Allocating the heap and setting the value to each element.
+    _values = new T[capacity];
+    for (size_t i = 0; i < capacity; i++)
+        _values[i] = value;
+}
+
+template <class T>
+Vector<T>::Vector(const Vector& other)
+    : _capacity(other._capacity)
+    , _size(other._size)
+    , _values(new T[other._capacity])
+{
+    for (size_t i = 0; i < other._size; i++)
+        _values[i] = other._values[i];
+}
+
+template <class T>
+Vector<T>::~Vector()
+{
+    delete[] _values;
+}
+
+template <class T>
+Vector<T>& Vector<T>::operator=(const Vector<T>& other)
+{
+    if (this != &other) {
+        this->_capacity = other._capacity;
+        this->_size = other._size;
+        delete[] this->_values;
+        this->_values = new T[other._capacity];
+        for (size_t i = 0; i < other._size; i++)
+            this->_values[i] = other._values[i];
+    }
+    return *this;
+}
+
+template <class T>
+Vector<T>& Vector<T>::operator()(const Vector<T>& other)
+{
+    *this = other;
+    return *this;
+}
+
+template <class T>
+size_t Vector<T>::Capacity() { return _capacity; }
+template <class T>
+size_t Vector<T>::Size() { return _size; }
+
+template <class T>
+void Vector<T>::PushBack(T value)
+{
+    // if the next size will overload the heap
+    if (_capacity < _size + 1) {
+        // Keep a track of the old pointer
+        T* oldPtr = _values;
+        // Creating a new pointer by resizing its capacity by factor 2.
+        _values = new T[_size * 2];
+        _capacity *= 2;
+        // Copying the old array onto the new
+        for (size_t i = 0; i < _size; i++)
+            _values[i] = oldPtr[i];
+        // Deallocating the old array
+        delete[] oldPtr;
+    }
+    // Setting the given value and incrementing the size
+    _values[_size] = value;
+    _size++;
+}
+
+// methode get
+template <class T>
+std::ostream& operator<<(std::ostream& stream, const Vector<T>& vec)
+{
+    for (size_t i = 0; i < vec._size; i++)
+        stream << vec._values[i] << ", ";
+    return stream;
+}
+
+// methode put
+template <class T>
+std::istream& operator>>(std::istream& stream, Vector<T>& vec)
+{
+    for (size_t i = 0; i < vec._capacity; i++)
+        stream >> vec._values[i];
+    vec._size = vec._capacity;
+    return stream;
+}
+
+template <class T>
+T Vector<T>::operator[](const int indice)
+{
+    if(indice > _size)
+        throw "Indice from the vector is not reachable";
+    else
+        return _values[indice];
+}
+
+#endif // HEADER_VECTOR

td/td2/src/main.cpp

@@ -0,0 +1,21 @@
+#include <iostream>
+#include "../include/vector.h"
+
+int main(void)
+{
+    Vector<int> intVector;
+    for(int i=0; i<6; i++)
+    {
+        intVector.PushBack(i);
+        std::cout << intVector[i] << std::endl;
+    }
+    try{
+    std::cout << intVector[12] << std::endl;
+    }
+    catch(const char* expr)
+    {
+        std::cout << "Error: " << expr << std::endl;
+    }
+
+    return 0;
+}