Home New Trending Search
About Privacy Terms
#
#constexpr
Posts tagged #constexpr on Bluesky
CppOnline
CppOnline
@cpponline.bsky.social
1 month ago
Preview
C++Online 2026 Session: When One Red Pill Is Not Enough - Compile-Time Optimization Through Dynamic Programming

C++Online 2026 SESSION SPOTLIGHT: When One Red Pill Is Not Enough - Compile-Time Optimization Through Dynamic Programming by Andrew Drakeford

Find out more and register your ticket today!

#algorithms #constexpr #cplusplus #cpp

1 0 0 0
Ubuntu
Ubuntu
@ubuntu.activitypub.awakari.com.ap.brid.gy
3 months ago
Post image

CLion 2025.3 Is Here, and It’s Epic: Faster Language Engine, Unique Constexpr Debugger, DAP Support, and Much More This is one of our largest updates ever, featuring advanced capabilities and ref...

#news #releases #clionnova #constexpr #cpp26 #dap #stm32 #zephyr-west

Origin | Interest | Match

0 0 0 0
CppNorth
CppNorth
@cppnorth.bsky.social
4 months ago
Daniel Nikpayuk - A universal data structure for compile time use
Daniel Nikpayuk - A universal data structure for compile time use YouTube video by CppNorth

Our next talk from CppNorth 2025 is now on YouTube! ⚙️

Watch Daniel Nikpayuk (@nikpayuk.bsky.social): "A universal data structure for compile time use."

Explore constexpr restrictions & paradigms for designing potent, compile-time data structures.

🔗 youtu.be/UAmyfaXpPiA

#CppNorth #cpp #constexpr

0 1 1 0
CppNorth
CppNorth
@cppnorth.bsky.social
8 months ago
Preview
CppNorth, The Canadian C++ Conference 2025: A universal data structure for compile t... View more about this event at CppNorth, The Canadian C++ Conference 2025

CppNorth 2025: Master Constexpr! ⚡️
Join Daniel Nikpayuk (@nikpayuk.bsky.social): "A universal data structure for compile time use." Learn paradigms for constexpr data structures & their potent applications.
🔗 sched.co/21xP9
Tickets: CppNorth.ca
🍁 Join us in Toronto, July 20-23! #cpp #Constexpr

3 1 0 1
FunctionalProgramming
FunctionalProgramming
@functionalprogramming.activitypub.awakari.com.ap.brid.gy
9 months ago
Preview
const vs constexpr in C++ ## C++ `const` vs `constexpr`: What’s the Real Difference? Both are used in C++ to define constants. ### Why This Matters Modern C++ encourages writing immutable, efficient, and expressive code. Two keywords—`const` and `constexpr`—sit at the heart of that effort. They look similar, but understanding their distinct guarantees is crucial for clean compile‑time and run‑time behavior. #### High‑Level Comparison Feature | `const` | `constexpr` ---|---|--- Compile‑time constant? | Maybe | Always (or fails to compile) Runtime OK? | Yes | Yes (evaluated at runtime if needed) Array/template usage | Only if truly constant | Guaranteed Functions allowed? | Only qualifiers on member | Full functions evaluable at CT ### 1 Declaring Immutable Data #### `const`: Immutable After Construction 1 | const int runtimeConst = std::rand(); // const but NOT a compile‑time constant ---|--- const int runtimeConst = std::rand(); // const but NOT a compile‑time constant When you merely want to prohibit modification—regardless of when the value is known—`const` is enough. #### `constexpr`: Must Be Known at Compile Time 1 2 | constexpr int arraySize = 10; int arr[arraySize];           // Always valid ---|--- constexpr int arraySize = 10; int arr[arraySize]; // Always valid If the value must participate in contexts that require a constant expression (array bounds, template parameters, `switch` labels), choose `constexpr`. ### 2 Functions and Methods #### `const` Member Functions 1 2 3 4 | class Widget { public:     int value() const {/*…*/} // promises not to modify *this }; ---|--- class Widget { public: int value() const {/*…*/} // promises not to modify *this }; They protect object state but offer no compile‑time guarantee. #### `constexpr` Functions 1 2 3 | constexpr int square(int n) { return n * n; } static_assert(square(4) == 16, "computed at compile time"); ---|--- constexpr int square(int n) { return n * n; } static_assert(square(4) == 16, "computed at compile time"); A `constexpr` function can run during compilation whenever its arguments are constant expressions, yet it still works at run time. ### 3 Common Pitfalls 1 2 3 4 5 | // 1. Compiles: runtimeConst is merely const const int runtimeConst = std::rand(); // 2. Fails: std::rand() is not constexpr constexpr int fails = std::rand(); ---|--- // 1. Compiles: runtimeConst is merely const const int runtimeConst = std::rand(); // 2. Fails: std::rand() is not constexpr constexpr int fails = std::rand(); Remember: every `constexpr` variable is implicitly `const`, but not every `const` variable is a constant expression. ### 4 Guidelines for Choosing * Need guaranteed compile‑time evaluation? Use `constexpr`. * Need immutability but value might come from a run‑time calculation? Use `const`. * Prefer `constexpr` if unsure; the compiler will complain if the initializer isn’t a constant expression. ### 5 Summary Snippet 1 2 | constexpr int ctVal = 42; // compile‑time const int rtVal = std::rand(); // run‑time, still immutable ---|--- constexpr int ctVal = 42; // compile‑time const int rtVal = std::rand(); // run‑time, still immutable Choosing correctly between `const` and `constexpr` unlocks safer, faster, and more expressive C++ code. Default to `constexpr` for constants you truly want at compile time, and reserve `const` for values determined during execution. #### C/C++ Programming * const vs constexpr in C++ * Tutorial on C++ Ranges * Tutorial on C++ Smart Pointers * Tutorial on C++ Future, Async and Promise * The Memory Manager in C/C++: Heap vs Stack * The String Memory Comparision Function memcmp() in C/C++ * Modern C++ Language Features * Comparisions of push_back() and emplace_back() in C++ std::vector * C++ Coding Reference: is_sorted_until() and is_sorted() * C++ Coding Reference: iota() Setting Incrementing Values to Arrays or Vectors * C++ Coding Reference: next_permutation() and prev_permutation() * C++ Coding Reference: count() and count_if() * C++ Code Reference: std::accumulate() and Examples * C++ Coding Reference: sort() and stable_sort() * The Next Permutation Algorithm in C++ std::next_permutation() –EOF (The Ultimate Computing & Technology Blog) — **GD Star Rating** _loading..._ 623 words **Last Post** : Tutorial on C++ Ranges The Permanent URL is: const vs constexpr in C++ (**AMP Version**) ### Related posts: 1. Comparisions of push_back and emplace_back in C++ std::vector In C++, both push_back and emplace_back are methods of the std::vector class used to add... 2. Tutorial on C++ Smart Pointers Tutorial on Smart Pointers in C++ Smart pointers in C++ provide automatic and safe memory... 3. Tutorial on C++ Ranges C++20 introduced ranges, a powerful and elegant abstraction for working with sequences (like arrays, vectors,... 4. From Idea to GitHub Pages: Building Tools with AI and Vibe Coding Built and Open-Sourced 3 Mini Tools with AI Recently, I used ChatGPT-4o and o4-mini to... 5. Teaching Kids Programming – Delete Nodes From Linked List Present in Array Teaching Kids Programming: Videos on Data Structures and Algorithms You are given an array of... 6. Interview Coding Exercise – Nested String (Python) Nested String A string S consisting of N characters is considered to be properly nested... 7. The Computers at Early 2000s In 2003, I took the college entrance exam and then spent the summer in Beijing.... 8. Using BackTracking Algorithm to Find the Combination Integer Sum Given a set of candidate numbers (candidates) (without duplicates) and a target number (target), find...

const vs constexpr in C++ C++ const vs constexpr: What’s the Real Difference? Both are used in ...

https://helloacm.com/const-vs-constexpr-in-c/

#c #/ #c++ #C/C++ #programming #languages #tutorial #c++ #const #constexpr #programming

Result Details

0 0 0 0
DEV Community
DEV Community
@dev.to.web.brid.gy
11 months ago
Preview
'if consteval' in C++20 - A Better Alternative to is_constant_evaluated() ## Introduction When working with `constexpr` and `consteval` in C++, developers may run into some limitations when attempting to evaluate conditions at compile-time. One common scenario is using `std::is_constant_evaluated()` to differentiate between compile-time and runtime code. However, there are cases where this approach fails due to how the compiler performs **static analysis**. In this post, we’ll explore how `if consteval` solves these issues, and why it is a better choice compared to `std::is_constant_evaluated()`. ## Why Doesn't This Code Work? Consider the following `constexpr` function: consteval auto consteval_func(int val) { return val; } constexpr auto constexpr_func(int val) { if (std::is_constant_evaluated()) { return consteval_func(val); } else { std::cout << "is_constant_evaluated==false\n"; return 0; } } The compiler produces an error at the line (**`5`**), because the parameter `val` is not `constexpr`. A `consteval` function like `consteval_func()` can only be called with `constexpr` arguments. Logically, this seems unnecessary since the `if (std::is_constant_evaluated())` branch will only execute at compile-time. And even though `val` isn’t `constexpr`, the `constexpr` function would have been invoked with a `constexpr` argument if executed at compile-time. For example: constexpr auto val = [] consteval { return constexpr_func(42); }(); ## Why does it still not work? The compiler reports an error during **static analysis** , even if the function is not invoked. The error arises because the compiler, during its static analysis phase, checks the code for syntactic and semantic correctness. Since an `if` clause is a runtime construct, the compiler does not generate separate code branches for compile-time and runtime during this phase. Instead, the compiler treats the call `consteval_func(val)` in the `if` clause as if it were outside the clause entirely. This means the call is always analyzed, regardless of whether it will actually execute or not. Consequently, the compiler raises an error because `val` is not `constexpr`. > This behavior leads to the conclusion that calling a `consteval` function from a `constexpr` function with a non-`constexpr` argument is **always** invalid. ## Enter `if consteval` Here’s how `if consteval` resolves the issue: consteval auto consteval_func(int val) { return val; } constexpr auto constexpr_func(int val) { if consteval { return consteval_func(val); } else { std::cout << "is_constant_evaluated==false\n"; return 0; } } With `if consteval`, the compiler makes the decision about which branch to execute during **static analysis**. This means: * The `consteval` branch is **excluded** entirely from runtime evaluation. * The compiler knows that the call to `consteval_func(val)` happens only in a compile-time context, allowing it to validate the code confidently. Unlike an `if` clause, `if consteval` is a compile-time construct, just like `if constexpr`. The compiler decides which branch to execute during **static analysis** and **excludes** the other entirely. This means the compiler can safely allow the call to the `consteval_func(val)` function, knowing that the call will occur only in a `constexpr` context during compile-time. ## Conclusion `std::is_constant_evaluated()` is useful for distinguishing between compile-time and runtime logic, but it is not suitable when working with `consteval` functions. The introduction of `if consteval` in C++ provides a cleaner and safer way to handle compile-time evaluation, ensuring that the compiler can confidently differentiate between branches. If you found this post useful, you might also enjoy follow-up articles and other C++ content on my blog: adamczapla.github.io
0 0 0 0
Forem
Forem
@forem.com.web.brid.gy
11 months ago
Preview
'if consteval' in C++20 - A Better Alternative to is_constant_evaluated() ## Introduction When working with `constexpr` and `consteval` in C++, developers may run into some limitations when attempting to evaluate conditions at compile-time. One common scenario is using `std::is_constant_evaluated()` to differentiate between compile-time and runtime code. However, there are cases where this approach fails due to how the compiler performs **static analysis**. In this post, we’ll explore how `if consteval` solves these issues, and why it is a better choice compared to `std::is_constant_evaluated()`. ## Why Doesn't This Code Work? Consider the following `constexpr` function: consteval auto consteval_func(int val) { return val; } constexpr auto constexpr_func(int val) { if (std::is_constant_evaluated()) { return consteval_func(val); } else { std::cout << "is_constant_evaluated==false\n"; return 0; } } The compiler produces an error at the line (**`5`**), because the parameter `val` is not `constexpr`. A `consteval` function like `consteval_func()` can only be called with `constexpr` arguments. Logically, this seems unnecessary since the `if (std::is_constant_evaluated())` branch will only execute at compile-time. And even though `val` isn’t `constexpr`, the `constexpr` function would have been invoked with a `constexpr` argument if executed at compile-time. For example: constexpr auto val = [] consteval { return constexpr_func(42); }(); ## Why does it still not work? The compiler reports an error during **static analysis** , even if the function is not invoked. The error arises because the compiler, during its static analysis phase, checks the code for syntactic and semantic correctness. Since an `if` clause is a runtime construct, the compiler does not generate separate code branches for compile-time and runtime during this phase. Instead, the compiler treats the call `consteval_func(val)` in the `if` clause as if it were outside the clause entirely. This means the call is always analyzed, regardless of whether it will actually execute or not. Consequently, the compiler raises an error because `val` is not `constexpr`. > This behavior leads to the conclusion that calling a `consteval` function from a `constexpr` function with a non-`constexpr` argument is **always** invalid. ## Enter `if consteval` Here’s how `if consteval` resolves the issue: consteval auto consteval_func(int val) { return val; } constexpr auto constexpr_func(int val) { if consteval { return consteval_func(val); } else { std::cout << "is_constant_evaluated==false\n"; return 0; } } With `if consteval`, the compiler makes the decision about which branch to execute during **static analysis**. This means: * The `consteval` branch is **excluded** entirely from runtime evaluation. * The compiler knows that the call to `consteval_func(val)` happens only in a compile-time context, allowing it to validate the code confidently. Unlike an `if` clause, `if consteval` is a compile-time construct, just like `if constexpr`. The compiler decides which branch to execute during **static analysis** and **excludes** the other entirely. This means the compiler can safely allow the call to the `consteval_func(val)` function, knowing that the call will occur only in a `constexpr` context during compile-time. ## Conclusion `std::is_constant_evaluated()` is useful for distinguishing between compile-time and runtime logic, but it is not suitable when working with `consteval` functions. The introduction of `if consteval` in C++ provides a cleaner and safer way to handle compile-time evaluation, ensuring that the compiler can confidently differentiate between branches. If you found this post useful, you might also enjoy follow-up articles and other C++ content on my blog: adamczapla.github.io
0 0 0 0
CppNow
CppNow
@cppnow.bsky.social
1 year ago
harder better faster stronger – C++Now Schedule

CppNow 2024 Session Announcement

<Random> harder better faster stronger by Adrien Devresse

schedule.cppnow.org/session/rand...

Register today at cppnow.org/registration

#Random #Benchmarking #Efficiency #Constexpr #Concurrency #Correctness #cppnow

0 0 0 0
Hana Dus�kov� 🏳️‍🌈
Hana Dus�kov� 🏳️‍🌈
@hanicka.net
6 years ago

If you don't know, @blelbach has a birthday tomorrow! #cpp #cpp20 #cppqkl #constexpr #volatile #mutable

0 0 0 0
Hana Dus�kov� 🏳️‍🌈
Hana Dus�kov� 🏳️‍🌈
@hanicka.net
8 years ago

Will someone like this?

if constexpr (auto [ok,a,b] = "^([a-z]+) ([0-9]+)$"_pre("hi 42"); ok) {

}

#cpp #constexpr #custom_string_literal

0 0 0 0