無害な範囲ベースのforループが機能しない

以下はコンパイルされません：

#include <iostream>

int main()
{
    int a{},b{},c{},d{};

    for (auto& s : {a, b, c, d}) {
        s = 1;
    }
    std::cout << a << std::endl;
    return 0;
}

ゴッドボルトで試してみてください

コンパイラエラーは次のとおりです。 error: assignment of read-only reference 's'

今私の実際の場合、リストはクラスのメンバー変数で構成されています。

これで、式がinitializer_list<int>実際にa、b、c、およびdをコピーするになるため、これは機能しません。したがって、変更もできません。

私の質問は2つあります。

このように範囲ベースのforループを記述できないようにする動機はありますか？ 例えば。おそらく、裸のブレース式の特別なケースがあるかもしれません。

このタイプのループを修正する構文上のきちんとした方法は何ですか？

この線に沿ったものが好ましいでしょう：

for (auto& s : something(a, b, c, d)) {
    s = 1;
}

私はポインタの間接化を適切なソリューションとは考えていません（つまり{&a, &b, &c, &d}）-イテレータが逆参照されている場合、どのソリューションでも要素参照を直接指定する必要があります。

範囲は人々が望むほど魔法ではありません。最後に、コンパイラは、メンバ関数やfree関数のいずれかへの呼び出しを生成できるオブジェクトがなければならないbegin()とend()。

あなたが来ることができる最も近いものは次のとおりです：

#include <iostream>

int main()
{
    int a{},b{},c{},d{};

    for (auto s : {&a, &b, &c, &d} ) {
        *s = 1;
    }
    std::cout << a << "\n";
    return 0;
}

ラッパーアイデア内の別のソリューション：

template<typename T, std::size_t size>
class Ref_array {
    using Array = std::array<T*, size>;

    class Iterator {
    public:
        explicit Iterator(typename Array::iterator it) : it_(it) {}

        void operator++() { ++it_; }
        bool operator!=(const Iterator& other) const { return it_ != other.it_; }
        decltype(auto) operator*() const { return **it_; }

    private:
        typename Array::iterator it_;
    };

public:
    explicit Ref_array(Array args) : args_(args) {}

    auto begin() { return Iterator(args_.begin()); }
    auto end() { return Iterator(args_.end()); }

private:
    Array args_;
};

template<typename T, typename... Ts>
auto something(T& first, Ts&... rest) {
    static_assert((std::is_same_v<T, Ts> && ...));
    return Ref_array<T, 1 + sizeof...(Ts)>({&first, &rest...});
}

次に：

int main() {
    int a{}, b{}, c{}, d{};

    for (auto& s : something(a, b, c, d)) {
        std::cout << s;
        s = 1;
    }

    std::cout  << std::endl;
    for (auto& s : something(a, b, c, d))
        std::cout << s;
}

出力

0000
1111

標準§11.6.4List-initialization / p5 [dcl.init.list] [ Emphasis Mine ]によると：

タイプ 'std :: initializer_list'のオブジェクトは、実装が「array of N const E」タイプのprvalueを生成および実体化した場合と同様に、イニシャライザリストから構築されます（ Nはイニシャライザリストの要素数）。その配列の各要素は、初期化子リストの対応する要素でコピー初期化され、std :: initializer_listオブジェクトはその配列を参照するように構築されます。[注：コピー用に選択されたコンストラクターまたは変換関数は、初期化子リストのコンテキストでアクセス可能でなければなりません（条項14）。— end note]いずれかの要素を初期化するためにナローイング変換が必要な場合、プログラムの形式が正しくありません。

したがって、コンパイラは合法的に文句を言います（つまり、範囲のforループでauto &s控除されint const& s、割り当てられませんs）。

'std :: reference_wrapper'でイニシャライザリスト（たとえば、 `std :: vector '）の代わりにコンテナを導入することにより、この問題を軽減できます。

#include <iostream>
#include <vector>
#include <functional>

int main()
{
    int a{},b{},c{},d{};

    for (auto& s : std::vector<std::reference_wrapper<int>>{a, b, c, d}) {
        s.get()= 1;
    }
    std::cout << a << std::endl;
    return 0;
}

ライブデモ

その構文を満たすために

for (auto& s : something{a, b, c, d}) {
    s = 1;
}

あなたはラッパーを作成するかもしれません：

template <typename T>
struct MyRefWrapper
{
public:
    MyRefWrapper(T& p)  : p(&p) {}

    T& operator =(const T& value) const { return *p = value; }

    operator T& () const { return *p; }
private:
    T* p;     
};

デモ

解決策：参照ラッパーを使用する

template <class It>
struct range_view_iterator : public It{//TODO: don't inherit It
    auto& operator*() {
        return (*this)->get();
    }
};

template<class It>
range_view_iterator(It) -> range_view_iterator<It>;


template<class T>
struct range_view {
    std::vector<std::reference_wrapper<T> > refs_;
    range_view(std::initializer_list<std::reference_wrapper<T> > refs) : refs_{refs} {
    }

    auto begin() {
        return range_view_iterator{ refs_.begin() };
    }

    auto end() {
        return range_view_iterator{ refs_.end() };
    }
};

次に、次のように使用されます。

for (auto& e : range_view<int>{a, b, c, d}) {
    e = 1;
}

ただし、これは最初の質問に答えようとするものではありません。

参照を格納するためのラッパークラスを作成できます。これには、この値を更新するための代入演算子があります。

template<class T>
struct Wrapper {
    T& ref;

    Wrapper(T& ref)
    : ref(ref){}

    template<class U>
    void operator=(U u) {
        ref = u;
    }
};

template<class...T>
auto sth(T&...t) {
    return std::array< Wrapper<std::common_type_t<T...> > ,sizeof...(t) >{Wrapper(t)...};
};

int main(){
    int a{},b{},c{},d{};

    for (auto s : sth(a,b,c,d)) {
        s = 1;
    }
    std::cout << a << std::endl; // 1

ライブデモ