Constexpr implica inline?

Considere a seguinte função embutida:

// Inline specifier version
#include<iostream>
#include<cstdlib>

inline int f(const int x);

inline int f(const int x)
{
    return 2*x;
}

int main(int argc, char* argv[])
{
    return f(std::atoi(argv[1]));
}

e a versão equivalente constexpr:

// Constexpr specifier version
#include<iostream>
#include<cstdlib>

constexpr int f(const int x);

constexpr int f(const int x)
{
    return 2*x;
}

int main(int argc, char* argv[])
{
    return f(std::atoi(argv[1]));
}

Minha pergunta é: o constexprespecificador implica o inlineespecificador no sentido de que se um argumento não constante for passado para uma constexprfunção, o compilador tentará inlinea função como se o inlineespecificador tivesse sido colocado em sua declaração?

O padrão C ++ 11 garante isso?

Sim ([dcl.constexpr], §7.1.5 / 2 no padrão C ++ 11): "funções constexpr e construtores constexpr são implicitamente embutidos (7.1.2)."

Observe, entretanto, que o inlineespecificador realmente tem muito pouco (se houver) efeito sobre a probabilidade de um compilador expandir uma função embutida ou não. No entanto, isso afeta a regra de definição única e, dessa perspectiva, o compilador deve seguir as mesmas regras para uma constexprfunção como uma inlinefunção.

Devo também acrescentar que, independentemente de constexprimplicar inline, as regras para constexprfunções em C ++ 11 exigiam que fossem simples o suficiente para que fossem frequentemente boas candidatas para expansão sequencial (a principal exceção sendo aquelas que são recursivas). Desde então, no entanto, as regras ficaram progressivamente mais flexíveis, constexprpodendo ser aplicadas a funções substancialmente maiores e mais complexas.

constexprnão implica inlinepara variáveis ​​não estáticas (variáveis ​​embutidas C ++ 17)

Embora constexprimplique inlinepara funções, não tem esse efeito para variáveis ​​não estáticas, considerando as variáveis ​​inline do C ++ 17.

Por exemplo, se você pegar o exemplo mínimo que postei em: Como funcionam as variáveis ​​embutidas? e remove o inline, deixando apenas constexpr, então a variável obtém vários endereços, que é a principal coisa que as variáveis ​​embutidas evitam.

constexpr variáveis ​​estáticas são, entretanto, implicitamente estáticas.

Exemplo mínimo que constexprimplica inlinefunções

Conforme mencionado em: https://stackoverflow.com/a/14391320/895245, o principal efeito de inlinenão é embutir, mas permitir várias definições de uma função, citação padrão em: Como um arquivo de cabeçalho C ++ pode incluir implementação?

Podemos observar isso brincando com o seguinte exemplo:

main.cpp

#include <cassert>

#include "notmain.hpp"

int main() {
    assert(shared_func() == notmain_func());
}

notmain.hpp

#ifndef NOTMAIN_HPP
#define NOTMAIN_HPP

inline int shared_func() { return 42; }
int notmain_func();

#endif

notmain.cpp

#include "notmain.hpp"

int notmain_func() {
    return shared_func();
}

Compile e execute:

g++ -c -ggdb3  -O0 -Wall -Wextra -std=c++11 -pedantic-errors  -o 'notmain.o' 'notmain.cpp' 
g++ -c -ggdb3  -O0 -Wall -Wextra -std=c++11 -pedantic-errors  -o 'main.o' 'main.cpp' 
g++ -ggdb3  -O0 -Wall -Wextra -std=c++11 -pedantic-errors  -o 'main.out' notmain.o main.o
./main.out

Se removermos inlinede shared_func, o link falhará com:

multiple definition of `shared_func()'

porque o cabeçalho é incluído em vários .cpparquivos.

Mas se substituirmos inlinepor constexpr, ele funcionará novamente, porque constexprtambém implica inline.

O GCC implementa isso marcando os símbolos como fracos nos arquivos de objeto ELF: Como um arquivo de cabeçalho C ++ pode incluir a implementação?

Testado em GCC 8.3.0.