Imposta operazione in c ++ (aggiorna valore esistente)

Ecco il mio codice:

 while (it!=s.end())  //here 's' is a set of stl and 'it' is iterator of set
    {   
        *it=*it-sub;    //'sub' is an int value
        it++;
    }

Non riesco ad aggiornare il valore di set da iteratore. Voglio sottrarre un valore intero 'sub' da tutto l'elemento dell'insieme.

Qualcuno può aiutarmi dove si trova il problema reale e quale sarebbe la soluzione effettiva?

Ecco il messaggio di errore:

error: assignment of read-only location ‘it.std::_Rb_tree_const_iterator<int>::operator*()’
   28 |             *it=*it-sub;
      |             ~~~^~~~~~~~

I valori chiave degli elementi in a std::setsono constper una buona ragione. La loro modifica può distruggere l'ordine che è essenziale per a std::set.

Quindi, la soluzione è cancellare l'iteratore e inserirne uno nuovo con chiave *it - sub. Tieni presente che std::set::erase()restituisce un nuovo iteratore che deve essere utilizzato nel tuo caso per far funzionare correttamente il ciclo while.

#include<iostream>
#include<set>

template <typename T>
std::ostream& operator<<(std::ostream &out, const std::set<T> &values)
{
  const char *sep = "{ ";
  for (const T &value : values) { out << sep << value; sep = ", "; }
  return out << " }";
}

int main()
{
  std::set<int> test{ 11, 12, 13, 14, 15 };
  std::cout << "test: " << test << '\n';
  const int sub = 10;
  std::set<int>::iterator iter = test.begin();
  while (iter != test.end()) {
    const int value = *iter;
    iter = test.erase(iter);
    test.insert(value - sub);
  }
  std::cout << "test: " << test << '\n';
}

Produzione:

test: { 11, 12, 13, 14, 15 }
test: { 1, 2, 3, 4, 5 }

Demo live su coliru

I cambiamenti durante l' std::setiterazione su di esso non sono un problema in generale, ma possono causare problemi sottili.

Il fatto più importante è che tutti gli iteratori utilizzati devono essere mantenuti intatti o non possono più essere utilizzati. (Ecco perché l'attuale iteratore dell'elemento di cancellazione viene assegnato con il valore di ritorno di std::set::erase()cui è un iteratore intatto o la fine dell'insieme.)

Naturalmente, è possibile inserire elementi anche dietro l'attuale iteratore. Anche se questo non è un problema in merito std::set, potrebbe interrompere il ciclo del mio esempio precedente.

Per dimostrarlo, ho modificato un po 'l'esempio sopra. Si prega di notare che ho aggiunto un contatore aggiuntivo per garantire la chiusura del loop:

#include<iostream>
#include<set>

template <typename T>
std::ostream& operator<<(std::ostream &out, const std::set<T> &values)
{
  const char *sep = "{ ";
  for (const T &value : values) { out << sep << value; sep = ", "; }
  return out << " }";
}

int main()
{
  std::set<int> test{ 11, 12, 13, 14, 15 };
  std::cout << "test: " << test << '\n';
  const int add = 10;
  std::set<int>::iterator iter = test.begin();
  int n = 7;
  while (iter != test.end()) {
    if (n-- > 0) {
      const int value = *iter;
      iter = test.erase(iter);
      test.insert(value + add);
    } else ++iter;
  }
  std::cout << "test: " << test << '\n';
}

Produzione:

test: { 11, 12, 13, 14, 15 }
test: { 23, 24, 25, 31, 32 }

Demo live su coliru

Semplice da sostituire con un altro set

std::set<int> copy;

for (auto i : s)
    copy.insert(i - sub);

s.swap(copy);

Non puoi mutare elementi std::setper design. Vedere

https://en.cppreference.com/w/cpp/container/set/begin

Poiché sia ​​iteratore che const_iterator sono iteratori costanti (e possono in effetti essere dello stesso tipo), non è possibile mutare gli elementi del contenitore attraverso un iteratore restituito da una di queste funzioni membro.

Questo perché set è ordinato . Se mutate un elemento in una raccolta ordinata, la raccolta deve essere ordinata di nuovo, il che è ovviamente possibile, ma non nel modo C ++.

Le tue opzioni sono:

1. Utilizza un altro tipo di raccolta (non ordinata).
2. Crea un nuovo set e riempilo con elementi modificati.
3. Rimuovere un elemento da std::set, modificarlo, quindi inserirlo di nuovo. (Non è una buona idea se si desidera modificare ogni elemento)

A std::setè in genere implementato come albero binario autobilanciante in STL. *itè il valore dell'elemento utilizzato per ordinare l'albero. Se fosse possibile modificarlo, l'ordine diventerebbe non valido quindi non è possibile farlo.

Se vuoi aggiornare un elemento, devi trovare quell'elemento nel set, rimuoverlo e inserire il valore aggiornato dell'elemento. Ma poiché è necessario aggiornare i valori di tutti gli elementi, è necessario cancellare e inserire tutti gli elementi uno per uno.

È possibile farlo in uno per il ciclo fornito sub > 0. S.erase(pos)rimuove l'iteratore in posizione pose restituisce la seguente posizione. Se sub > 0, il valore aggiornato che inserirai verrà prima del valore nel nuovo iteratore nella struttura ma se sub <= 0, quindi il valore aggiornato verrà dopo il valore nel nuovo iteratore nella struttura e quindi finirai in un ciclo infinito.

for (auto itr = S.begin(); itr != S.end(); )
{
    int val = *itr;
    itr = S.erase(itr);
    S.insert(val - sub);
}

L'errore spiega praticamente il problema

I membri del std::setcontenitore sono const. La loro modifica rende non valido il rispettivo ordine.

Per cambiare gli elementi in std::set, dovrai cancellare l'elemento e reinserirlo dopo che è stato modificato.

In alternativa, è possibile utilizzare std::mapper superare questo scenario.