¿Iteración sobre referencias?

Question

quisiera realizar la misma operación en varias matrices, algo así como:

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

Este código de falla, ya auto& es una constante referencia. ¿Hay una forma elegante de evitarlo?

Answer 1

Creo que el problema es que es un poco como vincular una referencia temporal a una referencia no constante. No hay una colección "concreta" allí, así que es un poco temporal.

SI tiene un vector temporal allí, se vinculará a una referencia constante pero no a una constante.

también creo que esto no volverá a trabajar lo que está haciendo, pero esto debería funcionar:

#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) 
} 

y concesionarios puede trabajar también.

Answer 2

Este código falla, desde auto & es una referencia constante. [énfasis mío]

Su razonamiento no se sostiene. En un bucle for basado en rango, lo que usted declara (aquí, auto& ab) es no vinculado a la expresión de rango (aquí, {a,b }). En su lugar, ab se inicializará a partir del elementos del rango, no el rango en sí.

En su lugar, el error proviene de llamar a std::sort con los parámetros ab.begin()/ab.end(), que pueden ser fácilmente observados al comentar el cuerpo del bucle. Como ha señalado RMartinho, los elementos del std::initializer_list<std::vector<double>> son inmutables, y no se puede ordenar un contenedor const (std::sort mezcla los elementos usando movimientos, no se puede asignar a un elemento const).

Suponiendo que desee (de forma independiente) Clasificar los dos vectores, se puede hacer:

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

en cuenta que de acuerdo a las reglas de deducción de argumento plantilla, auto& está muy bien aquí y auto se deducirá a const std::reference_wrapper<std::vector<double>>, produciendo std::reference_wrapper<std::vector<double>> const& como el tipo de ab.

Answer 3

Creo que la solución CashCows es agradable. Solo para mostrar una forma diferente: también puedes usar plantillas variadic para resolver esto.

#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: Es posible pasar un algoritmo como argumento, pero es un poco feo debido a la utilización de 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); 
}