Problèmes de compréhension des itérateurs et de la surcharge de l'opérateur en C++

Question

Nous avons un exemple de classe et je ne comprends pas. Je ne comprends pas très bien comment fonctionne l'opérateur() dans ce cas, et tout commence par trier. J'ai regardé la sortie après l'exécution du programme, et je ne vois pas comment ces valeurs sont obtenues.

sort indices array: 2 8 10 4 1 7 5 3 0 9 6 11 
replay numbers array: 37 33 29 36 32 35 39 34 30 38 31 40 
number array via indices 29 30 31 32 33 34 35 36 37 38 39 40 

J'ai essayé regardant foncteurs sur cette carte puisque le titre est foncteur exemple, mais je suppose que je ne vois pas comment foncteurs sont en jeu ici. Toutes les pensées seraient grandement appréciées car je suis complètement perdu. Merci!

#include <iostream> 
#include <vector> 
#include <algorithm> 
#include <numeric> 

#include "IndexCompare.h" 

using namespace std; 

template <class ForwardIterator, class T> 
void iota(ForwardIterator first, ForwardIterator last, T value) { 
    while (first != last) { 
     *first++ = value++; 
    } 
} 

const int MAX = 12; 

int main() { 
    int numbers[] = {37, 33, 29, 36, 32, 35, 39, 34, 30, 38, 31, 40}; 

    vector<int> vecNum(numbers, numbers + MAX); 

    // Display original number array. 
    cout << "--- initial numbers array ---" << endl; 

    vector<int>::iterator iter = vecNum.begin(); 
    for (; iter != vecNum.end(); iter++) { 
     cout << *iter << " "; 
    } 
    cout << "\n"; 

    vector<int> indices(vecNum.size()); 

    // fill indices array 
    cout << "\n--- invoke 'iota' on indices array ---"; 
    iota(indices.begin(), indices.end(), 0); 

    // Display original indices array. 
    cout << "\n linear indices array: "; 
    vector<int>::iterator iterIdx = indices.begin(); 
    for (; iterIdx != indices.end(); iterIdx++) { 
     cout << *iterIdx << " "; 
    } 
    cout << "\n"; 

    // sort indices array 
    cout << "\n--- invoke 'Sort' on indices based on number array ---"; 
    sort(indices.begin(), indices.end(), 
      IndexCompare<vector<int>::iterator>(vecNum.begin(),vecNum.end())); 

    // Display sorted indices array 
    cout << "\n Sorted indices array: "; 
    for (iterIdx = indices.begin(); iterIdx != indices.end(); iterIdx++) { 
     cout << *iterIdx << " "; 
    } 
    cout << "\n"; 

    cout << "\n--- Run check on number array indexed normally ---"; 
    // Display original numbers array. 
    cout << "\n replay numbers array: "; 
    iter = vecNum.begin(); 
    for (; iter != vecNum.end(); iter++) { 
     cout << *iter << " "; 
    } 
    cout << "\n"; 

    cout << "\n--- Run check on number array indexed with sorted indices ---"; 
    // Print original nums array indirectly through indices. 
    cout << "\n number array via indices: "; 
    for (int index = 0; index < vecNum.size(); index++) 
     cout << vecNum[indices[index]] << " "; 
    cout << "\n"; 

    getchar(); 

    return 0; 
} 

// IndexCompare.h - interface for IndexCompare class template 
#ifndef _INDEXCOMPARE_H_ 
#define _INDEXCOMPARE_H_ 
#pragma once 

template <class random_iterator> 
class IndexCompare { 
public: 
    IndexCompare(random_iterator begin, random_iterator end) 
     : begin(begin), end(end) {} 

    ~IndexCompare() {} 

    bool operator() (unsigned int first, unsigned int second) { 
      return (*(begin + first) < *(begin + second)); 

    } 

private: 
    random_iterator begin; 
    random_iterator end; 
}; 

#endif 

Answer 1

Je ne suis pas sûr que je serai en mesure de l'expliquer correctement. Voici mon essai:

(1). vector<int> indices(vecNum.size());

Vous créez un vecteur pour contenir les index pour les éléments du vecteur vecNum. Évidemment, le nombre d'éléments dans ce vecteur est le même que le nombre d'éléments dans vecNum.

(2). iota(indices.begin(), indices.end(), 0);

Initialisation du indices avec des valeurs de 0 - vecNum.size() - 1

(3).

sort(indices.begin(), indices.end(), 
       IndexCompare<vector<int>::iterator>(vecNum.begin(),vecNum.end())); 

Pour chaque élément dans le vecteur indices invoquer le foncteur IndexCompare. Ce foncteur dans sa operator() obtient la valeur du vecteur vecNum correspondant à la position d'index donnée. Donc, fondamentalement, vous triez le vecteur indices (pas vecNum) basé sur les valeurs de vecNum. Par conséquent, le vecNum reste inchangé et indices est trié en fonction des valeurs de vecNum.

Pour le rendre plus clair (je l'espère), l'état initial des indices vecteur sera dire: indices = 0,1,2 et vecNum = 20,10,30

Maintenant, vous appellent std::sort à ce sujet avec votre propre foncteur. Donc, pour déterminer si 0 est inférieur à 1 sort algorithme utilisera votre foncteur. A l'intérieur du foncteur, vous déterminez si 0 < 1 en utilisant la logique si vecNum [0] (c'est-à-dire 20) < vecNum [1] (c'est-à-dire 10). Donc, le put mis out sera indices = 1,0,2.