Hasty Briefsbeta

All tags

c++

20 stories total

Bilingual

C++ float-to-int conversion can be undefined behavior
3 days ago
- Converting a float to an int in C++ is undefined behavior when the truncated float does not fit into the destination integer.
- C++ allows implicit and explicit float-to-int conversions without warnings, even with -Wall and -Wextra.
- Microsoft's Guidelines Support Library (GSL) provides gsl::narrow for safe narrowing, but it uses undefined behavior internally for float-to-int conversions.
- The undefined behavior often works on current hardware (e.g., x86 CVTTSS2SI maps unrepresentable inputs to INT_MIN), but it's not portable or safe.
more...
Interconverting std::function with copyable_function
5 days ago
- C++11's std::function has design flaws: bloated API, const operator() despite mutable callables, and exception handling preventing noexcept.
- C++26 introduces std::copyable_function to fix these issues while retaining some suboptimal designs like implicit conversions and nullptr assignability.
- copyable_function and function are interconvertible, but naive implementations can create a 'linked list' of callables, degrading performance over time.
- libstdc++ currently shows O(n) call overhead as wrappers nest, while Microsoft STL avoids this issue and libc++ hasn't implemented yet.
more...
Modern C++ for C Programmers: part 1 - Bert Hubert's writings
5 days ago
- C and C++ are closely related; C code often compiles as valid C++ and C++ includes the entire C library.
- C++ follows the zero-overhead principle: you don't pay for features you don't use, and hand-coded equivalents are not better.
- C++ std::sort outperforms C qsort by 40% due to template inlining and lambda expressions; parallel sort further speeds up sorting.
- C++ std::string offers easy concatenation, searching, and interoperates with C via c_str().
more...
Modern C++ for C programmers: part 2 - Bert Hubert's writings
5 days ago
- Namespaces in C++ allow avoiding name collisions, with the standard library living in the std:: namespace.
- Classes are essentially C structs with member functions, using a hidden 'this' pointer for method calls.
- RAII (Resource Acquisition Is Initialization) uses constructors and destructors to automatically manage resources like file handles.
- Smart pointers like std::shared_ptr and std::unique_ptr provide automatic memory management with reference counting or zero overhead.
more...
Modern C++ for C Programmers: Part 3 - Bert Hubert's writings
5 days ago
- Inheritance and polymorphism are useful but not mandatory; example with Event base class and derived classes using virtual functions.
- References are like pointers but save typing and enable operator overloading, e.g., v[12]=4.
- Templates provide zero-overhead generic programming, enabling containers like std::vector that are as efficient as hand-written code.
- Worked example: indexing 692MB of Linux kernel source code in 10 seconds using std::unordered_map, std::vector, iterators, and range-based for loops.
more...
Modern C++ for C Programmers: Part 4 - Bert Hubert's writings
5 days ago
- Lambdas are syntactical sugar that make C++ more expressive and can yield faster code due to better compiler optimization.
- Lambdas can capture variables by value or reference, and can be stored in std::function or used as function pointers if no capture.
- C++ containers like std::vector and std::unordered_map can be combined with algorithms such as std::sort, std::nth_element, and std::lower_bound for efficient data manipulation.
- Using raw pointers to keys in another container can save memory but requires careful handling to avoid dangling references.
more...
Modern C++ for C Programmers: Part 6 - Bert Hubert's writings
5 days ago
- Static assert allows compile-time checks and self-documenting code.
- constexpr enables compile-time computation, improving performance and reducing runtime overhead.
- std::numeric_limits provides uniform access to type limits, replacing macros like ULLONG_MAX.
- iostreams are suitable for simple text I/O but not for high-performance tasks.
more...
C++ iostreams: Unexpected but legal multithreaded behaviour - Bert Hubert's writings
5 days ago
- Calling `std::ios_base::sync_with_stdio(false)` disables not only C stdio synchronization but also thread safety for standard iostream objects.
- Tied streams (e.g., `cin` tied to `cout`) cause hidden write operations: reading from `cin` flushes `cout`, creating concurrent access even if only one thread directly writes to `cout`.
- To avoid hidden concurrent writes in single-threaded `cout` usage, use `cin.tie(nullptr)` to break the tie.
- Even synchronized streams can produce interleaved output; no atomicity guarantee for multiple `<<` operations, so user-level locking is needed for clean output.
more...
Always use feenableexcept() when doing floating point math - Bert Hubert's writings
5 days ago
- Always use feenableexcept() in C/C++ floating point code to catch exceptions like division by zero, invalid operations, and overflow.
- By default, ISO C silently allows infinities and NaNs, which can propagate and produce undetected bogus results in calculations.
- Using feenableexcept(FE_DIVBYZERO | FE_INVALID | FE_OVERFLOW) on Linux with -lm causes SIGFPE on dubious operations, crashing the program for safety.
- Compiler optimization (e.g., SIMD) may be inhibited by exception trapping; enabling -fno-trapping-math allows optimization but prevents using feenableexcept().
more...
Unsigned char std::basic_string<> in C++ - Bert Hubert's writings
5 days ago
- Using std::basic_string<uint8_t> for bit manipulation is convenient but relies on a generic std::char_traits template.
- LLVM 19 removed the base std::char_traits template for non-standard types, breaking code that used std::basic_string with unsigned char.
- Workarounds include migrating to std::vector<uint8_t> or implementing a custom std::char_traits specialization.
Matt Godbolt's blog
5 days ago
- The compiler optimizes loops by moving invariant code (like size calculations) outside the loop, known as Loop-Invariant Code Motion (LICM).
- In a string_view counting example, clang moves the get_range() call outside the loop and uses setle/setge to avoid branches.
- Trust the compiler, but verify its output using tools like Compiler Explorer, as gcc may fail to perform LICM on certain struct types.
Matt Godbolt's blog
5 days ago
- Aliasing prevents compiler optimizations, and understanding why is crucial.
- A counter class example shows that with `int` types, the compiler updates the member variable each loop iteration due to potential aliasing, while with `long` types, it caches the accumulator in a register because strict aliasing rules prevent overlap.
- C++ strict aliasing allows the compiler to assume non-overlapping memory for different types, enabling optimizations like register caching and vectorization.
- Fixes include using a local variable for accumulation (e.g., `std::accumulate`) or the non-standard `__restrict` keyword.
more...
Matt Godbolt's blog
5 days ago
- Inlining is a fundamental compiler optimization that copies function bodies into call sites, enabling further optimizations like constant propagation and dead code elimination.
- Inlining can reduce call overhead but its primary benefit is allowing the compiler to specialize code at the inline site, such as simplifying branches based on known constants.
- Drawbacks of inlining include increased code size, which can strain instruction caches, and complex heuristic-driven decisions that vary between compilers.
- Inlining requires visibility of the function definition; declaring functions without bodies prevents inlining, though link-time optimization (LTO) can help across translation units.
more...
Matt Godbolt's blog
5 days ago
- Spent most of 2025 on a non-compete before starting a new job at Hudson River Trading.
- Delivered public talks at CppCon, C++Now, ACCU, and other conferences.
- Appeared in several Computerphile videos.
- Solved a three-year-old problem with CEFS, a content-addressable filesystem for Compiler Explorer.
more...
Making an agile version of a Windows Runtime delegate in C++/WinRT, part 6 - The Old New Thing
5 days ago
- The article discusses a bug fix for releasing a non-marshalable delegate on the correct thread, highlighting that a custom deleter for std::unique_ptr must not throw exceptions during construction.
- The solution involves changing the constructor to accept an explicit deleter, moving the potential exception outside the unique_ptr constructor.
- Despite this fix, the author notes that the code is still broken, suggesting further issues with the deleter's construction order relative to the pointer it guards.
Learn WebGPU for C++
9 days ago
- This guide teaches WebGPU for native graphics in C++ from scratch on Windows, Linux, and macOS.
- Users can choose to write WebGPU code from scratch or skip initial boilerplate, and can opt for a C++ styled wrapper (webgpu.hpp) or raw C API (webgpu.h).
- Backend options include wgpu-native (default) or Dawn, selectable via CMake.
- Base code examples range from a simple triangle to a 3D mesh viewer with basic interaction, with additional support for running on the Web.
more...
Software rendering in 500 lines of bare C++
9 days ago
- The article demonstrates how 3D graphics APIs like OpenGL and Vulkan work by writing a simplified software renderer from scratch in C++, using about 500 lines of code.
- No third-party libraries are used except for a TGA image class; the renderer generates an image of a 3D model without any graphical interface.
- Students typically require 10–20 hours of programming to produce such a renderer, and the initial code provided sets only single pixels to illustrate the starting point.
- The goal is to understand the internals of 3D graphics libraries, not to write GPU applications, and the author provides the complete source code on GitHub.
Neither GCC nor Clang are compliant with standard C++
13 days ago
- In C++, function types have an associated 'language linkage' such as C++, C, or other implementation-defined options.
- The standard mandates that function types with different language linkages are distinct types, even if they are otherwise identical.
- GCC and Clang do not store language linkage information with the type, allowing identical treatment of C and C++ function types.
- This leads to issues like static assertions failing incorrectly and compilation errors in function overloading scenarios.
more...
Beautiful Type Erasure with C++26 Reflection
18 days ago
- The article introduces rjk::duck, a C++26 library for type erasure using reflection, simplifying complex type erasure with minimal boilerplate.
- It explains how to define traits using annotations like [[=rjk::trait]] and generate tags and vtables through reflection, handling overload resolution via overload sets.
- Key implementation details include pointer-interconvertibility to optimize memory usage and support for inlined functions via perf_options for performance tuning.
- The library is single-header, supports owning/non-owning semantics, and works with gcc using -std=c++26 -freflection, though compile-time usage has limitations.
more...
Pystd, similar-ish functionality with a fraction of the compile time
a month ago
- The author discusses Pystd, a from-scratch written standard library for C++ designed to improve compilation times, which is not an implementation of the ISO specification.
- C++ compilation is significantly slower than C, with a 'hello world' program taking up to 2.3 seconds in C++ compared to 0.02 seconds in C, a slowdown of about 100x.
- The slowdown is attributed to the standard library implementation, where including headers like <vector> expands to around 29,000 lines of preprocessed code, increasing compile times.
- Pystd's design priorities are compilation time, simplicity of implementation, and performance, aiming to reduce build times with a requirement that any header compile within 0.15 seconds.
more...

firstprev0next

c++

C++ float-to-int conversion can be undefined behavior

Interconverting std::function with copyable_function

Modern C++ for C Programmers: part 1 - Bert Hubert's writings

Modern C++ for C programmers: part 2 - Bert Hubert's writings

Modern C++ for C Programmers: Part 3 - Bert Hubert's writings

Modern C++ for C Programmers: Part 4 - Bert Hubert's writings

Modern C++ for C Programmers: Part 6 - Bert Hubert's writings

C++ iostreams: Unexpected but legal multithreaded behaviour - Bert Hubert's writings

Always use feenableexcept() when doing floating point math - Bert Hubert's writings

Unsigned char std::basic_string<> in C++ - Bert Hubert's writings

Matt Godbolt's blog

Matt Godbolt's blog

Matt Godbolt's blog

Matt Godbolt's blog

Making an agile version of a Windows Runtime delegate in C++/WinRT, part 6 - The Old New Thing

Learn WebGPU for C++

Software rendering in 500 lines of bare C++

Neither GCC nor Clang are compliant with standard C++

Beautiful Type Erasure with C++26 Reflection

Pystd, similar-ish functionality with a fraction of the compile time