Come verificare in fase di compilazione che un'espressione è illegale?

Question

Ho un problema nella mia applicazione in cui vorrei affermare che un'applicazione di compilazione sarebbe stata rifiutata dal compilatore. C'è un modo per controllare questo con SFINAE?

Ad esempio, supponiamo che mi piacerebbe convalidare che std::transform in un intervallo const non è valido. Ecco cosa ho finora:

#include <algorithm> 
#include <functional> 
#include <iostream> 

namespace ns 
{ 

using std::transform; 

template<typename Iterator1, typename Iterator2, typename UnaryFunction> 
    struct valid_transform 
{ 
    static Iterator1 first1, last1; 
    static Iterator2 first2; 
    static UnaryFunction f; 

    typedef Iterator2     yes_type; 
    typedef struct {yes_type array[2];} no_type; 

    static no_type transform(...); 

    static bool const value = sizeof(transform(first1, last1, first2, f)) == sizeof(yes_type); 
}; 

} 

int main() 
{ 
    typedef int *iter1; 
    typedef const int *iter2; 
    typedef std::negate<int> func; 

    std::cout << "valid transform compiles: " << ns::valid_transform<iter1,iter1,func>::value << std::endl; 

    std::cout << "invalid transform compiles: " << ns::valid_transform<iter1,iter2,func>::value << std::endl; 

    return 0; 
} 

Sfortunatamente, il mio tratto respinge sia i casi legali che quelli illegali. Il risultato:

$ g++ valid_transform.cpp 
$ ./a.out 
valid transform compiles: 0 
invalid transform compiles: 0 

Answer 1

La tua domanda è simile a SFINAE + sizeof = detect if expression compiles.

Sintesi di quella risposta: sizeof valuta il tipo dell'espressione passata ad esso, tra cui un'istanza di un modello di funzione, ma non genera una chiamata di funzione. Questo è il motivo dietro le osservazioni di Lol4t0 che lo sizeof(std::transform(iter1(), iter1(), iter2(), func())) compila anche se non lo è std::transform(iter1(), iter1(), iter2(), func()).

Il tuo problema concreto può essere risolto valutando il modello dalla risposta di Lol4t0 per qualsiasi intervallo di output che deve essere fornito a . Tuttavia, il problema generale di verificare in un modello che una chiamata di funzione verrà compilata sembra impossibile da risolvere con il trucco sizeof + SFINAE. (richiederebbe un'espressione in fase di compilazione derivabile da una chiamata di funzione in fase di esecuzione).

Si consiglia di provare ConceptGCC per verificare se questo consente di esprimere il controllo di compilazione richiesto in un modo più conveniente.

Answer 2

Nella mia risposta, I'dd piace concentrarsi su problemi, come determinare, se dato iteratore costante: std::is_const è stato menzionato, ma non funziona in questo caso per me (GCC 4.7).

presumo, si implemeted come

template <typename T> 
struct is_const 
{ 
    enum {value = false }; 
}; 

template <typename T> 
struct is_const<const T> 
{ 
    enum {value = true }; 

}; 

Ora, non si può controllare i tipi di riferimento con questo struct, non sarebbe partita la specializzazione, perché const T sarebbe partita int& const, cioè riferimento costante a int, non const int&, ovvero riferimento a costante int, e in primo luogo non ha alcun senso.

Ok, ma siamo in grado di determinare, se iteratore è costante con la struct follwing:

template <typename Iterator> 
struct is_iterator_constant 
{ 
    typedef char yes_type; 
    typedef struct{ char _[2];} no_type; 
    template <typename T> 
    static no_type test(T&); 

    template <typename T> 
    static yes_type test(...); 

    enum {value = sizeof(test<typename std::iterator_traits<Iterator>::value_type>(*Iterator())) == sizeof(yes_type) }; 

};