Decidí dar entonces nuevoC++14 definicion deconstexpr un giro y para aprovecharlo al máximo decidí escribir un pequeño analizador de cadenas en tiempo de compilación. Sin embargo, estoy luchando por mantener mi objetoconstexpr mientras lo pasa a una función. Considere el siguiente código:

#include <cstddef>
#include <stdexcept>

class str_const {
    const char * const p_;
    const std::size_t sz_;
public:
    template <std::size_t N>
    constexpr str_const( const char( & a )[ N ] )
    : p_( a ), sz_( N - 1 ) {}
    constexpr char operator[]( std::size_t n ) const {
        return n < sz_ ? p_[ n ] : throw std::out_of_range( "" );
    }
    constexpr std::size_t size() const { return sz_; }
};

constexpr long int numOpen( const str_const & str ){
    long int numOpen{ 0 };
    std::size_t idx{ 0 };
    while ( idx <  str.size() ){
        if ( str[ idx ] == '{' ){ ++numOpen; }
        else if ( str[ idx ] == '}' ){ --numOpen; }
        ++idx;
    }
    return numOpen;
}

constexpr bool check( const str_const & str ){
    constexpr auto nOpen = numOpen( str );
    // ...
    // Apply More Test functions here,
    // each returning a variable encoding the correctness of the input
    // ...

    return ( nOpen == 0 /* && ... Test the variables ... */ );
}

int main() {
    constexpr str_const s1{ "{ Foo : Bar } { Quooz : Baz }" };
    constexpr auto pass = check( s1 );
}

Yo uso elstr_const clase presentado porScott Schurr en C ++ ahora 2012 en una versión modificada paraC++14.

El código anterior no se compilará con el error (clang-3.5)

error: constexpr variable 'nOpen' must be initialized by a constant expression  
    constexpr auto nOpen = numOpen( str );  
                           ~~~~~~~~~^~~~~

Lo que me lleva a la conclusión de que no puedes pasarconstexpr objetar sin perder suconstexpr-ness. Esto me lleva a las siguientes preguntas:

¿Es correcta mi interpretación?

¿Por qué es este el comportamiento que dicta la norma?

No veo el problema al pasar unconstexpr objeto alrededor. Claro, podría reescribir mi código para que encaje en una sola función, pero eso lleva a un código reducido. Supongo que factorizar funcionalidades separadas en unidades separadas de código (funciones) también debería ser un buen estilo para las operaciones de tiempo de compilación.

Como dije antes, el error del compilador se puede resolver moviendo el código de los cuerpos de las funciones de prueba separadas (comonumOpen) en el cuerpo de lanivel superior funcióncheck. Sin embargo, no me gusta esta solución, ya que crea una función enorme y estrecha. ¿Ves un enfoque diferente para resolver el problema?