Regole per la restituzione di riferimenti a oggetti falsi in C++

Question

Vorrei eseguire un'iterazione su un array float pre-allocato con un contenitore personalizzato che non possiede i dati, ma che agisce su un segmento di esso. Esempio, nominando la classe contenitore LinhaSobre:

std::unique_ptr<float[]> data(new float[720]); 
... 
//creates container to iterate 26 floats starting from from data[12] 
    LinhaSobre cont(data.get()+12, 26); 
//sets those elements to 1.5 
    for(size_t i = 0; i < cont.size(); i++) 
     cont[i] = 1.5f; 

Ecco una possibile implementazione del operator[]:

//... 
//LinhaSobre has a member mem0 which is initialized 
//as a pointer to where the interval starts 
float & LinhaSobre::operator[] (size_t i) 
{ 
    return *(mem0+i); 
} 

Si noti che sto tornando un riferimento da LinhaSobre::operator[] a dati che non si possiede. Non dovrebbe interferire con la durata dei dati (costruttori, distruttori).

Ora desidero esporre lo data memorizzato con un altro motivo, std::array<float,4> e non puro float. Esempio, nominando la nuova classe LinhaSobre4f:

std::unique_ptr<float[]> data(new float[720]); 
... 
//creates container to iterate 4 array<float, 4> starting from from data[12] 
    LinhaSobre4f l(data.get()+(3*4), 4); 
//sets those elements to {1.5f, 2.5f, 3.5f, 4.5f}; 
    for(size_t i = 0; i < l.size(); i++) 
     l[i] = { {1.5f, 2.5f, 3.5f, 4.5f} }; 

Si noti che io tratto le voci come una matrice. Ciò porterebbe ad alcuni cambiamenti nella classe contenitore, la mia preoccupazione principale è con il operator[], ecco il codice completo della classe:

struct LinhaSobre4f 
{ 
    LinhaSobre4f(float * pos_begin, size_t size_): 
     pos0(pos_begin), 
     size_(size_){} 
    std::array<float, 4> & operator[](size_t i)const 
    { 
     std::array<float,4> * r = 
      reinterpret_cast<std::array<float,4>*> (pos0+(4*i)); 
     return *r; 
    } 
    size_t size()const 
    { 
     return size_; 
    } 
private: 
    float * pos0; 
    size_t size_; 
}; 

Il operator[] restituisce un riferimento a un blocco di memoria trattato come un std::array<float,4> che mai esisteva come tale, ma data la garanzia del layout di memoria std::array, funziona. Sono dubbioso su questo, va bene? (a parte l'allineamento della memoria, che garantirò). Sono autorizzato a esporre un oggetto come questo, semanticamente? Qual è il termine corretto per questo? (Ho usato oggetto falso nel titolo).

Here's a live demo of the example. Here's another (the other link sometimes fails)

Answer 1

Il C++ standard (sto leggendo C++ 11) definisce un std::array come segue:

Le condizioni per un aggregato (8.5.1) sono soddisfatte.

Non è garantito che un std::array sia un POD. Lo standard C++ garantisce solo che si tratta di un aggregato di classe.

In base a ciò, credo che l'utilizzo di reinterpret_cast per convertire un array POD di float s in un std::array non sia un comportamento definito.

È probabile che funzioni con il compilatore, ma non è garantito che ciò sia portatile o legale.

Answer 2

Si potrebbe creare una pianura vecchio reference_type:

struct LinhaSobre4f { 
    struct Ref { 
     Ref(float *m): m(m){}; 
     Ref &operator=(std::initializer_list<float> const &l) { 
      std::copy(l.begin(), l.end(), m); 
      return *this; 
     } 
    private: 
     float *m; 
    }; 
    Ref operator[](size_t i) { return m + 4 * i; } 
private: 
    float *m; 
}; 

Answer 3

aggiunta alla risposta di Sam Varshavchik, si può essere interessati nel tipo span (formerly known as array_view).

Il tipo span è un'astrazione che fornisce una vista su una sequenza contigua di oggetti, la memorizzazione dei quali è di proprietà di un altro oggetto (maggiori dettagli in P0122R1, CppCoreGuidelines e Guidelines Support Library Review: span<T>).

Concettualmente, uno span è semplicemente un puntatore a qualche archivio e un conteggio degli elementi accessibili tramite quel puntatore. È così piccolo che può essere passato per valore.

An open source (solo intestazione), implementazione di riferimento è disponibile a https://github.com/Microsoft/GSL (attuazione assume generalmente una piattaforma che implementa C++ 14 di supporto. Esistono soluzioni specifiche per sostenere MSVC 2013 e 2015).