Khi nào bạn nên sử dụng khả năng constexpr trong C ++ 11?

Dường như với tôi rằng việc có một "hàm luôn trả về 5" sẽ phá vỡ hoặc làm loãng ý nghĩa của việc "gọi một hàm". Phải có một lý do, hoặc cần một khả năng này hoặc nó sẽ không có trong C ++ 11. Tại sao nó ở đó?

// preprocessor.
#define MEANING_OF_LIFE 42

// constants:
const int MeaningOfLife = 42;

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

Dường như với tôi rằng nếu tôi đã viết một hàm trả về giá trị theo nghĩa đen và tôi đã đưa ra một đánh giá mã, ai đó sẽ nói với tôi, sau đó, tôi nên khai báo một giá trị không đổi thay vì viết return 5.

Giả sử nó làm một cái gì đó phức tạp hơn một chút.

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

const int meaningOfLife = MeaningOfLife( 6, 7 );

Bây giờ bạn có một cái gì đó có thể được đánh giá xuống một hằng số trong khi duy trì khả năng đọc tốt và cho phép xử lý phức tạp hơn một chút so với chỉ đặt một hằng số cho một số.

Về cơ bản, nó cung cấp một sự trợ giúp tốt cho khả năng bảo trì vì nó trở nên rõ ràng hơn những gì bạn đang làm. Lấy max( a, b )ví dụ:

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

Đây là một lựa chọn khá đơn giản nhưng điều đó có nghĩa là nếu bạn gọi maxvới các giá trị không đổi thì nó được tính toán rõ ràng vào thời gian biên dịch chứ không phải trong thời gian chạy.

Một ví dụ tốt khác sẽ là một DegreesToRadianschức năng. Mọi người đều tìm thấy độ dễ đọc hơn radian. Mặc dù bạn có thể biết rằng 180 độ là radian nhưng nó được viết rõ ràng hơn như sau:

const float oneeighty = DegreesToRadians( 180.0f );

Nhiều thông tin hay ở đây:

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

Giới thiệu

constexpr đã không được giới thiệu như một cách để nói với việc thực hiện rằng một cái gì đó có thể được đánh giá trong bối cảnh đòi hỏi một biểu thức không đổi ; việc triển khai tuân thủ đã có thể chứng minh điều này trước C ++ 11.

Một cái gì đó mà việc thực hiện không thể chứng minh là ý định của một đoạn mã nhất định:

• Nhà phát triển muốn thể hiện điều gì với thực thể này?
• Chúng ta có nên mù quáng cho phép mã được sử dụng trong một biểu thức không đổi , chỉ vì nó xảy ra để làm việc?

Thế giới sẽ ra sao nếu không có constexpr ?

Giả sử bạn đang phát triển một thư viện và nhận ra rằng bạn muốn có thể tính tổng của mọi số nguyên trong khoảng (0,N].

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

Sự thiếu ý định

Một trình biên dịch có thể dễ dàng chứng minh rằng hàm trên có thể gọi được trong một biểu thức không đổi nếu biết được đối số được truyền trong khi dịch; nhưng bạn đã không tuyên bố đây là một ý định - nó chỉ là trường hợp.

Bây giờ có người khác đến, đọc chức năng của bạn, thực hiện phân tích tương tự như trình biên dịch; " Ồ, chức năng này có thể sử dụng được trong một biểu thức không đổi!" và viết đoạn mã sau.

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

Tối ưu hóa

Bạn, với tư cách là một nhà phát triển thư viện "tuyệt vời" , quyết định rằng fnên lưu trữ kết quả khi được gọi; Ai muốn tính toán cùng một tập hợp các giá trị?

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

Kết quả

Bằng cách giới thiệu tối ưu hóa ngớ ngẩn của bạn, bạn vừa phá vỡ mọi cách sử dụng chức năng của mình trong một bối cảnh có biểu thức không đổi đòi hỏi phải có .

Bạn không bao giờ hứa rằng hàm này có thể sử dụng được trong một biểu thức không đổi , và nếu không constexprcó cách nào sẽ cung cấp lời hứa như vậy.

Vậy, tại sao chúng ta cần constexpr?

Việc sử dụng chính của constexpr là khai báo ý định .

Nếu một thực thể không được đánh dấu là constexpr- nó không bao giờ được sử dụng trong một biểu thức không đổi ; và thậm chí nếu có, chúng tôi dựa vào trình biên dịch để chẩn đoán bối cảnh đó (vì nó coi thường ý định của chúng tôi).

Hãy std::numeric_limits<T>::max(): vì lý do gì, đây là một phương pháp. constexprsẽ có lợi ở đây

Một ví dụ khác: bạn muốn khai báo một mảng C (hoặc a std::array) lớn như một mảng khác. Cách để làm điều này vào lúc này là như vậy:

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

Nhưng nó sẽ không tốt hơn để có thể viết:

int y[size_of(x)];

Nhờ constexpr, bạn có thể:

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

constexprcác chức năng thực sự tốt đẹp và là một bổ sung tuyệt vời cho c ++. Tuy nhiên, bạn đã đúng khi hầu hết các vấn đề mà nó giải quyết có thể được xử lý liên tục với các macro.

Tuy nhiên, một trong những cách sử dụng constexprkhông có hằng số gõ C ++ 03 tương đương.

// 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;

Từ những gì tôi đã đọc, nhu cầu về constexpr xuất phát từ một vấn đề trong siêu lập trình. Các lớp đặc điểm có thể có các hằng được biểu diễn dưới dạng hàm, hãy nghĩ: num_limits :: max (). Với constexpr, các loại hàm này có thể được sử dụng trong siêu lập trình, hoặc như giới hạn mảng, v.v.

Một ví dụ khác ngoài đỉnh đầu của tôi sẽ là đối với các giao diện lớp, bạn có thể muốn các kiểu dẫn xuất xác định các hằng số riêng của chúng cho một số thao tác.

Biên tập:

Sau khi tìm hiểu về SO, có vẻ như những người khác đã đưa ra một số ví dụ về những gì có thể xảy ra với constexprs.

Từ bài phát biểu của Stroustrup tại "Đi bản địa 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

Một cách sử dụng khác (chưa được đề cập) là các nhà constexprxây dựng. Điều này cho phép tạo các hằng số thời gian biên dịch mà không phải khởi tạo trong thời gian chạy.

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

Ghép nối với nghĩa đen do người dùng định nghĩa và bạn có hỗ trợ đầy đủ cho các lớp do người dùng xác định theo nghĩa đen.

3.14D + 42_i;

Đã từng có một mẫu với siêu lập trình:

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

Tôi tin rằng constexprđã được giới thiệu để cho phép bạn viết các cấu trúc như vậy mà không cần các mẫu và các cấu trúc lạ với chuyên môn hóa, SFINAE và các thứ - nhưng chính xác như bạn sẽ viết một hàm thời gian chạy, nhưng với sự đảm bảo rằng kết quả sẽ được xác định trong quá trình biên dịch -thời gian.

Tuy nhiên, lưu ý rằng:

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

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

Biên dịch cái này với g++ -O3và bạn sẽ thấy rằngfact(10) thực sự được phát hiện vào thời gian biên dịch!

Trình biên dịch nhận biết VLA (vì vậy trình biên dịch C ở chế độ C99 hoặc trình biên dịch C ++ có phần mở rộng C99) thậm chí có thể cho phép bạn thực hiện:

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

Nhưng đó là C ++ không chuẩn vào lúc này - constexprtrông giống như một cách để chống lại điều này (ngay cả khi không có VLA, trong trường hợp trên). Và vẫn còn vấn đề về sự cần thiết phải có các biểu thức hằng "chính thức" làm đối số khuôn mẫu.

Mới bắt đầu chuyển đổi một dự án sang c ++ 11 và đã gặp một tình huống hoàn toàn tốt cho constexpr giúp dọn sạch các phương pháp thay thế để thực hiện cùng một hoạt động. Điểm mấu chốt ở đây là bạn chỉ có thể đặt hàm vào khai báo kích thước mảng khi nó được khai báo constexpr. Có một số tình huống mà tôi có thể thấy điều này rất hữu ích khi tiến lên phía trước với khu vực mã mà tôi tham gia.

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

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

Tất cả các câu trả lời khác đều tuyệt vời, tôi chỉ muốn đưa ra một ví dụ tuyệt vời về một điều bạn có thể làm với constexpr thật tuyệt vời. See-Phit ( https://github.com/rep-movsd/see-phit/blob/master/seephit.h ) là một trình phân tích cú pháp HTML và công cụ mẫu thời gian biên dịch. Điều này có nghĩa là bạn có thể đặt HTML vào và lấy ra một cây có thể được thao tác. Việc phân tích cú pháp được thực hiện tại thời gian biên dịch có thể cung cấp cho bạn một chút hiệu suất bổ sung.

Từ ví dụ trang 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;
}

Ví dụ cơ bản của bạn phục vụ anh ta lập luận tương tự như của hằng số. Tại sao sử dụng

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

kết thúc

int arr[5];

Bởi vì đó là cách duy trì nhiều hơn. Sử dụng constexpr rất nhiều, nhanh hơn nhiều để viết và đọc so với các kỹ thuật siêu lập trình hiện có.

Nó có thể cho phép một số tối ưu hóa mới. consttheo truyền thống là một gợi ý cho hệ thống loại và không thể được sử dụng để tối ưu hóa (ví dụ: constchức năng thành viên có thể const_castvà sửa đổi đối tượng bằng mọi cách, về mặt pháp lý, do đó constkhông thể tin cậy để tối ưu hóa).

constexprcó nghĩa là biểu thức thực sự là hằng số, với điều kiện đầu vào của hàm là const. Xem xét:

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

Nếu điều này được phơi bày trong một số mô-đun khác, trình biên dịch không thể tin rằng GetNumber()sẽ không trả về các giá trị khác nhau mỗi lần nó được gọi - thậm chí liên tiếp không có các cuộc gọi không liên tục ở giữa - bởi vìconst có thể đã bị loại bỏ trong quá trình thực hiện. (Rõ ràng là bất kỳ lập trình viên nào đã làm điều này nên bị bắn, nhưng ngôn ngữ cho phép nó, do đó trình biên dịch phải tuân thủ các quy tắc.)

Thêm constexpr:

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

Bây giờ trình biên dịch có thể áp dụng tối ưu hóa trong đó giá trị trả về GetNumber()được lưu trong bộ nhớ cache và loại bỏ các lệnh gọi bổ sung GetNumber(), bởi vì constexprđảm bảo chắc chắn hơn rằng giá trị trả về sẽ không thay đổi.

Khi nào nên sử dụng constexpr:

1. Bất cứ khi nào có một hằng số thời gian biên dịch.

Nó hữu ích cho những thứ như

// constants:
const int MeaningOfLife = 42;

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

int some_arr[MeaningOfLife()];

Liên kết điều này với một lớp đặc điểm hoặc tương tự và nó trở nên khá hữu ích.