Méthode permettant de vérifier si quelque chose a été modifié par l'itérateur

Question

J'ai réalisé une implémentation List of Lists d'une matrice sparse, et j'ai implémenté iterator et const_iterator avec succès.

L'itérateur ne pointe pas directement vers le conteneur où la valeur est stockée, mais crée une structure, nommée élément, ainsi définie :

template <typename T>
struct element{
 int i,j; //Coordinates
 T value;
};

Mais il y a un problème avec l'itérateur : lorsque je l'utilise pour modifier les valeurs dans la structure, cela devrait même affecter la structure interne de la matrice. J'ai pensé à stocker les valeurs originales dans d'autres attributs privés de l'itérateur, puis à les comparer avec les données stockées dans la structure : si quelque chose est différent, j'appelle les méthodes de la matrice pour modifier la structure interne réelle.

La seule chose qui me manque, c'est de savoir à quel moment il faut appeler cette méthode à l'intérieur de la classe des itérateurs.

Answer 1

La réponse courte est que vous devez appeler cette fonction dès que *it est affecté à, où it est un itérateur.

Je ne pense pas que vous ayez la bonne approche. Les itérateurs en C++ ne peuvent pas vraiment mettre en cache les changements, parce qu'il peut y avoir d'autres itérateurs qui pointent au même endroit dans le conteneur. Les modifications apportées par l'itérateur doivent affecter la matrice immédiatement, et les modifications de la matrice doivent être visibles immédiatement par l'itérateur. Voici un cas de test :

typedef whatever_type_you_like T; // maybe int

matrix<T> mymatrix(5, 5);
matrix<T>::iterator it1 = get_iterator_from(mymatrix, 2, 3);
matrix<T>::iterator it2 = get_iterator_from(mymatrix, 2, 3);
assert(it1 == it2);
assert(*it1 == *it2);
assert(*it1 == T());

*it1 = T(1); // or some other constructor parameter
assert(*it1 != T());
assert(*it1 == T(1));
assert(*it2 == T(1));
assert(it1 == it2);
assert(*it1 == *it2);
assert(*it1 == mymatrix[2][3]); // or whatever syntax you have for matrix access

*it2 = T(2);
assert(*it1 != T(1));
assert(*it1 == T(2));
assert(*it2 == T(2));
assert(it1 == it2);
assert(*it1 == *it2);
assert(*it2 == mymatrix[2][3]);

mymatrix[2][3] = T(3);
assert(*it2 != T(2));
assert(*it2 == mymatrix[2][3]);

Ainsi, au lieu de element stockage d'un copie de la valeur destinée à la matrice, il devrait accéder directement à la matrice, en y lisant la valeur et en la stockant (et donc en créant une entrée réelle dans la matrice éparse lorsqu'il est nécessaire de la stocker). Par ailleurs, votre element doit être convertible en T .