Unschuldiger Bereich basierend auf Schleife funktioniert nicht

Folgendes wird nicht kompiliert:

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

Probieren Sie es auf Godbolt

Compilerfehler ist: error: assignment of read-only reference 's'

In meinem aktuellen Fall besteht die Liste nun aus Mitgliedsvariablen einer Klasse.

Dies funktioniert jetzt nicht, da der Ausdruck zu einem wird initializer_list<int>, der tatsächlich a, b, c und d kopiert - und daher auch keine Änderung zulässt.

Meine Frage ist zweifach:

Gibt es eine Motivation, auf diese Weise keine bereichsbasierte for-Schleife schreiben zu dürfen? z.B. Vielleicht könnte es einen Sonderfall für nackte Zahnspangen geben.

Was ist eine syntaktisch saubere Methode, um diese Art von Schleife zu reparieren?

Etwas in dieser Richtung wäre vorzuziehen:

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

Ich halte Zeiger-Indirektion nicht für eine gute Lösung (das heißt {&a, &b, &c, &d}) - jede Lösung sollte die Elementreferenz direkt angeben, wenn der Iterator de-referenziert wird .

Bereiche sind nicht so magisch, wie die Leute es gerne hätten. Am Ende muss es ein Objekt geben, mit dem der Compiler entweder eine Mitgliedsfunktion oder eine freie Funktion begin()und aufrufen kann end().

Am nächsten kommen Sie wahrscheinlich:

#include <iostream>

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

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

Nur eine weitere Lösung innerhalb einer Wrapper-Idee:

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...});
}

Dann:

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;
}

Ausgänge

0000
1111

Gemäß dem Standard §11.6.4 Listeninitialisierung / p5 [dcl.init.list] [ Emphasis Mine ]:

Ein Objekt vom Typ 'std :: initializer_list' wird aus einer Initialisierungsliste erstellt, als ob die Implementierung einen Wert vom Typ "Array von N const E" generiert und materialisiert (7.4) hätte , wobei N die Anzahl der Elemente in der Initialisierungsliste ist. Jedes Element dieses Arrays wird mit dem entsprechenden Element der Initialisierungsliste kopierinitialisiert, und das Objekt std :: initializer_list wird so konstruiert, dass es auf dieses Array verweist. [Hinweis: Auf einen für die Kopie ausgewählten Konstruktor oder eine Konvertierungsfunktion muss im Kontext der Initialisierungsliste zugegriffen werden können (Abschnitt 14). - Endnote] Wenn eine Verengungskonvertierung erforderlich ist, um eines der Elemente zu initialisieren, ist das Programm fehlerhaft.

Daher beschwert sich Ihr Compiler zu Recht (dh auto &szieht ab int const& sund Sie können nicht sin der for-Schleife für den Bereich zuweisen ).

Sie können dieses Problem beheben, indem Sie einen Container anstelle einer Initialisiererliste (z. B. "std :: vector") mit "std :: reference_wrapper" einführen:

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

Live-Demo

Um diese Syntax zu erfüllen

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

Sie könnten einen Wrapper erstellen:

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;     
};

Demo

Lösung: Verwenden Sie einen Referenz-Wrapper

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() };
    }
};

Dann verwendet als:

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

Dies versucht jedoch nicht, die erste Frage zu beantworten.

Sie können eine Wrapper-Klasse zum Speichern von Referenzen erstellen, die über einen Zuweisungsoperator verfügt, um diesen Wert zu aktualisieren:

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

Live-Demo