Hasty Briefsbeta

All tags

#c++

159 stories total

Bilingual

Simplest C++ Callback, from SumatraPDF
a year ago
- SumatraPDF is a Windows GUI application for viewing PDF, ePub, and comic books, written in C++.
- Callbacks in GUI programs combine a function and data, known as closures in programming.
- C++ offers std::function<> and lambdas for closures, but they can complicate crash report analysis due to auto-generated names.
- The author proposes a simpler, more understandable callback solution than std::function<>, despite its limitations.
- The solution involves a basic Func0 struct for closures, addressing type safety and casting issues with MkFunc0 template.
- Func0 and Func1 are introduced for handling callbacks with no arguments and one additional argument, respectively.
- The author's approach is smaller, faster, and easier to understand than std::function<>, with benefits in size and compilation speed.
- Despite the boilerplate required, the solution is preferred for its simplicity and the author's familiarity with it.
String Interpolation in C++ Using Glaze Stencil/Mustache
a year ago
- Glaze provides string interpolation for C++ structs using stencil and mustache formats.
- Basic usage involves defining a struct and using a template string for interpolation.
- Template syntax includes variable interpolation, boolean sections, container iteration, and comments.
- Boolean sections show or hide content based on boolean field values.
- Container iteration applies templates to each item in a container.
- Mustache format includes HTML escaping for safe HTML output.
- Advanced features include complex templates, error handling, and automatic numbering with stencilcount.
- Error handling includes common errors like unknown keys and syntax errors.
- StencilCount provides automatic numbering for documents with nested sections.
Show HN: PlutoBook – Fast, lightweight C++ library for generating PDF from HTML
a year ago
- PlutoPrint is a Python library built on PlutoBook for easy paged HTML rendering.
- PlutoBook is a robust HTML rendering library tailored for paged media, independent of Chromium, WebKit, or Gecko.
- Designed to be lightweight and memory-efficient, leveraging modern C++ features.
- Supports HTML or XML input with CSS stylesheets, rendering to Bitmap images or PDF.
- Comparison with browser-based renderers like Playwright or Puppeteer highlights PlutoBook's efficiency for static documents.
- Core API revolves around the Book class for document manipulation and rendering.
- Supports loading content from URLs, local files, and rendering to ImageCanvas or PDFCanvas.
- Viewport in PlutoBook adjusts for margins, supporting CSS viewport-relative units for responsive layouts.
- Practical applications include email client rendering, text editor integration, backend PDF generation, and e-book readers.
- Installation requires Meson and Ninja, with dependencies like Cairo, FreeType, and optional libraries for extended features.
- Licensed under MIT, encouraging contributions and commercial use.
C++ Seeding Surprises (2015)
10 months ago
- C++11's std::seed_seq is intended to improve random number generator seeding but has limitations.
- Using a single 32-bit integer to seed a large state RNG like Mersenne Twister leads to predictability and bias issues.
- std::seed_seq can introduce bias even when provided with sufficient seed data, as it's not a bijection.
- Initializing RNGs with insufficient seed data can result in missing or duplicated outputs, causing systemic bias.
- The Mersenne Twister requires 19937 bits of seed data for unbiased initialization, making smaller seeds problematic.
- std::seed_seq's design forces its use even when unnecessary, complicating proper seeding with std::random_device.
- Proposed fixes include relaxing Seed Sequence requirements and adding a generate method to std::random_device.
Xbyak – a JIT assembler for x86/x64 architectures
10 months ago
- Xbyak is a C++ header-only library for dynamic assembly of x86/x64 instructions.
- Pronounced /k��bjæk/ (kai-byak), derived from the Japanese word �� (kaibyaku) meaning 'creation'.
- Supports advanced instruction sets including AVX-512, APX, and AVX10.2.
- Features Intel/MASM-like syntax and requires specific compiler options for certain operations.
- Extensions available for AArch64 (Xbyak_aarch64) and RISC-V (Xbyak_riscv).
- Includes support for various new instructions and technologies like AVX10.2, APX, RAO-INT, and more.
- MmapAllocator supports memfd with user-defined strings; strict address offset checks are enforced.
- Backward compatibility breaks include changes to push operations and removal of certain includes.
- Supports exception-less mode and is compatible with multiple operating systems and compilers.
- Documentation references include Intel manuals and architecture specifications.
AI-SDK-cpp: Modern C++ AI SDK
10 months ago
- AI SDK CPP is a modern C++ toolkit for building AI-powered applications with providers like OpenAI and Anthropic.
- Provides a unified API to abstract complexity across different AI providers.
- Built with C++20 features, minimal dependencies, and requires C++20 compiler and CMake 3.16+.
- Core module supports OpenAI and Anthropic with easy-to-use interfaces for text generation and streaming.
- Supports multi-turn conversations, error handling, and function calling for external API interactions.
- Includes async tools for long-running operations with parallel execution.
- Features text generation, streaming, embeddings, and image generation support.
- Future plans include support for additional providers like Google and Cohere.
- Examples provided cover basic chat, streaming, tool calling, and error handling.
NativeJIT: A C++ expression –> x64 JIT
10 months ago
- NativeJIT is an open-source, cross-platform library for high-performance just-in-time (JIT) compilation of expressions involving C data structures.
- Developed by the Bing team, it is used in the Bing search engine for scoring documents based on user queries.
- NativeJIT is lightweight, fast, and has no dependencies beyond the standard C++ runtime, running on Linux, OSX, and Windows.
- It optimizes generated code with a focus on register allocation, crucial for throughput and latency at scale.
- Designed for scenarios where expressions are unknown until runtime, evaluated multiple times to amortize compilation costs, and require low compilation latency.
- Includes support for arithmetic, logical operations, pointer and array operations, conditionals, structure field access, and calling C functions.
- Building NativeJIT requires CMake (2.8.11+) and a modern C++ compiler (gcc 5+, clang 3.4+, or VC 2015+).
- Provides example scripts for building on *nix platforms, OS X (using Makefiles or Xcode), and Windows (Visual Studio 2015).
- Example code demonstrates compiling an expression to calculate the area of a circle, showcasing generated assembly code.
Gecode is an open source C++ toolkit for developing constraint-based systems
10 months ago
- Gecode is an open-source C++ toolkit for constraint-based systems and applications.
- It offers state-of-the-art performance, modularity, and extensibility.
- Key features include openness for programming, comprehensive constraint support, and high efficiency.
- Gecode supports constraints over integers, Booleans, sets, and floats with over 70 predefined constraints.
- It includes advanced branching heuristics, multiple search engines, and automatic symmetry breaking.
- Gecode has won multiple gold medals in the MiniZinc Challenges from 2008 to 2012.
- It comes with extensive documentation, including a 500+ page tutorial and reference documentation.
- Distributed under the MIT license, Gecode is free and open-source.
- Portable across different platforms and supports parallel search for multi-core hardware.
Show HN: BinaryRPC – Lightweight WebSocket-based RPC framework in modern C++
10 months ago
- BinaryRPC is a high-throughput RPC framework built on uWebSockets, designed for latency-sensitive applications like multiplayer games and financial tick streams.
- The framework supports configurable reliability levels (None, AtLeastOnce, ExactlyOnce) with retries, ACKs, and two-phase commit mechanisms.
- BinaryRPC features pluggable layers for protocols, transports, middleware, and plugins, allowing for extensive customization.
- Stateful sessions with automatic expiry and indexed fields enable reconnect-friendly operations.
- Middleware chains support functionalities like JWT auth and rate-limiting, similar to Express.js.
- The framework is header-only, making it lightweight and easy to integrate into projects.
- Dependencies include CMake (3.16+), a C++20 compiler, vcpkg, and Git. Optional dependencies like JWT and JSON support can be added as needed.
- Installation involves cloning the repository, building with CMake, and linking the library in your project.
- BinaryRPC provides a modular architecture with replaceable components for QoS, serialization, transport, middleware, and plugins.
- The framework includes utilities for logging, error handling, and session management, with detailed examples provided for common use cases.
A Mental Model for C++ Coroutine
10 months ago
- C++ coroutine is a specification defining customization points for library writers, not a ready-to-use library or trait.
- Coroutines generalize functions by supporting suspend, resume, and destroy operations in addition to call and return.
- Example coroutine 'add' demonstrates suspending at 'co_await' and resuming after 'co_sleep(1)' completes.
- C++ coroutine's flexibility allows customization of operations like call, return, suspend, resume, and destroy.
- The 'promise_type' within the coroutine's return type (e.g., 'Task<T>') is key for customizing coroutine behavior.
- Awaiter and Awaitable concepts enable customization of suspend and resume operations, with 'await_suspend' and 'await_resume' methods.
- 'final_suspend' allows customization at the coroutine's end, often used to resume awaiting coroutines.
- 'await_transform' provides a way to transform expressions into awaitables, ensuring all awaitables are coroutines.
C++: Maps on Chains
10 months ago
- C++ maps with interval keys require a strict weak ordering for proper functioning.
- The interval order is not a strict weak order, leading to undefined behavior when inserting overlapping intervals.
- A workaround involves throwing an exception when overlapping intervals are detected to maintain order.
- Heterogeneous lookup allows for searching with integers within intervals, enhancing functionality.
- The solution involves defining a strict weak order on a combination of natural numbers and disjoint intervals.
C++ Coroutines Advanced: Converting std:future to asio:awaitable
10 months ago
- C++ coroutines revolutionize asynchronous programming, especially when integrating std::future with asio::awaitable.
- The article presents a thread-safe method to convert std::future<T> to asio::awaitable<T> using asio::async_initiate, avoiding IO thread blocking.
- A dedicated thread pool (asio::thread_pool) handles blocking operations, ensuring high performance and non-blocking IO threads.
- The solution includes robust exception handling using std::tuple<std::optional<T>, std::exception_ptr> to manage both results and exceptions.
- Key advantages include seamless integration with asio coroutines, type safety, and performance optimization by avoiding timer polling.
- Practical applications include database operations, file I/O, third-party library integration, and CPU-intensive tasks.
- The design ensures executor context preservation and uses move semantics for efficiency, making it ideal for high-performance coroutine applications.
C++ Library
10 months ago
- The author critiques C++'s standard library for being outdated and difficult to use, highlighting issues with associative containers, optional types, and iterator pairs.
- They propose 'best', a new C++ library designed to surpass the standard library, incorporating modern features inspired by Rust and Go.
- 'best' includes improved versions of standard library components like 'best::row' (replacing 'std::tuple'), 'best::choice' (replacing 'std::variant'), and 'best::option' (similar to Rust's 'Option').
- The library introduces 'best::ptr' for pointer operations, 'best::span' for contiguous memory abstraction, and 'best::iter' for a Rust-like iteration model.
- Text handling in 'best' is UTF-8 focused, with 'best::str' and 'best::strbuf' replacing 'std::string_view' and 'std::string', respectively.
- Formatting in 'best' is inspired by Rust's 'format!', with compile-time format checking and flexible formatting options.
- Reflection in 'best' allows for introspection of structs and enums, enabling generic operations like default formatting for aggregate structs.
- The library includes a unit testing framework and CLI parsing tools, aiming to make C++ development more streamlined and enjoyable.
- Future plans for 'best' include adding synchronization primitives, I/O operations, math libraries, and more OS APIs.
The Best C++ Library
10 months ago
- The author criticizes the C++ standard library for being outdated, wordy, and difficult to use, citing issues with associative containers, `std::optional`, `std::variant`, and iterator pairs.
- They propose a new C++ library called `best`, designed to be a modern, user-friendly alternative to the standard library, inspired by Rust, Go, and other languages.
- `best` includes foundational components like type traits, metaprogramming utilities, and algebraic data types (`best::row`, `best::choice`, `best::option`, `best::result`).
- Memory and pointer operations are handled by `best::ptr`, `best::box`, and `best::span`, which offer safer and more intuitive APIs compared to raw pointers and `std::span`.
- Iterators in `best` are modeled after Rust's `Iterator` trait, providing a more ergonomic and efficient way to work with sequences.
- Heap containers like `best::vec` and `best::table` (a hash table) are designed with small vector optimizations and customizable allocators.
- Text handling in `best` is UTF-8 focused, with `best::str` and `best::strbuf` providing robust Unicode support and encoding flexibility.
- Formatting is done via a Rust-like `format!` macro, with compile-time format string validation and extensible formatting for user-defined types.
- Reflection capabilities allow introspection of struct and enum fields, enabling generic operations like default formatting for aggregates.
- The library includes a unit testing framework (`best::test`) and a CLI parser (`best::cli`), both designed to be macro-free and easy to use.
- Future plans for `best` include adding synchronization primitives, I/O, math libraries, SIMD support, and OS APIs like signals and networking.
- The author sees `best` as a proof-of-concept for how C++ could be improved, though they don't expect widespread adoption.
cppyy: Automatic Python-C++ Bindings
10 months ago
- cppyy is an automatic, run-time Python-C++ bindings generator.
- It enables calling C++ from Python and vice versa without boilerplate code.
- Features include run-time template instantiation, lazy loading, and exception mapping.
- Based on Cling, it matches Python's dynamism and interactivity.
- Supports advanced C++ features like cross-inheritance and callbacks.
- Works with both CPython (v2 and v3) and PyPy, achieving C++-like performance.
- Minimizes dependencies for use in large-scale, distributed environments.
- Includes examples of dynamic interaction between C++ and Python.
- Supports Boost library features, demonstrating seamless C++ integration.
- Encourages bug reports and feedback via an issue tracker.
Smarter, workspace-aware code completions for C++ in VS Code
10 months ago
- C++ development is complex due to varying project structures and conventions.
- GitHub Copilot has improved C++ code completions with model upgrades and workspace awareness.
- The new GPT-4o Copilot model has additional training on 275,000+ public repositories, including C++.
- Workspace awareness enhancements help Copilot provide more accurate C++ code suggestions in VS Code.
- To access improvements, ensure Copilot extension 1.322.0+ and C/C++ extension 1.26.3+ are installed.
- Visual Studio 2022 17.14 will receive similar updates in the future.
- Feedback is encouraged via Developer Community, GitHub, email ([email protected]), or X (@VisualC).
C++ Trailing Return Types (2022)
10 months ago
- Trailing return types in C++11 allow specifying the return type after the function name and parameters, using `auto` before the function name.
- Main motivation: enables specifying return types in function templates where the return type depends on template arguments.
- Pros: Consistency with lambda functions and modern C++ syntax, better readability in some cases, and alignment with mathematical notation.
- Cons: Lack of familiarity among developers, potential inconsistency with existing codebases, and more typing for trivial functions.
- C++14's auto return type deduction reduces the necessity of trailing return types but explicit return types are preferred for clarity.
- Conclusion: Trailing return types offer some benefits but are not essential due to familiarity issues and auto deduction in C++14.
C++: zero-cost static initialization
10 months ago
- Static variables in C and C++ can be defined within function scope, with static storage duration.
- In C, static variable initializers must be compile-time constants, embedding values directly in the binary.
- C++ has complex initialization rules for static variables, including dynamic initialization for block-scope variables.
- Block-scope static variables in C++ are initialized the first time control passes through their declaration, with thread-safe mechanisms.
- Accessing static variables incurs overhead due to guard checks and synchronization mechanisms.
- A method to eliminate this overhead involves using linker features to pre-initialize static variables in dedicated sections.
- The solution uses `__attribute__((section))` and linker symbols `__start_SECNAME` and `__stop_SECNAME` for efficient initialization.
- Challenges include section attribute conflicts in inline functions and template members, requiring workarounds.
- The final solution involves using embedded assembler directives and unique symbol naming to avoid conflicts.
- The approach significantly reduces access overhead, making block-level static variables as efficient as file-level ones.
Sparse Matrix Library with Compressed Row Storage
9 months ago
- SparseMatrix is a template class in C++ for sparse matrices using CRS format.
- Matrix dimensions and element type are specified during initialization.
- Supports operations like set, get, multiply, add, subtract, and compare.
- Invalid coordinates or dimensions throw specific exceptions.
- Matrices are immutable; operations return new matrices.
- Custom element types must implement specific operators and constructors.
- Basic output streaming is supported for the matrix.
Carbon Language: An experimental successor to C++
9 months ago
- Carbon is an experimental successor to C++ designed for performance-critical software with seamless C++ interoperability.
- Goals include modern language foundations, easy upgrades between versions, and a path towards memory safety.
- Carbon aims for a gentle learning curve for C++ developers and supports scalable migration from C++.
- The project is currently experimental, focusing on toolchain development for Carbon ↔ C++ interop.
- Carbon provides a modern generics system with checked definitions, offering advantages over C++ templates.
- Memory safety is a priority, with plans for a safe Carbon subset in the future.
- Developers can try Carbon via the online toolchain or download experimental nightly releases.
- Carbon encourages community contributions and has a welcoming, inclusive development environment.

first prev2next

About|Login

#c++

Simplest C++ Callback, from SumatraPDF

String Interpolation in C++ Using Glaze Stencil/Mustache

Show HN: PlutoBook – Fast, lightweight C++ library for generating PDF from HTML

C++ Seeding Surprises (2015)

Xbyak – a JIT assembler for x86/x64 architectures

AI-SDK-cpp: Modern C++ AI SDK

NativeJIT: A C++ expression –> x64 JIT

Gecode is an open source C++ toolkit for developing constraint-based systems

Show HN: BinaryRPC – Lightweight WebSocket-based RPC framework in modern C++

A Mental Model for C++ Coroutine

C++: Maps on Chains

C++ Coroutines Advanced: Converting std:future to asio:awaitable

C++ Library

The Best C++ Library

cppyy: Automatic Python-C++ Bindings

Smarter, workspace-aware code completions for C++ in VS Code

C++ Trailing Return Types (2022)

C++: zero-cost static initialization

Sparse Matrix Library with Compressed Row Storage

Carbon Language: An experimental successor to C++