Compile-time function execution: Difference between revisions

Revision as of 15:50, 26 March 2024

Latest revision as of 23:44, 17 January 2025

(One intermediate revision by one other user not shown)

Line 1:

{{Short description|A compiler's ability to execute a function at compile time rather than runtime}}

In [[computing]], '''compile-time function execution''' (or '''compile -time function evaluation''', or '''general constant expressions''') is the ability of a [[compiler]], that would normally compile a [[Subroutine|function]] to [[machine code]] and [[Execution (computing)|execute]] it at [[run time (program lifecycle phase)|run time]], to execute the function at [[compile time]]. This is possible if the arguments to the function are known at compile time, and the function does not make any reference to or attempt to modify any global state (i.e. it is a [[pure function]]).

If the value of only some of the arguments are known, the compiler may still be able to perform some level of compile-time function execution ([[partial evaluation]]), possibly producing more optimized code than if no arguments were known.

Line 14:

In earlier versions of [[C++]], [[template metaprogramming]] is often used to compute values at compile time, such as:

<syntaxhighlight lang="CPPcpp">

template <int N>

struct Factorial {

Line 35:

Using compile-time function evaluation, code used to compute the factorial would be similar to what one would write for run-time evaluation e.g. using C++11 constexpr.

<syntaxhighlight lang="CPPcpp">

#include <cstdio>

Line 50:

In [[C++11]], this technique is known as [[C++11#constexpr – Generalized constant expressions|generalized constant expressions]] (<code>constexpr</code>).<ref>{{cite web|url=http://www.stroustrup.com/sac10-constexpr.pdf|author=Gabriel Dos Reis and Bjarne Stroustrup | title=General Constant Expressions for System Programming Languages. SAC-2010. The 25th ACM Symposium On Applied Computing. | date=March 2010}}</ref> [[C++14]] [[C++14#Relaxed constexpr restrictions|relaxes the constraints]] on constexpr – allowing local declarations and use of conditionals and loops (the general restriction that all data required for the execution be available at compile-time remains).

Here's an example of compile -time function evaluation in C++14:

<syntaxhighlight lang="CPPcpp">

// Iterative factorial at compile time.

constexpr int Factorial(int n) {

Line 70:

In [[C++20]], immediate functions were introduced, and compile-time function execution was made more accessible and flexible with relaxed <code>constexpr</code> restrictions.

<syntaxhighlight lang="CPPcpp">

// Iterative factorial at compile time.

consteval int Factorial(int n) {

Line 88:

Here's an example of using immediate functions in compile-time function execution:

<syntaxhighlight lang="CPPcpp">

void you_see_this_error_because_assertion_fails() {}

Line 111:

The typical compilation error message would display:

<syntaxhighlight lang="CPPcpp">

In function 'int main()':

in 'constexpr' expansion of 'test()'

Line 122:

Here's another example of using immediate functions as constructors which enables compile-time argument checking:

<syntaxhighlight lang="CPPcpp">

#include <string_view>

#include <iostream>

Line 149:

The compilation fails here with the message:

<syntaxhighlight lang="CPPcpp">

In function 'int main()':

in 'constexpr' expansion of 'checked_message(((const char*)"Hello, world!"))'

Line 159:

===D===

Here's an example of compile -time function evaluation in the [[D programming language]]:<ref>[http://d-programming-language.org/function.html#interpretation D 2.0 language specification: Functions]</ref>

<syntaxhighlight lang="Dd">

int factorial(int n) {

if (n == 0)

Line 177:

CTFE can be used to populate data structures at compile-time in a simple way (D version 2):

<syntaxhighlight lang="Dd">
int[] genFactorials(int n) {

auto result = new int[n];

result[0] = 1;

Line 197 ⟶ 198:

===Zig===

Here's an example of compile -time function evaluation in the [[Zig programming language]]:<ref>[https://ziglang.org/documentation/0.11.0/#Compile-Time-Expressions Zig 0.11.0 Language Reference: Compile-Time Expressions]</ref>

<syntaxhighlight lang="Zigzig">

pub fn factorial(n: usize) usize {

var result = 1;

Line 216 ⟶ 217:

This example specifies a valid Zig function called "factorial" which would typically be evaluated at run time. The use of <code>comptime</code> tells the compiler that the initializer for the variables must be computed at compile time. Note that the arguments to the function must be able to be resolved at compile time as well.

Zig also support Compile-Time Parameters .<ref>[https://ziglang.org/documentation/0.11.0/#Compile-Time-Parameters Zig 0.11.0 Language Reference: Compile-Time Parameters]</ref>.

<syntaxhighlight lang="Zigzig">

pub fn factorial(comptime n: usize) usize {

var result: usize = 1;

Line 235 ⟶ 236:

CTFE can be used to create generic data structures at compile-time:

<syntaxhighlight lang="Zigzig">

fn List(comptime T: type) type {

return struct {

Line 256 ⟶ 257:

==External links==

* [http://rosettacode.org/wiki/Compile-time_calculation Rosettacode examples of compile-time function evaluation in various languages]

{{Compiler optimizations}}

[[Category:Compiler construction]]

[[Category:Articles with example C++ code]]

[[Category:Articles with example D code]]

[[Category:Compiler optimizations]]