-
Stay up-to-date with everything C++! Content directly fetched from the subreddit just for you. Join our group for discussions : @programminginc Powered by : @r_channels
Open-lmake: A novel reliable build system with auto-dependency tracking
https://github.com/cesar-douady/open-lmake
https://redd.it/1kdw53s
@r_cpp
Strangecpp: strange cpp things
https://github.com/dalerank/strangecpp
https://redd.it/1kcxydm
@r_cpp
C++ open source Simple dynamic simulator v0.5.0 release!
https://github.com/ahmed-AEK/Simple_Dynamic_Simulator
https://redd.it/1kcjqaw
@r_cpp
Active Learning
Is it best to learn C++ from a textbook or to learn it by doing projects?
I'm doing the former, however feel that it would be more effective to just jump right in to a project and learn what I need as I go, which is how I learned python.
Do you have any recommendations or advice.
https://redd.it/1kca1u3
@r_cpp
C++23 Phantom.Coroutines library
This post announces Phantom.Coroutines, a C++23 library for C++ coroutines, available at JoshuaRowePhantom/Phantom.Coroutines: Coroutines for C++23. The differentiators of Phantom.Coroutines are:
Flexible compilation: header-only or C++20 modules support
Extensible promises for custom behavior without full rewriting
Policy-driven feature selection
A certain amount of cppcoro source-level compatibility, and significantly compatibility otherwise
CLang-21 on Ubuntu 24 and WSL and MSVC support
Natvis visualizers
TLA+ modelling of key components
General purpose multi-threading constructs well suited to coroutine-based code
It comes with the usual set of coroutine types:
task
shared_task
generator
async_generator
It has a coroutine types unique to this library:
reusable\_task - version of task that can be co\_awaited multiple times
early_termination_task - allow co_await'ing results that prematurely terminate coroutines without invoking exceptions, useful for error-code based code
allocated\_promise - allow for use of custom allocators for promise types, integrated with other promise types
extensible_promise / extended_promise - extend the behavior of promises types provided by the library
contextual\_promise / thread\_local\_contextual\_promise - set variables at resumption of a coroutine
It has the usual set of awaitable utilities:
async_manual_reset_event
async\_auto\_reset\_event
async_latch
async\_mutex
async_scope
async\_reader\_writer\_lock / sharded\_async\_reader\_writer\_lock
thread_pool_scheduler
Configurable behavior via its policy scheme:
await\_cancellation\_policy
awaiter_cardinality_policy
continuation\_type
General purpose multi-threading capabilities that I've found invaluable in coroutine programming:
read_copy_update_section
sequence\_lock
thread_local_storage
Documentation is available at the main page.
I am presently working on a process for accepting PR submissions. There is a working VisualStudio.com pipeline for it that I am working on making the results of public. I am not currently performing formal versioning activities, but I shall begin doing so as I develop the PR process. Expertise on this subject is welcome. Submissions and pull requests are welcome. When this process is adequately in place, and if there is enough community interest in the project, I will submit a vcpkg port.
Current development focus is on ensuring test coverage and comment content for existing facilities. This will be followed by expansion and refactoring of the policy scheme to ensure greater support for policies across all types provided in the library. Any additional primitives I discover a need for in other projects will be added as necessary, or as requested by users who can state their cases clearly.
I developed this library to support the JoshuaRowePhantom/Phantom.ProtoStore project (still very much in development), with good results when paired with MiMalloc, achieving 100,000+ database write operations per core per second on 48 core machines.
My qualifications in this area include that I am the developer of the coroutine library supporting Microsoft's CosmosDB backend, which follows many of the lessons learned from writing Phantom.Coroutines.
https://redd.it/1kc3513
@r_cpp
Would you use an AI tool that turns natural language (like English or Spanish) into editable code?
I’m working on a side project and want to know if there’s real interest before I go deeper.
It’s an AI tool where you type instructions in plain language—like “create a basic Flask app with a login page” or “write a Python script that scrapes Twitter”—and it generates editable, clean code you can tweak.
It supports multiple languages (English, Spanish, etc.), and the goal is to make building with code easier and more intuitive, especially for beginners or solo devs.
Would this be useful to you? What features would actually make it worth using
https://redd.it/1kbwekg
@r_cpp
Memory leak with cling::Interpreter in C++ HTTP server
I'm building a C++ HTTP server that uses the cling::Interpreter (a C++ interpreter) to evaluate code dynamically. However, I'm noticing what appears to be a memory leak - the memory usage keeps increasing with each request. After sending multiple HTTP requests to the server, I see the RSS (Resident Set Size) memory constantly growing:
Current process RSS: 62959616 bytes (61484 KB, 60.043 MB)
Current process RSS: 69967872 bytes (68328 KB, 66.7266 MB)
Current process RSS: 76976128 bytes (75172 KB, 73.4102 MB)
Current process RSS: 83988480 bytes (82020 KB, 80.0977 MB)
Current process RSS: 90992640 bytes (88860 KB, 86.7773 MB)
Current process RSS: 97996800 bytes (95700 KB, 93.457 MB)
Current process RSS: 105005056 bytes (102544 KB, 100.141 MB)
You can see that each request increases memory by approximately 7MB. I've observed that after some time (approximately 1-10 minutes), the memory usage slightly decreases, but it doesn't return to the original levels.
*Important*: When I include more header files in the interpreter (beyond the simple example shown), the memory growth becomes much more significant - potentially reaching gigabytes of RAM, which makes this issue critical for my application.
re-using the cling::Interpreter instance fix the issue,but my real-world use case wouldn't allow it. I need to execute code that's passed in with each request, and different requests might contain the same definitions/variables, which would cause conflicts if I reused the interpreter across requests
Here's my simplified code:
#include <cling/Interpreter/Interpreter.h>
#include <cling/Interpreter/Value.h>
#include "httplib.h"
#include <iostream>
#include <fstream>
#include <string>
#include <vector>
#include <unistd.h>
long getResidentSetSize() {
std::ifstream statm_file("/proc/self/statm");
long rss = -1;
if (statm_file.is_open()) {
long size, resident, shared, text, lib, data, dirty;
if (statm_file >> size >> resident >> shared >> text >> lib >> data >> dirty) {
rss = resident; // resident set size in pages
}
statm_file.close();
}
return rss;
}
int main(int argc, const char* const* argv) {
httplib::Server svr;
svr.Post("/", [&](const httplib::Request& req, httplib::Response& res) {
{
cling::Interpreter interp(argc, argv, LLVMDIR);
interp.declare("#include <vector>");
interp.runAndRemoveStaticDestructors();
interp.unload(0);
res.set_header("Connection", "close");
res.set_content("over", "text/plain");
}
long rss_pages = getResidentSetSize();
if (rss_pages != -1) {
long page_size = sysconf(_SC_PAGESIZE);
long rss_bytes = rss_pages * page_size;
std::cout << "Current process RSS: " << rss_bytes << " bytes ("
<< rss_bytes / 1024.0 << " KB, "
<< rss_bytes / 1024.0 / 1024.0 << " MB)" << std::endl;
} else {
std::cerr << "Could not read /proc/self/statm" << std::endl;
}
});
std::cout << "Server listening on http://0.0.0.0:3000" << std::endl;
if (!svr.listen("0.0.0.0", 3000)) {
std::cerr << "Error starting server!" << std::endl;
return 1;
}
return 0;
}
Environment：
* ubuntu:22.04
* cling --version | 1.3\~dev
I have already tried:
* Using a local scope for the cling::Interpreter instance
* Calling runAndRemoveStaticDestructors() && unload(0)
* using malloc\_trim(0) doesn't seem to have much effect. In my example, memory grows by about 6MB with each request, but in my actual production environment where I'm including many more header files, the memory growth is much larger and can easily lead to memory exhaustion/crashes. While I
Thoughts on this optional implementation?
So i wanted to create a type of optional class in c++ that functioned similar to a rust optional where the value is accessable only when the optional is "some". I know c++ already has an optional type in the standard library but it basically functions like an if statement and provides no safety. Also apologies if the code or question itsself is rough, i'm coming back to c++ from a few years of c and rust.
here is my implementation:
template <typename T>
class Result {
private:
bool present;
T value;
public:
Result(T result){ // OK result
present = true;
value = result;
}
Result(){ // Null result
present = false;
}
bool ifok(std::function<void(T)> call){
if(present){
call(value)
}
return present;
}
};
The class can then be used as such:
Result<std::string> getsecretmessage(int key) {
if(key == 1234){
return Result<std::string>(std::string("Hello, World!"));
}
return Result<std::string>();
}
int main() {
if(!getsecretmessage(1234).ifok((std::string result){
std::cout << "You guessed the code! the secret message is: " << result << "\n";
})) {
std::cout << "Incorrect code!";
}
}
Any thoughts on this approach or advice on how this code could be bettered would be greatly appreciated.
https://redd.it/1kb4zb7
@r_cpp
Pure Virtual C++ 2025 is Tomorrow (Wed 2025-04-30, 14:00-16:30 UTC)
https://devblogs.microsoft.com/cppblog/pure-virtual-cpp-2025-is-tomorrow/
https://redd.it/1kb118j
@r_cpp
Valgrind 3.25 released
Valgrind 3.25 is out! Here is the announcement.
>
We are pleased to announce a new release of Valgrind, version 3.25.0,
available from .
This release adds initial support for RISCV64/Linux, the GDB remote
packet 'x', zstd compressed debug sections, Linux Test Project
testsuite integration, numerous fixes for Illumos, FreeBSD atexit
filters and getrlimitusage syscall support, Linux syscall support for
landlock*, io_pgetevents, open_tree, move_mount, fsopen, fsconfig,
fsmount, fspick, userfaultfd, s390x BPP, BPRP, PPA and NIAI instruction
support, --track-fds=yes improvements and a new --modify-fds=high
option, and an helgrind --check-cond-signal-mutex=yes|no option.
See the release notes below for details of the changes.
Our thanks to all those who contribute to Valgrind's development. This
release represents a great deal of time, energy and effort on the part
of many people.
Happy and productive debugging and profiling,
\-- The Valgrind Developers
\~\~\~\~\~\~\~\~\~\~\~\~\~\~\~\~\~\~\~\~\~\~\~\~\~\~\~\~
Release 3.25.0 (25 Apr 2025)
\~\~\~\~\~\~\~\~\~\~\~\~\~\~\~\~\~\~\~\~\~\~\~\~\~\~\~\~
This release supports X86/Linux, AMD64/Linux, ARM32/Linux, ARM64/Linux,
PPC32/Linux, PPC64BE/Linux, PPC64LE/Linux, S390X/Linux, MIPS32/Linux,
MIPS64/Linux, RISCV64/Linux, ARM/Android, ARM64/Android, MIPS32/Android,
X86/Android, X86/Solaris, AMD64/Solaris, AMD64/MacOSX 10.12, X86/FreeBSD,
AMD64/FreeBSD and ARM64/FreeBSD There is also preliminary support for
X86/macOS 10.13, AMD64/macOS 10.13 and nanoMIPS/Linux.
* ==================== CORE CHANGES ===================
* The valgrind gdbserver now supports the GDB remote protocol packet
'x addr,len' (available in GDB release >= 16).
The x packet can reduce the time taken by GDB to read memory from valgrind.
* Valgrind now supports zstd compressed debug sections.
* The Linux Test Project (ltp) is integrated in the testsuite try
'make ltpchecks' (this will take a while and will point out various
missing syscalls and valgrind crashes!)
* ================== PLATFORM CHANGES =================
* Added RISCV64 support for Linux. Specifically for the RV64GC
instruction set.
* Numerous bug fixes for Illumos, in particular fixed a Valgrind crash
whenever a signal handler was called.
* On FreeBSD, a change to the libc code that runs atexit handlers was
causing Helgrind to produce an extra error about exiting threads
still holding locks for. This applied to every multithreaded application.
The extra error is now filtered out. A syscall wrapper had been added
for getrlimitusage.
* On Linux various new syscalls are supported (landlock*, io_pgetevents,
open_tree, move_mount, fsopen, fsconfig, fsmount, fspick, userfaultfd).
* s390x has support for various new instructions (BPP, BPRP, PPA and NIAI).
* ==================== TOOL CHANGES ===================
* The --track-fds=yes and --track-fds=all options now treat all
inherited file descriptors the same as 0, 1, 2 (stdin/out/err).
And when the stdin/out/err descriptors are reassigned they are
now treated as normal (non-inherited) file descriptors.
* A new option --modify-fds=high can be used together with
\--track-fds=yes to create new file descriptors with the highest
possible number (and then decreasing) instead of always using the
lowest possible number (which is required by POSIX). This will help
catch issues where a file descriptor number might normally be reused
between a close and another open call.
* Helgrind:
There is a change to warnings about calls to pthread_cond_signal and
pthread_cond_broadcast when the associated mutex is unlocked. Previously
Helgrind would always warn about this. Now this error is controlled by
a command line option, --check-cond-signal-mutex=yes|no. The default is
no. This change has been made because some C and C++ standard libraries
use pthread_cond_signal/pthread_cond_broadcast in
It's possible to write an Android APP using only NDK ?
I would like to write apps using only C++. I guess the way to do this is to use NDK, right ?
But all the examples I have seen of NDK use, is for some auxiliary C++ code.
It's possible to develop complete apps only using C++ ? Anyone has a complete example of a simple app using NDK ?
If there's another way to develop for Android besides NDK I'd also like to know. Thanks
https://redd.it/1kau82h
@r_cpp
C++/cpp is my favorite programming language. Is there anyone else who feels the same?
Its fast, its versatile, it can do all that C does except more, it can do OOP, classes, its high in demand, it has jobs(way more than C), like i honestly enjoy c++ tbh. Its stressful sometimes but thats about it. It’s not perfect but for me it’s good enough to be my favourite. At least so far. This is probably an unpopular opinion though
https://redd.it/1kapf8v
@r_cpp
C++23 mdspan
https://alexsyniakov.com/2025/04/26/c23-mdspan/
https://redd.it/1kamn2w
@r_cpp
NDC Techtown call for papers
https://ndctechtown.com/call-for-papers
https://redd.it/1kakfy4
@r_cpp
Using std::cpp 2025 keynote: The Real Problem of C++
https://youtu.be/vN0U4P4qmRY?si=tT3uuGS9X3ChGpX7
https://redd.it/1ka5enl
@r_cpp
CppCast: Software development in a world of AI
https://cppcast.com/software_development_in_a_world_of_ai/
https://redd.it/1kd0pqm
@r_cpp
Basic Use of function_ref is Segfaulting
I have been experimenting with various ways of implementing callbacks/delegates in C++, especially for embedded systems. I have a bunch of different techniques that I'm benchmarking, including C-style functions, inheritance, templating, std::function with std::bind and lambdas and more (see the post at [https://blog.mbedded.ninja/programming/languages/c-plus-plus/callbacks/](https://blog.mbedded.ninja/programming/languages/c-plus-plus/callbacks/) for all the info).
For some reason, the function\_ref benchmark is segfaulting, but only when optimizations are disabled (\`-O0\`). I've got a feeling it's because I don't understand the concept of "non owning references" and "lifetimes" when it comes to the idea of a function\_ref and I'm triggering UB.
I am using the [https://github.com/zhihaoy/nontype\_functional](https://github.com/zhihaoy/nontype_functional) library since C++26 features are not widely available in compilers right now.
Below is the code that is segfaulting. Any ideas on why?
#include <cstdio>
#include <functional>
#include <std23/function_ref.h>
#include <benchmark/benchmark.h>
class MyClass {
public:
int methodToCallback(int num1, int num2) {
return num1 + num2;
}
};
static int x = 0;
static int y = 0;
static int total = 0;
class LibraryClass {
public:
LibraryClass(std23::function_ref<int(int, int)> callback) : callback(callback) {}
void run() {
total += callback(x++, y++);
}
private:
std23::function_ref<int(int, int)> callback;
};
static void stdFunctionRef(benchmark::State& state) {
MyClass myClass;
std23::function_ref<int(int, int)> callback = {std23::nontype<&MyClass::methodToCallback>, &myClass};
LibraryClass libraryClass(callback);
for (auto _ : state) {
libraryClass.run();
}
}
// Register the function as a benchmark
BENCHMARK(stdFunctionRef);
https://redd.it/1kcmgx8
@r_cpp
C++ Show and Tell - May 2025
Use this thread to share anything you've written in C++. This includes:
* a tool you've written
* a game you've been working on
* your first non-trivial C++ program
The rules of this thread are very straight forward:
* The project must involve C++ in some way.
* It must be something you (alone or with others) have done.
* Please share a link, if applicable.
* Please post images, if applicable.
If you're working on a C++ library, you can also share new releases or major updates in a dedicated post as before. The line we're drawing is between "written in C++" and "useful for C++ programmers specifically". If you're writing a C++ library or tool for C++ developers, that's something C++ programmers can use and is on-topic for a main submission. It's different if you're just using C++ to implement a generic program that isn't specifically about C++: you're free to share it here, but it wouldn't quite fit as a standalone post.
Last month's thread: https://www.reddit.com/r/cpp/comments/1jpjhq3/c_show_and_tell_april_2025/
https://redd.it/1kcejef
@r_cpp
C++26: more constexpr in the standard library
https://www.sandordargo.com/blog/2025/04/30/cpp26-constexpr-library-changes
https://redd.it/1kc4xb6
@r_cpp
2025 Annual C++ Developer Survey "Lite"
https://standardcpp.typeform.com/2025-dev-survey
https://redd.it/1kc24bc
@r_cpp
understand that memory managers often don't return memory to the OS immediately, the scale of growth in my real application (reaching gigabytes) makes this a critical issue that can't be ignored, especially since the memory is only recovered after a very long delay(\~30 minutes or more)
* i compiling with -g -fsanitize=leak (via CMake): add\_compile\_options(-g -fsanitize=leak) add\_link\_options(-fsanitize=leak), after running the program, I don't see any additional leak reports
Despite these cleanup attempts, the memory keeps growing with each request. In a production environment with frequent requests and more complex header files, this could quickly lead to memory exhaustion.
Questions
1. Are there ways to force more immediate cleanup of resources after each request?
2. Is there something in my implementation that's preventing proper cleanup between requests?
I'm relatively new to C++ and especially to using libraries like cling, so any advice would be greatly appreciated.
https://redd.it/1kbv1ta
@r_cpp
Memory leak with cling::Interpreter in C++ HTTP server
I'm building a C++ HTTP server that uses the cling::Interpreter (a C++ interpreter) to evaluate code dynamically. However, I'm noticing what appears to be a memory leak - the memory usage keeps increasing with each request. After sending multiple HTTP requests to the server, I see the RSS (Resident Set Size) memory constantly growing:
Current process RSS: 62959616 bytes (61484 KB, 60.043 MB)
Current process RSS: 69967872 bytes (68328 KB, 66.7266 MB)
Current process RSS: 76976128 bytes (75172 KB, 73.4102 MB)
Current process RSS: 83988480 bytes (82020 KB, 80.0977 MB)
Current process RSS: 90992640 bytes (88860 KB, 86.7773 MB)
Current process RSS: 97996800 bytes (95700 KB, 93.457 MB)
Current process RSS: 105005056 bytes (102544 KB, 100.141 MB)
You can see that each request increases memory by approximately 7MB. I've observed that after some time (approximately 1-10 minutes), the memory usage slightly decreases, but it doesn't return to the original levels.
Important: When I include more header files in the interpreter (beyond the simple example shown), the memory growth becomes much more significant - potentially reaching gigabytes of RAM, which makes this issue critical for my application.
re-using the cling::Interpreter instance fix the issue,but my real-world use case wouldn't allow it. I need to execute code that's passed in with each request, and different requests might contain the same definitions/variables, which would cause conflicts if I reused the interpreter across requests
Here's my simplified code:
#include <cling/Interpreter/Interpreter.h>
#include <cling/Interpreter/Value.h>
#include "httplib.h"
#include <iostream>
#include <fstream>
#include <string>
#include <vector>
#include <unistd.h>
long getResidentSetSize() {
std::ifstream statmfile("/proc/self/statm");
long rss = -1;
if (statmfile.isopen()) {
long size, resident, shared, text, lib, data, dirty;
if (statmfile >> size >> resident >> shared >> text >> lib >> data >> dirty) {
rss = resident; // resident set size in pages
}
statmfile.close();
}
return rss;
}
int main(int argc, const char* const* argv) {
httplib::Server svr;
svr.Post("/", [&](const httplib::Request& req, httplib::Response& res) {
{
cling::Interpreter interp(argc, argv, LLVMDIR);
interp.declare("#include <vector>");
interp.runAndRemoveStaticDestructors();
interp.unload(0);
res.setheader("Connection", "close");
res.setcontent("over", "text/plain");
}
long rsspages = getResidentSetSize();
if (rsspages != -1) {
long pagesize = sysconf(SCPAGESIZE);
long rssbytes = rsspages page_size;
std::cout << "Current process RSS: " << rss_bytes << " bytes ("
<< rss_bytes / 1024.0 << " KB, "
<< rss_bytes / 1024.0 / 1024.0 << " MB)" << std::endl;
} else {
std::cerr << "Could not read /proc/self/statm" << std::endl;
}
});
std::cout << "Server listening on http://0.0.0.0:3000" << std::endl;
if (!svr.listen("0.0.0.0", 3000)) {
std::cerr << "Error starting server!" << std::endl;
return 1;
}
return 0;
}
Environment：
ubuntu:22.04
cling --version | 1.3\~dev
I have already tried:
Using a local scope for the cling::Interpreter instance
Calling runAndRemoveStaticDestructors() && unload(0)
using malloc_trim(0) doesn't seem to have much effect. In my example, memory grows by about 6MB with each request, but in my actual production environment where I'm including many more header files, the memory growth is much larger and can easily lead to memory exhaustion/crashes. While I
Is Linear Probing Really a Bad Solution for Open-Addressing?
I've been watching several lectures on YouTube about open addressing strategies for hash tables. They always focus heavily on the number of probes without giving much consideration to cache warmth, which leads to recommending scattering techniques like double hashing instead of the more straightforward linear probing. Likewise it always boils down to probability theory instead of hard wall clock or cpu cycles.
Furthermore I caught an awesome talk on the cppcon channel from a programmer working in Wall Street trading software, who eventually concluded that linear searches in an array performed better in real life for his datasets. This aligns with my own code trending towards simpler array based solutions, but I still feel the pull of best case constant time lookups that hash tables promise.
I'm aware that I should be deriving my solutions based on data set and hardware, and I'm currently thinking about how to approach quantitative analysis for strategy options and tuning parameters (eg. rehash thresholds) - but i was wondering if anyone has good experience with a hash table that degrades to linear search after a single probe failure? It seems to offer the best of both worlds.
Any good blog articles or video recommendations on either this problem set or related experiment design and data analysis? Thanks.
https://redd.it/1kb2xkg
@r_cpp
this way. Users are
obliged to use suppressions if they wish to avoid this noise.
* ==================== FIXED BUGS ====================
The following bugs have been fixed or resolved. Note that "n-i-bz"
stands for "not in bugzilla" -- that is, a bug that was reported to us
but never got a bugzilla entry. We encourage you to file bugs in
bugzilla () rather
than mailing the developers (or mailing lists) directly -- bugs that
are not entered into bugzilla tend to get forgotten about or ignored.
290061 pie elf always loaded at 0x108000
396415 Valgrind is not looking up $ORIGIN rpath of shebang programs
420682 io_pgetevents is not supported
468575 Add support for RISC-V
469782 Valgrind does not support zstd-compressed debug sections
487296 --track-fds=yes and --track-fds=all report erroneous information
when fds 0, 1, or 2 are used as non-std
489913 WARNING: unhandled amd64-linux syscall: 444 (landlock_create_ruleset)
493433 Add --modify-fds=[no|high\] option
494246 syscall fsopen not wrapped
494327 Crash when running Helgrind built with #define TRACE_PTH_FNS 1
494337 All threaded applications cause still holding lock errors
495488 Add FreeBSD getrlimitusage syscall wrapper
495816 s390x: Fix disassembler segfault for C[G\]RT and CL[G\]RT
495817 s390x: Disassembly to match objdump -d output
496370 Illumos: signal handling is broken
496571 False positive for null key passed to bpf_map_get_next_key syscall.
496950 s390x: Fix hardware capabilities and EmFail codes
497130 Recognize new DWARF5 DW_LANG constants
497455 Update drd/scripts/download-and-build-gcc
497723 Enabling Ada demangling breaks callgrind differentiation between
overloaded functions and procedures
498037 s390x: Add disassembly checker
498143 False positive on EVIOCGRAB ioctl
498317 FdBadUse is not a valid CoreError type in a suppression
even though it's generated by --gen-suppressions=yes
498421 s390x: support BPP, BPRP and NIAI insns
498422 s390x: Fix VLRL and VSTRL insns
498492 none/tests/amd64/lzcnt64 crashes on FreeBSD compiled with clang
498629 s390x: Fix S[L\]HHHR and S[L\]HHLR insns
498632 s390x: Fix LNGFR insn
498942 s390x: Rework s390_disasm interface
499183 FreeBSD: differences in avx-vmovq output
499212 mmap() with MAP_ALIGNED() returns unaligned pointer
501119 memcheck/tests/pointer-trace fails when run on NFS filesystem
501194 Fix ML_(check_macho_and_get_rw_loads) so that it is correct for
any number of segment commands
501348 glibc built with -march=x86-64-v3 does not work due to ld.so memcmp
501479 Illumos DRD pthread_mutex_init wrapper errors
501365 syscall userfaultfd not wrapped
501846 Add x86 Linux shm wrappers
501850 FreeBSD syscall arguments 7 and 8 incorrect.
501893 Missing suppression for __wcscat_avx2 (strcat-strlen-avx2.h.S:68)?
502126 glibc 2.41 extra syscall_cancel frames
502288 s390x: Memcheck false positives with NNPA last tensor dimension
502324 s390x: Memcheck false positives with TMxx and TM/TMY
502679 Use LTP for testing valgrind
502871 Make Helgrind "pthread_cond_{signal,broadcast}: dubious: associated
lock is not held by any thread" optional
https://redd.it/1kawl4q
@r_cpp
GCC's atomic builtins + `__builtin_is_aligned(ptr, 2)` ⇒ pointer tagging without casting
https://compiler-explorer.com/z/reT5YaGEx
https://redd.it/1kavwvg
@r_cpp
Is there any advanced use of the autogenerated .bat/.sh generator conan files(e.g.: conanbuild.bat, conanbuildenv-release-x86_64.bat) in time of installing conan package from remote repositories or conancentre (in conan 2.x)?
I am using conan version 2.12 and this command:
conan install <conanfile> -r <repo-name> --output-folder=<outer-folder> --build=missing
[requires]
zlib/1.2.13
[tool_requires]
cmake/3.22.6
make/4.4.1
ninja/1.12.1
[generators]
CMakeDeps
CMakeToolchain
I am currently using this kind of conanfile.txt to create and add path of build tools like make, cmake, ninja or some other external library to the system environment variables.
For some cases, I am also using [conanfile.py](http://conanfile.py) to set some custom variable or paths like this:
def generate(self):
env1 = Environment()
env1.define("foo", "var")
envvars = env1.vars(self, scope="build")
envvars.save_script("my_env_file")
As per my requirements, I have to copy the package content in the build folder and that part is fine. I was just wondering is there any special use of these autogenerated .bat/.sh files. Any kind of insight is appreciated.
Thanks in advance!
https://redd.it/1kar5lm
@r_cpp
Dynamic vs static binding in c++?
Based on the code you can see below. What conclusions can you make? Note, some code are omitted ( // ... ). You can choose one or more correct answers.
//...
// Base classes
struct Baseone {
virtual void run() {}
};
struct Basetwo {
virtual void two() = 0;
};
// Derived classes
struct Done : Baseone {
// ...
virtual void run() override { }
};
struct Rtwo : Basetwo {
// ...
virtual void run() { }
};
struct Mult : Baseone, Basetwo {
// ...
virtual void two() {}
};
int main() {
Done done;
Rtwo R2;
Mult mult;
Baseone & refdone = done;
Basetwo & refR2 = R2;
Basetwo & refmult = mult;
refdone.run();
refR2.two();
mult.run();
}
a) Rtwo must implement two()
b) Mult must implement run()
c) No function calls are determined in runtime using dynamic binding.
d) One function call is determined in runtime using dynamic binding
e) Two function calls is determined in runtime using dynamic binding
f) Three function calls is determined in runtime using dynamic binding
Here is my answer:
a) True, b) False c) False
Now that I got the obvious ones out of the way (hopefully I'm correct). The last 3 ones are the hardest for me.
**ref\done.run() -> This will result in dynamic binding.
ref_R2.two() -> I am not really sure about this one, but the superclass defintion of two is pure so shouldn't the compiler understand that it shoudln't use the superclass method thus know to use the child.
mult.run() -> I am not sure about this one as well since Mult doesn't implement fun().
I would appreciate the clarficiation.
https://redd.it/1kaojg4
@r_cpp
Write more C++ code thanks to constexpr
https://andreasfertig.com/blog/2024/12/write-more-cpp-code-thanks-to-constexpr/
https://redd.it/1kalh6q
@r_cpp
C++ DataFrame new release (3.5.0) is out on Conan and VCPKG
https://github.com/hosseinmoein/DataFrame
https://redd.it/1kaa5id
@r_cpp
Learning CPP as a senior web dev
Hi folks,
I've been reading through the threads on how to get started on CPP however I have a lot of programming experience in a very general sense, used many of the within server side web development, Java Servlet, PHP, Golang etc. I see a lot of folks point out Learn C++ – Skill up with our free tutorials as a great source however, I'm torn as there are so many topics I'm already aware of say for instance overloading, return types etc.
I'm aware there is probably a lot of gotchas which I wouldn't know till I hit them, in the past my tech stack just changed with every job and I'd pick up whatever we were working with. This time CPP is for my own enjoyment, been doing some challenges on Leetcode in C just for fun it's nice to work with something so simple until you have to start rolling your own data structures. So wanting to continue the journey and try some CPP touched it at the start of coding journey; pointers and seg faults pushed me towards Java, but time for a return.
Apologies for the waffly post but just wondering what would you recommend to get to grips with CPP given I already have a lot of coding knowledge as I'd rather not spend endless time on tutorials which already cover many topics I know.
https://redd.it/1k9zumv
@r_cpp