Nie można skonstruować constexpr tablicę z usztywnione-init-listy

Question

I zostały wdrożone constexpr tablicę tak:

template <typename T> 
class const_array { 
    const T* p; 
    unsigned n; 
public: 
    template <unsigned N> 
    constexpr const_array(const T(&a)[N]): p(a), n(N) { } 

    constexpr unsigned size() const { return n; } 
}; 

int main(int argc, char* argv[]) { 
    // works 
    static_assert(const_array<double>{{1.,2.,3.}}.size() == 3); 

    // doesn't compile 
    constexpr const_array<double> a{{1.,2.,3.}}; 
    static_assert(a.size() == 3); 
} 

Dlaczego jest to, że pierwszy static_assert kompiluje, ale inicjowanie a nie używam gcc 6.2? .0. Dostaję

: In function 'int main(int, char**)': 
: error: 'const_array<double>{((const double*)(&<anonymous>)), 3u}' is not a constant expression 
    constexpr const_array<double> a{{1.,2.,3.}}; 
             ^
test/const_array.cc:17:3: error: non-constant condition for static assertion 
    static_assert(a.size() == 3); 
    ^~~~~~~~~~~~~ 

Answer 1

Kompilator narzeka, że ​​inicjator od a.p nie jest stałą ekspresję. Zawodzi: § 5.20/5.2:

jeśli wartość jest typu wskaźnika, zawiera adres obiektu z czasem przechowywania statycznego, adres znajdujący się za końcem takiego obiektu (5.7), adres funkcja lub wartość wskaźnika pustego

Innymi słowy, tylko wartości wskaźników znane linkerowi są poprawnymi stałymi. (Również w przykładzie wskaźnik jest zwisające.)

Pierwszy static_assert nie potknąć tego powodu p odrzuca się, a wartość n jest stałą ekspresję. Wyrażenia stałe mogą mieć nieciągłe podwyrażenia.

to działa:

static constexpr double arr[] = { 1.,2.,3. }; 
constexpr const_array<double> a{ arr }; 
static_assert(a.size() == 3); 

kredytową do @ Jarod42 za wskazanie problemu w komentarzach.

Answer 2

Problem polegał na tym, że nie można przesyłać stałej natury wskaźnika do T w szablonie wewnętrznym za pomocą parametru T szablonu zewnętrznego.

template <typename T> class const_array { 
    const T * p; 
    unsigned n; 
public: 
    template <unsigned N> 
     constexpr const_array(const T(& a)[N]): p(a), n(N) { } 
}; 

int main(int argc, char* argv[]) { 
    constexpr const_array<double> ca{(const double []) { 1., 2. }}; 
    return 0; 
} 

Próbowałem kilkadziesiąt permutacje pozbyć obsady bez powodzenia.