Quando você deve usar o recurso constexpr no C ++ 11?

Parece-me que ter uma "função que sempre retorna 5" está quebrando ou diluindo o significado de "chamar uma função". Deve haver um motivo ou uma necessidade desse recurso ou não seria no C ++ 11. Por que está aí?

// preprocessor.
#define MEANING_OF_LIFE 42

// constants:
const int MeaningOfLife = 42;

// constexpr-function:
constexpr int MeaningOfLife () { return 42; }

Parece-me que, se eu escrevesse uma função que retornasse um valor literal e fiz uma revisão de código, alguém me diria que eu deveria declarar um valor constante em vez de escrever o retorno 5.

Suponha que faça algo um pouco mais complicado.

constexpr int MeaningOfLife ( int a, int b ) { return a * b; }

const int meaningOfLife = MeaningOfLife( 6, 7 );

Agora você tem algo que pode ser avaliado em constante, mantendo boa legibilidade e permitindo um processamento um pouco mais complexo do que apenas definir uma constante para um número.

Basicamente, fornece uma boa ajuda para a manutenção, pois fica mais óbvio o que você está fazendo. Tomemos max( a, b )por exemplo:

template< typename Type > constexpr Type max( Type a, Type b ) { return a < b ? b : a; }

É uma escolha bastante simples, mas significa que, se você chamar maxcom valores constantes, é explicitamente calculado em tempo de compilação e não em tempo de execução.

Outro bom exemplo seria uma DegreesToRadiansfunção. Todo mundo acha graus mais fáceis de ler do que radianos. Embora você saiba que 180 graus está em radianos, é muito mais claro escrito da seguinte maneira:

const float oneeighty = DegreesToRadians( 180.0f );

Muitas informações boas aqui:

http://en.cppreference.com/w/cpp/language/constexpr

Introdução

constexprnão foi introduzido como uma maneira de dizer à implementação que algo pode ser avaliado em um contexto que requer uma expressão constante ; implementações em conformidade conseguiu provar isso antes do C ++ 11.

Algo que uma implementação não pode provar é a intenção de um determinado pedaço de código:

• O que é que o desenvolvedor deseja expressar com essa entidade?
• Devemos permitir cegamente que o código seja usado em uma expressão constante , apenas porque funciona?

O que seria do mundo sem constexpr ?

Digamos que você esteja desenvolvendo uma biblioteca e compreenda que deseja calcular a soma de cada número inteiro no intervalo (0,N].

int f (int n) {
  return n > 0 ? n + f (n-1) : n;
}

A falta de intenção

Um compilador pode facilmente provar que a função acima pode ser chamada em uma expressão constante se o argumento passado for conhecido durante a tradução; mas você não declarou isso como uma intenção - aconteceu de acontecer.

Agora alguém aparece, lê sua função, faz a mesma análise que o compilador; " Oh, esta função é utilizável em uma expressão constante!" e escreve o seguinte trecho de código.

T arr[f(10)]; // freakin' magic

A otimização

Você, como um desenvolvedor de biblioteca "impressionante" , decide que fdeve armazenar em cache o resultado ao ser chamado; quem gostaria de calcular o mesmo conjunto de valores repetidamente?

int func (int n) { 
  static std::map<int, int> _cached;

  if (_cached.find (n) == _cached.end ()) 
    _cached[n] = n > 0 ? n + func (n-1) : n;

  return _cached[n];
}

O resultado

Ao introduzir sua otimização boba, você acabou de quebrar todos os usos de sua função que estavam em um contexto em que uma expressão constante era necessária.

Você nunca prometeu que a função era utilizável em uma expressão constante e , sem ela, constexprnão haveria maneira de oferecer tal promessa.

Então, por que precisamos constexpr?

O uso principal do constexpr é declarar intenção .

Se uma entidade não estiver marcada como constexpr- ela nunca foi projetada para ser usada em uma expressão constante ; e, mesmo que seja, contamos com o compilador para diagnosticar esse contexto (porque desconsidera nossa intenção).

Tome std::numeric_limits<T>::max(): por qualquer motivo, este é um método. constexprseria benéfico aqui.

Outro exemplo: você deseja declarar uma matriz C (ou a std::array) que é tão grande quanto outra matriz. A maneira de fazer isso no momento é assim:

int x[10];
int y[sizeof x / sizeof x[0]];

Mas não seria melhor ser capaz de escrever:

int y[size_of(x)];

Graças a constexpr, você pode:

template <typename T, size_t N>
constexpr size_t size_of(T (&)[N]) {
    return N;
}

constexprfunções são realmente legais e um ótimo complemento para o c ++. No entanto, você está certo de que a maioria dos problemas que resolve pode ser deselegantemente contornada com macros.

No entanto, um dos usos de constexprnão possui constantes digitadas equivalentes a C ++ 03.

// This is bad for obvious reasons.
#define ONE 1;

// This works most of the time but isn't fully typed.
enum { TWO = 2 };

// This doesn't compile
enum { pi = 3.1415f };

// This is a file local lvalue masquerading as a global
// rvalue.  It works most of the time.  But May subtly break
// with static initialization order issues, eg pi = 0 for some files.
static const float pi = 3.1415f;

// This is a true constant rvalue
constexpr float pi = 3.1415f;

// Haven't you always wanted to do this?
// constexpr std::string awesome = "oh yeah!!!";
// UPDATE: sadly std::string lacks a constexpr ctor

struct A
{
   static const int four = 4;
   static const int five = 5;
   constexpr int six = 6;
};

int main()
{
   &A::four; // linker error
   &A::six; // compiler error

   // EXTREMELY subtle linker error
   int i = rand()? A::four: A::five;
   // It not safe use static const class variables with the ternary operator!
}

//Adding this to any cpp file would fix the linker error.
//int A::four;
//int A::six;

Pelo que li, a necessidade de constexpr vem de um problema na metaprogramação. Classes de características podem ter constantes representadas como funções, pense: numeric_limits :: max (). Com constexpr, esses tipos de funções podem ser usados ​​na metaprogramação ou como limites de array, etc.

Outro exemplo de primeira linha seria que, para interfaces de classe, você pode querer que tipos derivados definam suas próprias constantes para alguma operação.

Editar:

Depois de bisbilhotar o SO, parece que outros criaram alguns exemplos do que pode ser possível com o constexprs.

Do discurso de Stroustrup em "Going Native 2012":

template<int M, int K, int S> struct Unit { // a unit in the MKS system
       enum { m=M, kg=K, s=S };
};

template<typename Unit> // a magnitude with a unit 
struct Value {
       double val;   // the magnitude 
       explicit Value(double d) : val(d) {} // construct a Value from a double 
};

using Speed = Value<Unit<1,0,-1>>;  // meters/second type
using Acceleration = Value<Unit<1,0,-2>>;  // meters/second/second type
using Second = Unit<0,0,1>;  // unit: sec
using Second2 = Unit<0,0,2>; // unit: second*second 

constexpr Value<Second> operator"" s(long double d)
   // a f-p literal suffixed by ‘s’
{
  return Value<Second> (d);  
}   

constexpr Value<Second2> operator"" s2(long double d)
  // a f-p literal  suffixed by ‘s2’ 
{
  return Value<Second2> (d); 
}

Speed sp1 = 100m/9.8s; // very fast for a human 
Speed sp2 = 100m/9.8s2; // error (m/s2 is acceleration)  
Speed sp3 = 100/9.8s; // error (speed is m/s and 100 has no unit) 
Acceleration acc = sp1/0.5s; // too fast for a human

Outro uso (ainda não mencionado) é constexpr construtores. Isso permite criar constantes de tempo de compilação que não precisam ser inicializadas durante o tempo de execução.

const std::complex<double> meaning_of_imagination(0, 42); 

Emparelhe isso com literais definidos pelo usuário e você terá suporte completo para classes literais definidas pelo usuário.

3.14D + 42_i;

Costumava haver um padrão com metaprogramação:

template<unsigned T>
struct Fact {
    enum Enum {
        VALUE = Fact<T-1>*T;
    };
};

template<>
struct Fact<1u> {
    enum Enum {
        VALUE = 1;
    };
};

// Fact<10>::VALUE is known be a compile-time constant

Acredito que constexprfoi introduzido para permitir que você escreva essas construções sem a necessidade de modelos e construções estranhas com especialização, SFINAE e outras coisas - mas exatamente como você escreveria uma função de tempo de execução, mas com a garantia de que o resultado será determinado na compilação -Tempo.

No entanto, observe que:

int fact(unsigned n) {
    if (n==1) return 1;
    return fact(n-1)*n;
}

int main() {
    return fact(10);
}

Compile isso g++ -O3e você verá quefact(10) é realmente evado no tempo de compilação!

Um compilador compatível com VLA (portanto, um compilador C no modo C99 ou um compilador C ++ com extensões C99) pode até permitir:

int main() {
    int tab[fact(10)];
    int tab2[std::max(20,30)];
}

Mas, no momento, constexpré C ++ fora do padrão - parece uma maneira de combater isso (mesmo sem o VLA, no caso acima). E ainda há o problema da necessidade de ter expressões constantes "formais" como argumentos de modelo.

Acabei de começar a mudar o projeto para o c ++ 11 e me deparei com uma situação perfeitamente boa para o constexpr, que limpa métodos alternativos de executar a mesma operação. O ponto principal aqui é que você só pode colocar a função na declaração de tamanho da matriz quando ela for declarada constexpr. Há várias situações em que vejo isso sendo muito útil para avançar com a área de código em que estou envolvido.

constexpr size_t GetMaxIPV4StringLength()
{
    return ( sizeof( "255.255.255.255" ) );
}

void SomeIPFunction()
{
    char szIPAddress[ GetMaxIPV4StringLength() ];
    SomeIPGetFunction( szIPAddress );
}

Todas as outras respostas são ótimas, só quero dar um exemplo legal de uma coisa que você pode fazer com o constexpr que é incrível. O See-Phit ( https://github.com/rep-movsd/see-phit/blob/master/seephit.h ) é um analisador de HTML em tempo de compilação e um mecanismo de modelo. Isso significa que você pode inserir HTML e sair de uma árvore que possa ser manipulada. Fazer a análise em tempo de compilação pode oferecer um desempenho extra.

No exemplo da página do github:

#include <iostream>
#include "seephit.h"
using namespace std;



int main()
{
  constexpr auto parser =
    R"*(
    <span >
    <p  color="red" height='10' >{{name}} is a {{profession}} in {{city}}</p  >
    </span>
    )*"_html;

  spt::tree spt_tree(parser);

  spt::template_dict dct;
  dct["name"] = "Mary";
  dct["profession"] = "doctor";
  dct["city"] = "London";

  spt_tree.root.render(cerr, dct);
  cerr << endl;

  dct["city"] = "New York";
  dct["name"] = "John";
  dct["profession"] = "janitor";

  spt_tree.root.render(cerr, dct);
  cerr << endl;
}

Seu exemplo básico serve ao mesmo argumento que o das constantes. Por que usar

static const int x = 5;
int arr[x];

sobre

int arr[5];

Porque é muito mais sustentável. O uso do constexpr é muito, muito mais rápido de escrever e ler do que as técnicas de metaprogramação existentes.

Pode ativar algumas novas otimizações. consttradicionalmente é uma dica para o sistema de tipos e não pode ser usado para otimização (por exemplo, uma constfunção membro pode const_caste modifica o objeto de qualquer maneira, legalmente, portanto constnão pode ser confiável para otimização).

constexprsignifica que a expressão é realmente constante, desde que as entradas para a função sejam const. Considerar:

class MyInterface {
public:
    int GetNumber() const = 0;
};

Se isso for exposto em algum outro módulo, o compilador não pode confiar que GetNumber()não retornará valores diferentes cada vez que for chamado - mesmo consecutivamente sem chamadas não-const no meio - porqueconst poderia ter sido descartado na implementação. (Obviamente, qualquer programador que fez isso deve ser filmado, mas a linguagem permite, portanto, o compilador deve cumprir as regras.)

Adicionando constexpr:

class MyInterface {
public:
    constexpr int GetNumber() const = 0;
};

O compilador agora pode aplicar uma otimização na qual o valor de retorno GetNumber()é armazenado em cache e eliminar chamadas adicionais para GetNumber(), porque constexpré uma garantia mais forte de que o valor de retorno não será alterado.

Quando usar constexpr:

1. sempre que houver uma constante de tempo de compilação.

É útil para algo como

// constants:
const int MeaningOfLife = 42;

// constexpr-function:
constexpr int MeaningOfLife () { return 42; }

int some_arr[MeaningOfLife()];

Amarre isso com uma classe de características ou algo semelhante e isso se torna bastante útil.