Clang beschwert: „Zeiger durch ein temporäres Array initialisiert wird“

Question

Ich habe eine Reihe von (Zeiger) Arrays von verschiedenen Längen, die ich habe ich gelernt, konnte unter Verwendung der Verbindung Literale definieren:

const uint8_t *const minutes[] = { 
    (const uint8_t[]) {END}, 
    (const uint8_t[]) {1, 2, 3, 4, 5 END}, 
    (const uint8_t[]) {8, 9, END}, 
    (const uint8_t[]) {10, 11, 12, END}, 
    ... 
}; 

gcc dies akzeptiert nur gut, aber Klang sagt: pointer is initialized by a temporary array, which will be destroyed at the end of the full-expression. Was bedeutet das? Der Code scheint zu funktionieren, aber andererseits scheinen viele Dinge zu funktionieren, wenn sie auf Speicher zeigen, der nicht mehr zugeordnet ist. Muss ich mir deswegen Sorgen machen? (Letztendlich brauche ich es nur wirklich, um mit gcc zu arbeiten.)

Update: Etwas faul ist los. Es sagt here dass:

Compound literals yield lvalues. This means that you can take the address of a compound literal, which is the address of the unnamed object declared by the compound literal. As long as the compound literal does not have a const-qualified type, you can use the pointer to modify it.

`struct POINT *p; 
    p = &(struct POINT) {1, 1}; 

Dieses Beispiel Code genau zu tun scheint, was ich versuche zu tun: durch eine Verbindung wörtliche definiert einen Zeiger auf etwas. Also ist die Clam-Fehlermeldung legitim? Wird dies auf nicht zugewiesenen Speicher zeigen, wenn entweder mit clang oder gcc kompiliert wird?

Update 2: fand einig documentation: „In C wird eine Verbindung Literal bezeichnet ein unbenannte Objekt mit statischer oder dynamischer Speicher Dauer In C++ ist eine Verbindung literal ein temporäres Objekt bezeichnet, die sie nur bis zum Ende lebt. "So scheint es, dass clang ist richtig, davor zu warnen, und gcc wahrscheinlich sollte auch, aber nicht, auch mit -Wall -Wextra.

Ich kann nicht erraten, warum ein nützliches C-Feature aus C++ entfernt wurde, und es wurde kein eleganter alternativer Weg gefunden, dasselbe zu erreichen.

Answer 1

Nun, Klirren ist richtig, und das soll auch so geschehen:

namespace elements 
{ 
    const uint8_t row1[] = {END}; 
    const uint8_t row2[] = {1, 2, 3, 4, 5, END}; 
    ... 
} 
const uint8_t *const minutes[] = { 
    elements::row1, 
    elements::row2, 
    ... 
}; 

Sie können mehr C++ denken Lösung, wie std::tuple mit:

#include <tuple> 

constexpr auto minutes = std::make_tuple(
    std::make_tuple(), 
    std::make_tuple(1,2,3,4,5), 
    std::make_tuple(8,9,10)); 

#include <iostream> 
#include <type_traits> 
int main() { 
    std::cout << std::tuple_size<decltype(minutes)>::value << std::endl; 
    std::cout << std::tuple_size<std::remove_reference_t<decltype(std::get<1>(minutes))>>::value << std::endl; 
} 

Answer 2

Nun, das heißt, dieser Ausdruck

(const uint8_t[]) {1, 2, 3, 4, 5 END}, 

erstellt ein temporäres Objekt — vorübergehend, weil es keinen Namen hat, das über den Ausdruck von dem es ein Teil ist, dauern kann —, die am Ende zerstört werden des vollen Ausdruck, was das bedeutet: Bekomme

definiert „den vollen Ausdruck“, an welcher Stelle alle temporären Objekte zerstört, ein nd das Array von Zeigern minutes enthält Zeiger, die auf zerstört Objekte zeigen, weshalb der Compiler warnt.

Hoffe, dass hilft.

Answer 3

update: danke an den Hinweis für den Fehler in der ursprünglichen Lösung.

static constexpr uint8_t END = 0xff; 

template<uint8_t...x> 
const uint8_t* make() 
{ 
    static const uint8_t _[] = { x..., END }; 
    return _; 
} 

const uint8_t* const array[] = { 
    make<>(), 
    make<1, 2, 3, 4, 5>(), 
    make<8, 9>(), 
    make<10, 11, 12>() 
};