const riferimento funzione di membro qualificato

Question

Lo stock esempio di una funzione membro di riferimento qualificato sembra essere qualcosa di simile:

#include <stdio.h> 
#include <stdexcept> 
#include <string> 

// Easy access to literals 
using namespace std::literals; 

// File wrapper 
class File { 
    private: 
    // The wrapped file 
    FILE *_file; 
    public: 
    File(const char *name) : 
     _file(fopen(name, "r")) { 
     // unable to open the file? 
     if (!_file) throw std::runtime_error{ "Unable to open file: "s + name }; 
    } 
    ~File() { 
     fclose(_file); 
    } 

    // Convert to the underlying wrapped file 
    operator FILE *() & { 
     return _file; 
    } 

    // TODO: Member functions for working with the file 
}; 

Questo metodo funziona bene. Non è possibile recuperare direttamente il puntatore FILE sottostante da un temporaneo senza nome. Tuttavia, se rendiamo anche l'operatore di casting const-qualificato, questo sembra non funzionare più.

Diversi compilatori semplicemente lo inghiottono senza lamentarsi anche se è un'idea terribilmente utile. Prendi, ad esempio, la funzione membro std :: string :: c_str(). Si ritiene che dovrebbe essere qualificato come riferimento (perché altrimenti si dispone di un puntatore non valido) eppure non lo è.

Si tratta di un buco nello standard C++ 11? Mi sto perdendo qualcosa qui?

Answer 1

Un oggetto temporaneo può essere associato a un oggetto qualificato const& e il qualificatore di qualifica effettivamente qualifica l'oggetto implicitamente passato (*this). Se si desidera impedire chiamate su provvisori ma consentire lvalue, è possibile = delete il sovraccarico di riferimento rvalore e implementare la versione lvalue. Utilizzando const qualificazioni di riferimento qualificato sia per gli operatori richiede un solo attuata e un'implementazione = delete d:

class File { 
    // ... 
    FILE* _file; 
public: 
    operator FILE*() const&& = delete; 
    operator FILE*() const& { return this->_file; } 
    // ... 
}; 

L'effetto netto è che si può utilizzare la conversione solo per gli oggetti a cui si va un lvalue:

int main() { 
    File  f; 
    File const cf{}; 

    FILE* fp = f;    // OK 
    FILE* cfp = cf;   // OK 
    FILE* tfp = File();  // ERROR: conversion is deleted 
    FILE* mfp = std::move(cf); // ERROR: conversion is deleted 
}