C++17 initialzer list aus std::array

[nga (Gast)]

Hallo,

ich würde gerne in einem C++ Projekt ein Grid (2D-Array) aus floats 
beschreiben.

Dafür gibt es eine Klasse

#include <cstddef>
template<std::size_t rows, std::size_t columns>
class grid {
    std::array<std::array<float, columns>, rows> elements;
public:
    constexpr grid(const std::initializer_list<float> list) noexcept;
    // ...member functions...
};

Aktuell kann ich die Klasse so initialisieren:

grid<2,2>{
    1, 2,
    3, 4
};

Dabei ist es allerdings leicht Fehler zu machen, z.B. eine falsche 
Grid-Größe oder zu viele Werte werden angegeben, z.B.:

grid<1,3>{
    1, 2, 3,
    4, 5, 6
};
// Grid: [[1,2,3]] anstatt den "optisch erwarteten" [[1,2,3],[4,5,6]]

Auch blöd ist, dass man Zeilen und spalten vertauschen kann:

grid<4,2>{
    1,1,1,1,
    2,2,2,2
};
// Grid: [[1,1],[1,1],[2,2],[2,2]] anstatt [[1,1,1,1],[2,2,2,2]]

Soweit der aktuelle Stand.



Nervig finde ich erstens, dass man die template-Parameter bei dieser 
Version explizit angeben muss (und damit Fehler machen kann) und 
zweitens, dass der Benutzer 1 Array (bzw. eine Initializer list, aber 
die sieht ja aus wie ein Array) angibt, obwohl es ja eine 2D-Struktur 
ist. Ich finde, man sollte im Code sehen, wie groß das Grid ist.

Ich würde nun gerne einen Konstruktor schreiben, der das erlaubt:

grid{{1,2},{3,4},{5,6}};
// bzw. optisch ansprechender
grid{
    {1, 2},
    {3, 4},
    {5, 6}
};
// Grid: 3x2 [[1,2],[3,4],[5,6]]
// Template parameter automatisch erkannt

Schön wäre es außerdem, wenn das Programm nicht kompiliert, wenn die 
inneren Arrays nicht gleich lang sind.

Wichtig ist aber, dass alles constexpr ist, also zum Beispiel mittels 
static_assert() überprüfbar.

Gibt es so ein Konstrukt im aktuellen C++?

Mit freundlichen Grüßen,
nga

[Wilhelm M. (wimalopaan)]

Auf die Schnelle sehe ich zwei Varianten:

    constexpr auto g = make_grid(1, 2)(3, 4)();
    
    constexpr auto g = grid{R{1, 2}, R{3, 4}};

Man kann zwar initializer_list verschachteln, allerdings sehe ich gerade 
keine Möglichkeit die Länge einer inilializer_list als constexpr zu 
ermitteln, wenn die initializer_list als Funktionsparameter übergeben 
wird, da sie in diesem Kontext wieder nicht mehr constexpr ist.

Deswegen sehe ich erstmal nur die beiden Möglichkeiten oben. Einmal mit 
einer Factory und op() oder einem Helper-Typ R.

[Wilhelm M. (wimalopaan)]

Man kann auf den helper make_grid() auch verzichten, wenn man ein DGuide 
einsetzt:

    constexpr auto g = grid(1, 2)(3, 4)(5, 6);

Passt das für Dich? Wenn ja, schreibe ich es ausführlich hin ...

[nga (Gast)]

Hallo Wilhelm M.,

danke für deine Beiträge.
An die Möglichkeit einer Factory habe ich gar nicht gedacht, die Idee 
ist gut.
Der Helper-Typ ist zwar von der Idee auch nicht schlecht und vmtl. 
einfach zu implementieren, aber sagt mir ehrlich gesagt nicht so zu.

Wilhelm M. schrieb:
> Man kann auf den helper make_grid() auch verzichten, wenn man ein DGuide
> einsetzt:

     constexpr auto g = grid(1, 2)(3, 4)(5, 6);

> Passt das für Dich?

Diese Möglichkeit finde ich sehr schön, aber ich muss jetzt (mglw. blöd) 
fragen: Was ist ein DGuide? Ich habe diesen Begriff noch nie gehört.

Es wäre nett, wenn du entweder Informationen verlinken könntest oder 
eine Beispiel-Signatur des Konstruktor schreiben würdest (irgendwie 
komme ich gerade nicht drauf, wie man das einfach Implementieren kann).

Grüße,
nga

[Wilhelm M. (wimalopaan)]

nga schrieb:

> Wilhelm M. schrieb:
>> Man kann auf den helper make_grid() auch verzichten, wenn man ein DGuide
>> einsetzt:
>

>      constexpr auto g = grid(1, 2)(3, 4)(5, 6);
>

>> Passt das für Dich?
>
> Diese Möglichkeit finde ich sehr schön, aber ich muss jetzt (mglw. blöd)
> fragen: Was ist ein DGuide? Ich habe diesen Begriff noch nie gehört.

Damit ist ein user-defined deduction-guide gemeint. Beispiel kommt 
gleich ...

[Wilhelm M. (wimalopaan)]

Hier (s.u.) eine Möglichkeit ohne Helper-Funktion. Der "Trick" besteht 
darin, das grid<> ein Functor ist, der hier als factory benutzt wird.

#include <cstddef>
#include <array>
#include <algorithm>
#include <iostream>
#include <cassert>

// little bit of TMP (see below: deduction-guide)
namespace Meta {
    template<typename... T> struct List;
    namespace detail {
        template<typename L> struct front;
        template<typename F, typename... T, template<typename...> typename L>
        struct front<L<F, T...>> {
            typedef F type;
        };
    }
    template<typename L>
    using front = typename detail::front<L>::type;
}

template<typename ItemType, std::size_t rows, std::size_t columns>
class grid {
    std::array<std::array<ItemType, columns>, rows> elements{};
public:
    template<typename... VV>
    constexpr grid(const VV&... vv) : elements{{ItemType(vv)...}} {
        static_assert(sizeof...(VV) == columns, "wrong number of columns");
    }

    template<typename... AA>
    constexpr grid(const std::array<ItemType, columns>& a, const AA&... aa) : elements{a, aa...} {
        static_assert(sizeof...(AA) == (rows - 1), "wrong number of rows");
        static_assert((std::is_same_v<ItemType, typename AA::value_type> && ...));
    }
    
    template<typename... VV>
    constexpr auto operator()(VV... rv) {
        static_assert(sizeof...(VV) == columns, "wrong number of values to form a complete row");
//        static_assert((std::is_same_v<ItemType, VV> && ...), "use always the same type"); 
        auto n = [&]<auto... RR>(std::index_sequence<RR...>) { // C++20, refactor to function-template if C++17
                std::array<ItemType, columns> nextRow{ItemType(rv)...};
                grid<ItemType, rows + 1, columns> n{(*this)[RR]..., nextRow};
                return n;
        }(std::make_index_sequence<rows>{});
        return n;
    }
    
    constexpr auto& operator[](size_t row) const {
        assert(row < rows);
        return elements[row];
    }
};

// user-defined deduction-guide
template<typename... RR>
grid(RR... rr) -> grid<Meta::front<Meta::List<RR...>>, 1, sizeof...(RR)>;

int main() {
    constexpr auto g1 = grid(1.0, 2.0)(3, 4)(5, 6); // grid<double, 3, 2>
    constexpr auto g2 = grid(1, 2)(3, 4)(5, 6); // grid<int, 3, 2>
}

Wie schon beschrieben, sind std::initializer_list's hier nur wenig 
geeignet, da sie in einem constexpr-Kontext nur schlecht funktionieren. 
Es gab mal einen Entwurf, die Länge statisch als member-typ zur 
Verfügung zu stellen ...

Mit concepts können man die überladenen ctor'en etwas besser gestalten.

[nga (Gast)]

Hallo,

danke für das Beispiel!
Ich werde allerdings wohl etwas brauchen, bis ichs komplett verstanden 
habe. Mir sind das irgendwie zu viele "..." :-)

Grüße und nochmals vielen Dank,
nga

[nga (Gast)]

Hallo,

ich muss mich nochmal als unfähig/unwissend outen... (mach ich nicht 
gerne :-) ).

Betreffend dieses Parts:

Wilhelm M. schrieb:
> template<typename... VV>
>     constexpr auto operator()(VV... rv) {
>         static_assert(sizeof...(VV) == columns, "wrong number of values
> to form a complete row");
> //        static_assert((std::is_same_v<ItemType, VV> && ...), "use
> always the same type");
>         auto n = [&]<auto... RR>(std::index_sequence<RR...>) { // C++20,
> refactor to function-template if C++17
>                 std::array<ItemType, columns> nextRow{ItemType(rv)...};
>                 grid<ItemType, rows + 1, columns> n{(*this)[RR]...,
> nextRow};
>                 return n;
>         }(std::make_index_sequence<rows>{});
>         return n;
>     }
Ich möchte das ganze erst mal mit der aktuellsten verabschiedeten 
Version der Sprache machen, also C++17 (ohne GNU extensions o.Ä.).
Also kann ich das Lambda Template so in der Art (wie du netterweise 
geschrieben hast) nicht verwenden -.-
Ich habe mich mal hingesetzt und versucht das ganze mittels 
template-Funktionen nachzubilden (Compiler Explorer): 
https://godbolt.org/g/ZBvVES

Leider kenne ich mich mit TMP im Prinzip gar nicht aus und ich kann 
weder mit der GCC-Fehlermeldung, noch mit der von clang etwas 
anfangen...

GCC:

note:   template argument deduction/substitution failed:
note:   mismatched types 'std::integer_sequence<long unsigned int, RR ...>' and 'int'
return expand_grid(rv..., std::make_index_sequence<rows>{});
                                                              ^

clang:

note: in instantiation of function template specialization 'grid<double, 1, 2>::operator()<int, int>' requested here
note: candidate template ignored: could not match 'integer_sequence<unsigned long, RR...>' against 'int'

(Genaueres alles im Compiler Explorer zu sehen)

Ich denke, dass ich einen trivialen Fehler

Es wäre furchbar nett, wenn du mir noch einmal auf die Sprünge helfen 
könntest, oder entsprechende Literatur zu aktueller C++ TMP empfehlen 
könntest.

Grüße,
nga

[Wilhelm M. (wimalopaan)]

Du hast nur die Reihenfolge der Argumente vertauscht:

        return expand_grid(std::make_index_sequence<rows>{}, rv... );

Das erste Argument muss ja die std::index_sequence<> sein, danach 
folgende die Werte der neuen Zeile.

[nga (Gast)]

Manchmal sieht man den Wald vor lauter Bäumen/... nicht :-)

Nochmals vielen Dank für deine Hilfe!

Grüße,
nga