Iterazione sui riferimenti?

Question

Vorrei per eseguire la stessa operazione su più array, qualcosa di simile:

#include<vector> 
#include<algorithm> 
int main(void){ 
    std::vector<double> a, b; 
    for(auto& ab:{a,b}) std::sort(ab.begin(),ab.end()); // error 
} 

Questo codice non funziona, dal momento che è un auto& const riferimento. C'è un modo elegante attorno ad esso?

Answer 1

Penso che il problema sia un po 'come legare un riferimento temporaneo a un non-const. Non esiste una collezione "concreta", quindi è un po 'temporanea.

Se si dispone di un vettore temporaneo, esso si collegherà a un riferimento const ma non a uno const-const.

Penso anche che questo non funzionerà mai quello che stai facendo, ma questo dovrebbe funzionare:

#include<vector> 
#include<algorithm> 
int main(void) 
{  
    std::vector<double> a, b;  
    for(std::vector<double>* ab:{&a,&b}) 
     std::sort(ab->begin(),ab->end()); // or begin(*ab),end(*ab) 
} 

e auto può funzionare anche.

Answer 2

Questo codice non funziona, poiché l'auto & è un riferimento const. [emphasis mine]

Il tuo ragionamento non regge. In un ciclo for-range, ciò che dichiari (qui, auto& ab) è non associato all'espressione di intervallo (qui, {a,b }). Invece, ab verrà inizializzato dagli elementi dell'intervallo, non dall'intervallo stesso.

Invece l'errore deriva dal chiamare std::sort con i parametri ab.begin()/ab.end(), che può essere facilmente osservato commentando il corpo del ciclo. Come sottolineato da RMartinho, gli elementi di std::initializer_list<std::vector<double>> non sono modificabili e non è possibile ordinare un contenitore const (elementi std::sort utilizzando le mosse, non è possibile assegnare a un elemento const).

Supponendo che si desidera (in modo indipendente) ordinare entrambi i vettori, si può fare:

for(auto& ab: { std::ref(a), std::ref(b) }) 
    std::sort(std::begin(ab.get()), std::end(ab.get())); 

Si noti che in base alle leggi di deduzione modello di argomento, auto& va bene qui e auto sarà dedotta al const std::reference_wrapper<std::vector<double>>, cedendo std::reference_wrapper<std::vector<double>> const& come il tipo di ab.

Answer 3

Penso che la soluzione CashCows sia buona. Solo per mostrare un modo diverso: potresti anche usare modelli variadici per risolvere questo problema.

#include <vector> 
#include <algorithm> 

using namespace std; 

void mysort() {} // termination version 

template<typename Arg1, typename... Args> 
void mysort(Arg1 &arg1, Args&... args) 
{ 
    sort(arg1.begin(), arg1.end()); 
    mysort(args...); 
} 

int main(void) 
{ 
    vector<double> a, b; 
    mysort(a, b); 
} 

@CashCow: E 'possibile passare un algoritmo come argomento, ma è un po' brutto a causa dell'uso di decltype:

#include <vector> 
#include <algorithm> 

using namespace std; 

template<typename Algo> 
void mysort(Algo algo) {} // termination version 

template<typename Algo, typename Arg1, typename... Args> 
void mysort(Algo algo, Arg1 &arg1, Args&... args) 
{ 
    algo(arg1.begin(), arg1.end()); 
    mysort(algo, args...); 
} 

int main(void) 
{ 
    vector<double> a, b; 
    mysort(&sort<decltype(a.begin())>, a, b); 
}