Когда следует использовать возможность constexpr в C ++ 11? - PullRequest
Новая
       17

Когда следует использовать возможность constexpr в C ++ 11?

312 голосов
/ 20 января 2011

Мне кажется, что наличие «функции, которая всегда возвращает 5» нарушает или ослабляет значение «вызова функции».Должна быть причина, или необходимость в этой возможности, иначе ее не будет в C ++ 11.Почему это там?

// preprocessor.
#define MEANING_OF_LIFE 42

// constants:
const int MeaningOfLife = 42;

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

Мне кажется, что если бы я написал функцию, возвращающую буквальное значение, и пришел к обзору кода, кто-то сказал бы мне, а затем объявить постоянное значение вместописьменный возврат 5.

Ответы [ 14 ]

283 голосов
/ 20 января 2011

Предположим, что-то немного сложнее. 

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

const int meaningOfLife = MeaningOfLife( 6, 7 );

Теперь у вас есть что-то, что можно оценить до постоянной, сохраняя при этом хорошую читабельность и допуская немного более сложную обработку, чем просто установка постоянной для числа.

Это в основном обеспечивает хорошую поддержку для ремонтопригодности, поскольку становится более очевидным, что вы делаете. Возьмите max( a, b ), например: 

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

Это довольно простой выбор, но это означает, что если вы вызываете max с постоянными значениями, он явно вычисляется во время компиляции, а не во время выполнения.

Другим хорошим примером будет функция DegreesToRadians. Каждый находит градусы легче для чтения, чем радианы. Хотя вы, возможно, знаете, что в радианах 180 градусов, гораздо яснее записать следующее: 

const float oneeighty = DegreesToRadians( 180.0f );

Много полезной информации здесь:

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

132 голосов
/ 03 марта 2015

Введение

constexpr не было представлено как способ сказать реализации, что что-то может быть оценено в контексте, который требует константа-выражения ;соответствующие реализации смогли доказать это до C ++ 11.

То, что реализация не может доказать, это намерение определенного фрагмента кода:

  • Что разработчик хочет выразить с помощью этой сущности?
  • Должны ли мы слепо разрешить использование кода в константном выражении только потому, что это работает?

Каким бы был мир без constexpr?

Допустим, вы разрабатываете библиотеку и понимаете, что хотите иметь возможность вычислять сумму каждого целого числа в интервале(0,N]. 

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

Отсутствие намерения

Компилятор может легко доказать, что вышеуказанная функция может вызываться в выражении константы , если переданный аргумент равенизвестен при переводе;но вы не объявили это как намерение - просто так оно и было.

Теперь приходит кто-то другой, читает вашу функцию, выполняет тот же анализ, что и компилятор;« О, эту функцию можно использовать в константном выражении!» и записывает следующий фрагмент кода. 

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

Оптимизация

Вы, как "офигенно" разработчик библиотеки, решите, что f должен кэшировать результат при вызове;кто захочет вычислять один и тот же набор значений снова и снова? 

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];
}

Результат

Введя свою глупую оптимизацию, вы просто прервали каждое использование своей функции, которое случалось вконтекст, в котором требовалось константное выражение .

Вы никогда не обещали, что функцию можно будет использовать в константном выражении , и без constexpr будетнет способа дать такое обещание.

Итак, зачем нам constexpr?

Основное использование constexpr - это объявление намерение .

Если объект не помечен как constexpr - он никогда не предназначался для использования в константном выражении ;и даже если это так, мы полагаемся на компилятор для диагностики такого контекста (потому что он игнорирует наши намерения).

89 голосов
/ 20 января 2011

Взять std::numeric_limits<T>::max(): по какой-то причине это метод.constexpr было бы здесь полезно.

Другой пример: вы хотите объявить C-массив (или std::array), который будет размером с другой массив.Способ сделать это на данный момент выглядит так: 

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

Но не лучше ли будет написать:можно: 

template <typename T, size_t N>
constexpr size_t size_of(T (&)[N]) {
    return N;
}
17 голосов
/ 20 января 2011

constexpr функции действительно хороши и являются отличным дополнением к c ++. Тем не менее, вы правы в том, что большинство проблем, которые он решает, можно обойтись без макросов.

Однако одно из применений constexpr не имеет эквивалентных 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;
14 голосов
/ 20 января 2011

Из того, что я прочитал, необходимость в constexpr возникает из-за проблемы в метапрограммировании.Классы признаков могут иметь константы, представленные как функции, подумайте: numeric_limits :: max ().С constexpr эти типы функций могут использоваться в метапрограммировании, или как границы массивов, и т. Д. И т. Д.

Еще один пример, который я бы выбрал - это то, что для интерфейсов классов вы можете захотеть, чтобы производные типы определялисобственные константы для некоторой операции.

Редактировать:

После того, как вы покопались в SO, похоже, что другие придумали некоторые примеров того, чтоможет быть возможно с constexprs.

11 голосов
/ 16 марта 2013

Из выступления Страуструпа на "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
7 голосов
/ 20 января 2011

Другое использование (пока не упомянутое) - конструкторы constexpr.Это позволяет создавать константы времени компиляции, которые не нужно инициализировать во время выполнения. 

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

Сопряжение с пользовательскими литералами и полная поддержка литеральных пользовательских классов.

6 голосов
/ 20 января 2011

Раньше был шаблон с метапрограммированием: 

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

Я полагаю, что constexpr был введен, чтобы позволить вам писать такие конструкции без необходимости в шаблонах и странных конструкциях со специализацией, SFINAE и прочим - но точно так же, как вы бы написали функцию времени выполнения, но с гарантией, что результат будет определен во время компиляции.

Однако учтите, что: 

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

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

Скомпилируйте это с g++ -O3, и вы увидите, что fact(10) действительно вычисляется во время компиляции!

Компилятор с поддержкой VLA (например, компилятор C в режиме C99 или компилятор C ++ с расширениями C99) может даже разрешить вам: 

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

Но на данный момент это нестандартный C ++ - constexpr выглядит как способ борьбы с этим (даже без VLA, в приведенном выше случае). И все еще существует проблема необходимости иметь «формальные» константные выражения в качестве аргументов шаблона.

5 голосов
/ 04 февраля 2014

Только что начали переключать проект на c ++ 11 и столкнулись с совершенно хорошей ситуацией для constexpr, которая очищает альтернативные методы выполнения той же операции. Ключевым моментом здесь является то, что вы можете поместить функцию в объявление размера массива только тогда, когда она объявлена ​​constexpr. В ряде ситуаций я вижу, что это очень полезно для продвижения вперед в той области кода, в которой я участвую. 

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

void SomeIPFunction()
{
    char szIPAddress[ GetMaxIPV4StringLength() ];
    SomeIPGetFunction( szIPAddress );
}
2 голосов
/ 24 апреля 2018

Все остальные ответы великолепны, я просто хочу привести классный пример того, что вы можете сделать с constexpr, который удивителен. See-Phit (https://github.com/rep-movsd/see-phit/blob/master/seephit.h) - это HTML-анализатор и шаблонизатор времени компиляции. Это означает, что вы можете поместить HTML-код и получить дерево, которым можно манипулировать. Выполнение анализа во время компиляции может немного дополнительной производительности.

На примере страницы 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;
}
Страница:
...