Intentionnalités inspirées de Python (et autre langages, probablement. Cf https://docs.python.org/3.3/library/functions.html#zip). Permet de manipuler des listes.

Zip : prend plusieurs listes et en crée une seule.

const auto x = { 1, 2, 3 };
const auto y = { 'a', 'b', 'c' };
const auto z = zip(x, y);
std::cout << z << std::endl; // affiche ((1,a), (2,b), (3,c))

Unzip : prend une liste est la sépare en plusieurs liste

const Zip z = { { 1, 'a' }, { 2, 'b' }, { 3, 'c' } };
styd::tie(x, y) = unzip(z);
std::cout << x << std::endl; // affiche (1, 2, 3)
std::cout << y << std::endl; // affiche (a, b, c)

Ecrire une fonction qui vérifie que 2 vectors ont le même nombre d'éléments, en utilisant un algorithme de la bibliothèque standard.

bool check_zip(vector<int> const& x, vector<char> const& y);

Ecrire une fonction qui zip deux vector, en utilisant un algorithme de la bibliothèque standard.

vector<pair<int, char>> zip1(vector<int> const& x, vector<char> const& y);

Idem, en utilisant une boucle for sur itérateur (zip2a), une boucle for avec indices (zip2b). Idem avec while (zip2c et zip2d).

Quelle est la syntaxe que vous préférez et pourquoi ?

Est-il possible d'utiliser un “range-based for” ?

Ecrire une fonction qui est générique pour les types

vector<pair<T, U>> zip3(vector<T> const& x, vector<U> const& y);

Ecrire une fonction qui est générique pour les collections (en entrée uniquement ?). S'inspirer des algorithmes de la bibliothèque standard.

void zip3(InputIterA first_x, InputIterA last_x, 
         InputIterB first_y, InputIterB last_y, 
         OutputIter first_z);

La fonction de la question précédente n'a pas la même syntaxe que les fonctions des questions avant (vector en paramètre mutable plutôt qu'en retour de fonction), par homologie avec les algorithmes standards (et pour éviter la copie).

Ecrire un adaptateur permettant de convertir le zip de la question 4 (donc sans réécrire le zip).

vector<pair<T, U>> z = (...) zip3(x1, x2, y1, y2, z1) (...);

Utiliser des paires d'itérateurs sur chaque collection en paramètre, plutôt que des itérateurs (sauf pour la sortie).

void zip5(std::pair<InputIterA, InputIterA> x, 
          std::pair<InputIterB, InputIterB> y,
          OutputIter first_z);

Idem, mais chaque paire représente le début ou la fin dans les 2 collections.

void zip5b(std::pair<InputIterA, InputIterB> first, 
          std::pair<InputIterA, InputIterB> last,
          OutputIter first_z);

Quelle syntaxe vous semble la plus pratique ?

Est-il possible d’écrire zip5 et zip5b en utilisant zip3 et des adaptateurs ?

Prendre un nombre indéfini de collections en entrée. Plusieurs approches sont possibles :

• réécrire zip5 avec std::tuple
• réécrire zip5b avec std::tuple
• prendre un seul std::tuple en paramètre, contenant successivement le début et la fin de chaque collection
• en utilisant un variadic template

Ecrire chaque approche. Laquelle préférez vous ?

Note : cette question sort des limites de ce cours.