Lặp lại tham chiếu?

Question

Tôi muốn thực hiện các hoạt động tương tự trên nhiều mảng, một cái gì đó như:

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

Mã này thất bại, kể từ auto& là một const tham chiếu. Có một cách thanh lịch xung quanh nó?

Answer 1

Tôi nghĩ rằng vấn đề là nó giống như ràng buộc tạm thời với tham chiếu không phải const. Không có bộ sưu tập "cụ thể" ở đó nên nó hơi giống như tạm thời.

NẾU bạn có một véc tơ tạm thời ở đó, nó sẽ liên kết với tham chiếu const nhưng không liên kết với nhau.

Tôi cũng nghĩ rằng điều này sẽ không bao giờ làm việc gì bạn đang làm, nhưng điều này sẽ làm việc:

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

và tự động có thể làm việc quá.

Answer 2

Mã này không thành công, vì tự động & là tham chiếu const. [nhấn mạnh mỏ]

Lý do của bạn không giữ. Trong vòng lặp dựa trên phạm vi, những gì bạn khai báo (ở đây, auto& ab) là không phải được liên kết với biểu thức phạm vi (tại đây, {a,b }). Thay vào đó, ab sẽ được khởi tạo từ các yếu tố của phạm vi, không phải phạm vi của chính nó.

Thay vào đó, lỗi xuất phát từ việc gọi std::sort với thông số ab.begin()/ab.end(), có thể dễ dàng được chứng kiến ​​bằng cách nhận xét nội dung vòng lặp. Như RMartinho đã chỉ ra, các thành phần của std::initializer_list<std::vector<double>> là không thay đổi và bạn không thể sắp xếp vùng chứa const (std::sort các yếu tố bằng cách sử dụng di chuyển, không thể gán cho phần tử const).

Giả sử bạn muốn (độc lập) sắp xếp cả hai vectơ, bạn có thể làm:

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

ý rằng theo nguyên tắc khấu trừ mẫu đối số, auto& là tốt ở đây và auto sẽ được rút ra để const std::reference_wrapper<std::vector<double>>, năng suất std::reference_wrapper<std::vector<double>> const& như loại ab.

Answer 3

Tôi nghĩ giải pháp CashCows rất hay. Chỉ để hiển thị một cách khác: Bạn cũng có thể sử dụng các mẫu variadic để giải quyết vấn đề này.

#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: Có thể vượt qua một thuật toán như là đối số nhưng nó là một chút xấu xí vì việc sử dụng 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); 
}