เมื่อใดที่คุณควรใช้ความสามารถของ constexpr ใน C ++ 11

ดูเหมือนว่าสำหรับฉันแล้วการมี "ฟังก์ชั่นที่ส่งกลับค่า 5" จะทำลายหรือทำให้ความหมายของ "การเรียกใช้ฟังก์ชัน" ลดลง ต้องมีเหตุผลหรือต้องการความสามารถนี้มิเช่นนั้นจะไม่อยู่ใน C ++ 11 ทำไมถึงอยู่ที่นั่น?

// preprocessor.
#define MEANING_OF_LIFE 42

// constants:
const int MeaningOfLife = 42;

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

สำหรับฉันดูเหมือนว่าถ้าฉันเขียนฟังก์ชันที่ส่งคืนค่าตามตัวอักษรและฉันได้รับการตรวจสอบโค้ดใครบางคนจะบอกฉันฉันก็ควรจะประกาศค่าคงที่แทนการเขียนส่งคืน 5

สมมติว่ามันทำอะไรที่ซับซ้อนไปหน่อย

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

บทนำ

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- มันไม่เคยตั้งใจที่จะใช้ในการแสดงออกคงที่ ; และแม้ว่าจะเป็นไปได้ก็ตามเราพึ่งพาคอมไพเลอร์เพื่อวิเคราะห์บริบทดังกล่าว (เพราะไม่สนใจเจตนาของเรา)

ใช้std::numeric_limits<T>::max(): ด้วยเหตุผลใดก็ตามนี่เป็นวิธี constexprจะเป็นประโยชน์ที่นี่

อีกตัวอย่าง: คุณต้องการประกาศ C-array (หรือ a std::array) ที่มีขนาดใหญ่เท่ากับอาร์เรย์อื่น วิธีการทำเช่นนี้ในขณะนี้เป็นเช่น:

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

แต่จะดีกว่าไหมถ้าจะเขียน:

int y[size_of(x)];

ขอบคุณconstexprคุณสามารถ:

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

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;

จากสิ่งที่ฉันได้อ่านความจำเป็นในการใช้ constexpr มาจากปัญหาใน metaprogramming คลาสลักษณะอาจมีค่าคงที่ที่แสดงเป็นฟังก์ชันให้คิดว่า numeric_limits :: max () ด้วย constexpr ฟังก์ชันประเภทนั้นสามารถใช้ใน metaprogramming หรือเป็น array array ฯลฯ เป็นต้น

อีกตัวอย่างหนึ่งจากด้านบนของหัวของฉันจะเป็นสำหรับอินเทอร์เฟซสำหรับคลาสคุณอาจต้องการชนิดที่ได้รับกำหนดค่าคงที่ของตนเองสำหรับการดำเนินการบางอย่าง

แก้ไข:

หลังจาก poking รอบในดังนั้นดูเหมือนว่าคนอื่น ๆ ได้เกิดขึ้นกับบาง ตัวอย่างของสิ่งที่อาจจะเป็นไปได้ด้วย constexprs

จากคำพูดของ Stroustrup ที่ "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

การใช้งานอื่น (ยังไม่ได้กล่าวถึง) คือสิ่งconstexprก่อสร้าง สิ่งนี้ช่วยให้การสร้างค่าคงที่เวลาคอมไพล์ซึ่งไม่จำเป็นต้องเริ่มต้นในระหว่างรันไทม์

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

จับคู่กับตัวอักษรที่กำหนดโดยผู้ใช้และคุณได้รับการสนับสนุนอย่างเต็มที่สำหรับคลาสที่ผู้ใช้กำหนดตามตัวอักษร

3.14D + 42_i;

เคยมีรูปแบบด้วยโปรแกรมเมตาโปรแกรม:

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 ในกรณีข้างต้น) และยังคงมีปัญหาที่ต้องมีนิพจน์คงที่ "เป็นทางการ" เป็นอาร์กิวเมนต์เทมเพลต

เพิ่งเริ่มเปลี่ยนโครงการเป็น c ++ 11 และพบกับสถานการณ์ที่ดีอย่างสมบูรณ์สำหรับ constexpr ซึ่งจะทำความสะอาดวิธีการอื่นในการดำเนินการเดียวกัน จุดสำคัญที่นี่คือที่คุณสามารถวางฟังก์ชั่นในการประกาศขนาดอาร์เรย์เมื่อมีการประกาศ constexpr มีหลายสถานการณ์ที่ฉันเห็นว่านี่เป็นประโยชน์อย่างมากในการก้าวไปข้างหน้าด้วยส่วนของรหัสที่ฉันเกี่ยวข้อง

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

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

คำตอบอื่น ๆ ทั้งหมดนั้นยอดเยี่ยมฉันแค่อยากจะยกตัวอย่างของสิ่งหนึ่งที่คุณสามารถทำได้ด้วย 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;
}

ตัวอย่างพื้นฐานของคุณทำหน้าที่เขาโต้แย้งเช่นเดียวกับค่าคงที่ตัวเอง ทำไมต้องใช้

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

เกิน

int arr[5];

เพราะมันเป็นวิธีการบำรุงรักษามากขึ้น การใช้ constexpr นั้นเร็วกว่ามากในการเขียนและอ่านมากกว่าเทคนิค metaprogramming ที่มีอยู่

มันสามารถเปิดใช้งานการเพิ่มประสิทธิภาพใหม่บางอย่าง constตามเนื้อผ้าเป็นคำใบ้สำหรับระบบประเภทและไม่สามารถใช้สำหรับการปรับให้เหมาะสม (เช่นconstฟังก์ชั่นสมาชิกสามารถconst_castและปรับเปลี่ยนวัตถุอย่างไรก็ตามตามกฎหมายดังนั้นจึงconstไม่น่าเชื่อถือสำหรับการปรับให้เหมาะสม)

constexprหมายถึงการแสดงออกจริงๆคงที่ให้ปัจจัยการผลิตเพื่อฟังก์ชั่นที่มี const พิจารณา:

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

หากสิ่งนี้ถูกเปิดเผยในโมดูลอื่น ๆ คอมไพเลอร์ไม่สามารถไว้วางใจได้ว่าGetNumber()จะไม่ส่งคืนค่าที่แตกต่างกันในแต่ละครั้งที่ถูกเรียกใช้ - แม้ต่อเนื่องโดยไม่มีการโทรที่ไม่ใช่ const ระหว่างนั้นเพราะconstอาจถูกทิ้งในการนำไปใช้ (เห็นได้ชัดว่าโปรแกรมเมอร์คนใดที่ทำสิ่งนี้ควรถูกยิง แต่ภาษาอนุญาตมันดังนั้นผู้แปลจึงต้องปฏิบัติตามกฎ)

การเพิ่มconstexpr:

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

คอมไพเลอร์สามารถใช้การปรับให้เหมาะสมโดยที่ค่าส่งคืนของGetNumber()ถูกแคชและกำจัดการเรียกเพิ่มเติมGetNumber()เนื่องจากconstexprเป็นการรับประกันที่ดีกว่าว่าค่าส่งคืนจะไม่เปลี่ยนแปลง

ควรใช้เมื่อใดconstexpr:

1. เมื่อใดก็ตามที่มีการรวบรวมเวลาคงที่

มันมีประโยชน์สำหรับบางสิ่งเช่น

// constants:
const int MeaningOfLife = 42;

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

int some_arr[MeaningOfLife()];

ผูกนี้กับชั้นเรียนลักษณะหรือชอบและมันจะมีประโยชน์มาก