1) El ejemplo de Ilya debe ser un código no válido basado en el hecho de que la barra de miembros de datos constexpr estática se inicializa fuera de línea violando la siguiente instrucción en el estándar:

9.4.2 [clase.estática.datos] p3: ... Un miembro de datos estático de tipo literal se puede declarar en la definición de clase con el especificador constexpr; si es así, su declaración especificará un inicializador de llave o igual en que cada inicializador-cláusula de que es una tarea de expresión es un expresión constante.

2) El código en la pregunta de MvG:

class C1 {
  constexpr static int foo(int x) { return x + 1; }
  constexpr static int bar = foo(sizeof(int));
};

Es válido por lo que veo e intuitivamente uno esperaría que funcionara porque el miembro estático foo(int) se define por el tiempo de procesamiento de bar comienza (asumiendo el procesamiento de arriba hacia abajo). Algunos hechos:

• Estoy de acuerdo, sin embargo, que la clase C1 no está completa en el punto de invocación de foo (basado en 9.2p2) pero lo completo o incompleto de la clase C1 no dice nada acerca de si foo está definido en lo que respecta al estándar.
• Busqué en el estándar la definición de las funciones miembro, pero no encontré nada.
• Así que la declaración mencionada por Ben no se aplica aquí si mi lógica es válida:

  Una invocación de una función constexpr indefinida o una función undefined constructor constexpr fuera de la definición de una función constexpr o un constructor constexpr;

class C1
{
  constexpr static int foo() { return bar; }
  constexpr static int bar = foo();
};

Parece inválido pero por diferentes razones y no simplemente porque foose llama en el inicializador de bar. La lógica es la siguiente:

• foo () se llama en el inicializador de la barra de miembros constexpr estática, por lo que tiene que ser una expresión constante (por 9.4.2 p3).
• dado que es una invocación de una función constexpr, la invocación de la función la sustitución (7.1.5 p5) entra en acción.
• No hay parámetros para la función, por lo que lo que queda es "convertir implícitamente la expresión devuelta resultante o la lista de inicio entre corchetes al tipo de retorno de la función como si fuera por inicialización de copia."(7.1.5 p5)
• la expresión de retorno es simplemente bar, que es un lvalue y se necesita la conversión lvalue a rvalue.

• Pero por la viñeta 9 en (5.19 p2) que bar no satisface porque todavía no se ha inicializado:

  • una conversión lvalue a rvalue (4.1) a menos que se aplique a:
    • un glvalue de tipo integral o enumeración que se refiere a un objeto const no volátil con una inicialización anterior, inicializado con una expresión constante.

• Por lo tanto, la conversión lvalue a rvalue de bar no produce una expresión constante que no cumpla con el requisito en (9.4.2 p3).

• así que por bullet 4 in (5.19 p2), la llamada a foo () no es una expresión constante:

  Una invocación de una función constexpr con argumentos que, cuando son sustituidos por sustitución de invocación de función (7.1.5), no producen una expresión constante

#include <iostream>

class C1 
{
public:
    constexpr static int foo(constexpr int x)
    { 
        return x + 1;
    }

    static constexpr int bar;
};

constexpr int C1::bar = C1::foo(sizeof(int));

int main()
{
    std::cout << C1::bar << std::endl;
    return 0;
}

Tal inicialización funciona bien, pero solo en clang

Probablemente, el problema aquí está relacionado con el orden de la declaración/definiciones en una clase. Como todos saben, puede usar cualquier miembro incluso antes de que sea declarado / definido en una clase.

Cuando se define el valor de constexpr en la clase, el compilador no tiene la función constexpr disponible para ser utilizada porque está dentro de la clase.

Quizás, La respuesta de Philip, relacionada con esta idea, es un buen punto para entender la pregunta.

Tenga en cuenta este código que compila sin problemas:

constexpr int fooext(int x) { return x + 1; }
struct C1 {
  constexpr static int foo(int x) { return x + 1; }
  constexpr static int bar = fooext(5);
};

constexpr static int barext = C1::foo(5);