-
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
A video on coroutines
I understand coroutines. It took time to sort the forest from the trees. From what I can gather, many still don't understand them ( see use\_case\_for\_coroutines ). Would anybody be interested in a, say, 15 minute video that clears up the misunderstandings. I think the sticking point is that they don't necessarily do what you think they do (cppreference is a bit misleading as well) because the actual use case is not obvious (i.e. all the "state machine" business). I guess I'm asking y'all to inspire me to do what I kinda want to do anyhow!
https://redd.it/1ib2trt
@r_cpp
High performance HTTP library?
I'm looking for a high performance HTTP library to integrate with a C++ project.
To clarify, I'm writing the sockets code myself. The system I am building will have both a REST/HTTP interface as well as a custom binary protocol.
The sockets code for both will be broadly similar. The binary protocol is something I will implement myself at a later date. To faciliate in starting quickly, I want to strap a HTTP/REST interface to this thing first.
Assuming my plan is sensible, I imagine this will be as simple as reading some (text based) HTML data from a socket into a buffer, and then passing that data to a library for validation and parsing.
I may then need to pass the body to a JSON library such as cppjson for deserialization of the JSON payload.
I just don't want to implement this serialization and deserialization logic myself.
Can anyone offer a recommendation?
https://redd.it/1iak1ak
@r_cpp
Need advice
Hey people, I'm a third year engineering student. I have been on this sub for quite a while and a lot of it goes above my head. I'm quite fascinated by C/C++, and no other language comes close. I have heard from a lot of people till now to focus on other more important languages, say Js and python, but I've always avoided them. I want to learn more about cpp, more industry relevant side. For now I have a course on parallel computing going on, for which we're using C and its amazing. And I want to learn more stuff about C and cpp, that maybe useful in my career too. I'm from India so based on the market here, if anyone can give any advice then I'm all ears, even if not I'll be happy to hear.
https://redd.it/1iabbm4
@r_cpp
mostrarNumero(diceNumber);
}
void mostrarNumero(int num) {
Serial.print("Mostrando número: ");
Serial.println(num);
for (int i = 0; i < 7; i++) {
Serial.print("Segmento ");
Serial.print(i);
Serial.print(": ");
Serial.println(digitos[num][i] ? "HIGH" : "LOW");
}
// Inicializar todos os segmentos como apagados
digitalWrite(PIN_A, LOW);
digitalWrite(PIN_B, LOW);
digitalWrite(PIN_C, LOW);
digitalWrite(PIN_D, LOW);
digitalWrite(PIN_E, LOW);
digitalWrite(PIN_F, LOW);
digitalWrite(PIN_G, LOW);
// Ligar os segmentos correspondentes ao número
digitalWrite(PIN_A, digitos[num][0]);
digitalWrite(PIN_B, digitos[num][1]);
digitalWrite(PIN_C, digitos[num][2]);
digitalWrite(PIN_D, digitos[num][3]);
digitalWrite(PIN_E, digitos[num][4]);
digitalWrite(PIN_F, digitos[num][5]);
digitalWrite(PIN_G, digitos[num][6]);
digitalWrite(PIN_DP, LOW); // Ponto decimal desativado
}
// Testa individualmente os segmentos G e D
void testeSegmentos() {
Serial.println("Testando segmento G (meio)...");
digitalWrite(PIN_G, HIGH);
delay(1000);
digitalWrite(PIN_G, LOW);
delay(500);
Serial.println("Testando segmento D (inferior)...");
digitalWrite(PIN_D, HIGH);
delay(1000);
digitalWrite(PIN_D, LOW);
delay(500);
Serial.println("Teste de segmentos finalizado.");
}
e and in the meantime it's staying like this: [https://imgur.com/a/Db5JVnd](https://imgur.com/a/Db5JVnd), This is number 6, but it's not turning on all the way, as it should. And this goes for all numbers. For example, number 4 stays on as if it were number 1. Could you help me?
https://redd.it/1iaby14
@r_cpp
I have a problem with a school project.
I'm doing a C++ code where I have to upload a local ESP8266 server for data rolling, there will be a button on the website and it will draw a random number, so far so good, it's going smoothly. However, on the ESP8266 board the number doesn't turn on all the LEDs, for example the number 6, I'll show you here the code and the photo of the display:
#include <ESP8266WiFi.h>
#include <ESP8266WebServer.h>
// Configuração do WiFi
const char ssid = "SPEED TURBO-ELGFJ";
const char password = "F20112017";
ESP8266WebServer server(80);
// Define os valores dos dígitos para o display de 7 segmentos
const byte digitos107 = {
{HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, LOW}, // 0
{LOW, HIGH, HIGH, LOW, LOW, LOW, LOW}, // 1
{HIGH, HIGH, LOW, HIGH, HIGH, LOW, HIGH}, // 2
{HIGH, HIGH, HIGH, HIGH, LOW, LOW, HIGH}, // 3
{LOW, HIGH, HIGH, LOW, LOW, HIGH, HIGH}, // 4
{HIGH, LOW, HIGH, HIGH, LOW, HIGH, HIGH}, // 5
{HIGH, LOW, HIGH, HIGH, HIGH, HIGH, HIGH},// 6
{HIGH, HIGH, HIGH, LOW, LOW, LOW, LOW}, // 7
{HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH}, // 8
{HIGH, HIGH, HIGH, LOW, LOW, HIGH, HIGH} // 9
};
// Pinos GPIO do ESP8266
#define PINA 4 // GPIO4 (D2)
#define PINB 0 // GPIO0 (D3)
#define PINC 2 // GPIO2 (D4)
#define PIND 14 // GPIO14 (D5) - Inferior
#define PINE 12 // GPIO12 (D6)
#define PINF 13 // GPIO13 (D7)
#define PING 15 // GPIO15 (D8) - Meio
#define PINDP 16 // GPIO16 (D0)
// Página da interface web
const char webpage PROGMEM = R"rawliteral(
<!DOCTYPE html>
<html>
<head>
<title>Rolar Dado</title>
<style>
body { font-family: Arial, sans-serif; text-align: center; margin-top: 50px; }
button { padding: 10px 20px; font-size: 18px; }
#result { font-size: 24px; margin-top: 20px; }
</style>
</head>
<body>
<h1>Rolar Dado</h1>
<button onclick="rollDice()">Rolar</button>
<div id="result"></div>
<script>
function rollDice() {
var xhttp = new XMLHttpRequest();
xhttp.onreadystatechange = function() {
if (this.readyState == 4 && this.status == 200) {
document.getElementById("result").innerHTML = "Número: " + this.responseText;
}
};
xhttp.open("GET", "/roll", true);
xhttp.send();
}
</script>
</body>
</html>
)rawliteral";
void setup() {
Serial.begin(115200);
// Configuração dos pinos do display de 7 segmentos
pinMode(PINA, OUTPUT);
pinMode(PINB, OUTPUT);
pinMode(PINC, OUTPUT);
pinMode(PIND, OUTPUT);
pinMode(PINE, OUTPUT);
pinMode(PINF, OUTPUT);
pinMode(PING, OUTPUT);
pinMode(PINDP, OUTPUT);
// Teste inicial dos segmentos G e D
testeSegmentos();
// Conexão WiFi
WiFi.begin(ssid, password);
Serial.print("Conectando a ");
Serial.println(ssid);
while (WiFi.status() != WLCONNECTED) {
delay(1000);
Serial.print(".");
}
Serial.println();
Serial.println("Conectado ao WiFi");
Serial.print("Endereço IP: ");
Serial.println(WiFi.localIP());
// Configuração do servidor
server.on("/", handleRoot);
server.on("/roll", handleRollDice);
server.begin();
Serial.println("Servidor iniciado");
}
void loop() {
server.handleClient();
}
void handleRoot() {
server.sendP(200, "text/html", webpage);
}
void handleRollDice() {
int diceNumber = random(1, 7); // Gera um número entre 1 e 6
char result2;
itoa(diceNumber, result, 10);
server.send(200, "text/plain", result);
How to debug production cpp applications
At work we have production cpp applications running with o2 level of optimization
However during core dumps I often find the stack traces lacking. Also if I run the debugger, not much use from break points.
What is the best practice for this type of debugging. Should we make another build with no optimizations? But the memory locations are different right? The new debugger might not be able to correctly process with the debug build
Right now I sometimes build a debug build, run a dev service and send some traffic to reproduce. But it’s a lot of work to do this
https://redd.it/1ia6oh1
@r_cpp
Lightning Fast Lock-Free Queue - Roast Me
Code: Github
I built this single producer multi consumer (SPMC) and single producer single consumer (SPSC), random-access, ring buffer based on per-element atomic locks. I am a novice in CPP, and I want to learn my mistakes and flaws. I would really appreciate feedback on how I can improve this code, and in general what other things to build to improve my CPP skills. Please roast my code and tell me how to fix it!
I want to also be able to make it more production friendly where it can be used in an application. What should I add to it? Data serialization? This queue only accepts raw bytes, but I don't know if implementing a serialization/deserialization feature would be a good idea or if that should be left to the user to implement.
If anyone is interested in improving it with me I am open to collaboration too!!!!
Oh, and if you liked it, please ⭐️ it on github.
https://redd.it/1i9xwqq
@r_cpp
Where is std::snscanf
Why do we not have std::snscanf()?
https://redd.it/1i9yl74
@r_cpp
Can you tell me some free c/c++ ide for my intel mac
I don't like vs code 😔
https://redd.it/1i9pbn0
@r_cpp
If C++ had a mascot, what would it be?
Just a fun thought—if C++ were to have a mascot, what do you think it would be? Something that captures the complexity, power, and versatility of the language.
https://redd.it/1i9of4d
@r_cpp
Navigating corporate education benefits: What should a C++ developer pursue?
Hello fellow developers,
I'm a Development Engineer with several years of experience in the automotive industry, primarily working with C++ and occasionally scripting in Python. My company offers a generous education benefit, allowing us to choose courses from platforms like Coursera, Udemy, or any other educational resource. However, I'm struggling to find courses that are truly beneficial for my career advancement.
I would like to ask for any suggestions, whether they're specific courses, learning paths, or general advice on how to make the most of my company's education benefit. What would you recommend to a mid-career developer looking to enhance their skills and career prospects?
Thank you in advance for your insights and recommendations!
https://redd.it/1i9lbkc
@r_cpp
Protecting Coders From Ourselves: Better Mutex Protection
https://drilian.com/posts/2025.01.23-protecting-coders-from-ourselves-better-mutex-protection/
https://redd.it/1i9h4c6
@r_cpp
allowed
modifyResource(x);
readResource(x); // Valid: Mutable borrow modifies the resource
}
# Syntax
The typeprop system allows the specification of type properties directly in C++. The intention is that these could align with type theorhetic principles like linearity and affinity.
General Syntax: typeprop<property> type variable;
This syntax is a straw man. The name typeprop is chosed in preference to lifetime to indicate a potentially more generic used.
Alternatively we might use a concepts style syntax where lifetimes are special properties as proposed in the related paper on function colouring.
E.g. something like:
template <typename T>
concept BorrowedT = requires(T v)
{
{v} -> typeprop<Borrowed>;
};
Supported Properties:
* linear: Values must be used exactly once.
* affine: Values can be used at most once.
* borrow: Restrict references to immutable or a single mutable.
* mut\_borrow: Allow a single mutable reference.
* default\_lifetime: Default to existing C++ behaviour.
# Comparison with Safe C++
The safe c++ proposal adds borrowing semantics to C++. However it ties borrowing with function safety colouring. While those two things can be related it is also possible to consider them as independent facets of the language as we propose here. This proposal focuses solely on lifetime properties as a special case of a more general notion of type properties.
We propose a general purpose property system which can be used at compile time to enforce or help compute type propositions. We note that some propositions might not be computable from within the source at compile or even within existing compilers without the addition of a constraint solver or prover like Z3. A long term goal might be to expose an interface to that engine though the language itself. The more immediate goal would be to introduce just relatively simple life time properties that require a subset of that functionality and provide only limited computational power by making them equivalent to concepts.
https://redd.it/1i9e6ay
@r_cpp
ensures `processSensorData` cannot call `rawMemoryOperation`.
# **3.3 Coloring Functions as **async
# Why Coloring is Useful
Asynchronous programming often requires functions to execute in specific contexts (e.g., thread pools or event loops). Mixing sync and async functions can lead to subtle bugs like blocking in non-blocking contexts. Coloring functions as `async` enforces correct usage.
# Motivating Example
void fetchDataAsync() requires AsyncFunction {
// Non-blocking operation
}
void computeSync() requires SyncFunction {
// Blocking operation
}
Enforcing these constraints ensures `fetchDataAsync` cannot call `computeSync` directly, preventing unintentional blocking.
# **3.4 Transitive **const
# Why Coloring is Useful
D has the concept of transitive constness. If an object is transitively const, then it may only contain const references. This is particularly useful for ensuring immutability in large systems.
# Motivating Example
template<typename T>
concept TransitiveConst = requires(T t) {
// Ensure all members are const
{ t.get() } -> std::same_as<const T&>;
};
void readOnlyOperation(const MyType& obj) requires TransitiveConst {
// Cannot modify obj or its members
}
# 4. Design Goals
1. **Expressiveness**: Use existing C++ syntax (`requires`) to define function constraints.
2. **Backward Compatibility**: Avoid breaking changes to existing codebases.
3. **Minimal Language Impact**: Build on C++20 features (concepts) without introducing new keywords.
4. **Static Guarantees**: Enable compile-time enforcement of function-level properties.
5. **Meta-Programming Support**: Colors should be settable and retrievable at compile time using existing meta-programming approaches.
This is a strawman intended to spark conversation. It is not an official proposal and has no weight with the ISO committee. There is currently no implementation experience.
# 6. Syntax Alternatives Considered
1. **New Keyword**:
* Simpler syntax but adds language complexity.
* Risks backward compatibility issues.
2. **Attributes**:
* Lightweight but lacks compile-time enforcement.
* Relies on external tooling for validation.
* Attributes are not supposed to change the semantics of a program
https://redd.it/1i9cleb
@r_cpp
Function Colouring in C++ Using requires Constraints (A Strawman Proposal for linking new properties to functions)
# 1. Introduction
This is a strawman intended to spark conversation. It is not an official proposal. There is currently no implementation experience. This is one of a pair of independent proposals.
# 1.1 Problem Statement
Modern software development increasingly requires tools to enforce semantic constraints on functions, such as safety guarantees, immutability, and async execution. While C++20 introduced concepts to define and enforce type-based constraints, there is no standardized mechanism to enforce semantic properties like safety, immutability, or execution contexts at the function level.
This proposal introduces function colouring as a general-purpose mechanism to categorize and enforce semantic constraints on functions (or methods). The goal is to improve program correctness, readability, and maintainability by enhancing the existing requires syntax to express these constraints/properties.
# 2. Proposal
Every member or free function can be annotated to indicate that it has a property. We refer to this property as a "colour." In current C++, colour properties exist only for member functions, where we have:
`const`
virtual
`override`
noexcept
In other languages, there are properties such as:
async \- is this function asynchronous? Async functions prevent blocking operations in asynchronous contexts and ensure non-blocking execution.
pure \- does the function have side effects? Pure functions enable optimizations by guaranteeing that functions depend only on their inputs and have no observable side effects.
safe \- are there restrictions on using unsafe operations such as pointers? Safety-critical systems often require strict separation between safe and unsafe operations.
We propose to make this mechanism generic such that users can define their own properties using concepts. We use concepts because "colors" are part of the type system, and concepts represent types.
Independently of the coloring mechanism itself, it is possible to propose special "color" concepts like pure and safe, which cannot be implemented directly by programmers using concepts because they would require compiler analysis. The mechanism creates an extension point allowing new "colors" to be invented. We might add "color" concepts to `std::experimental` or allow vendors to provide their own through a compiler plugin mechanism.
# 3. Motivation and Use Cases
# 3.1 Coloring Functions as pure
# Why Coloring is Useful
In many codebases, functions are logically categorized as pure when they:
Do not mutate state.
Rely only on immutable data sources.
Don't produce side effects.
While member functions can be qualified with const, this is not possible for free functions or lambdas. Coloring these functions explicitly provides compile-time guarantees, making the code more self-documenting and resilient.
# Motivating Example
Languages like D and Fortran allow us to declare functions as side-effect-free. This enables the compiler to make optimizations that are not possible with functions that have side effects.
template<NumericType T>
T square(T x) requires PureFunction {
return x x;
}
# 3.2 Coloring Functions as safe
# Why Coloring is Useful
Safety-critical systems (e.g., automotive, medical) often require strict separation between safe and unsafe operations. For example:
Safe functions avoid raw pointers or unsafe operations.
Unsafe functions perform low-level operations and must be isolated.
Function coloring simplifies safety analysis by encoding these categories in the type system.
# Motivating Example
void processSensorData(std::shared_ptr<Data> data) requires SafeFunction {
// Safe memory operations
}
void rawMemoryOperation(void ptr) requires UnsafeFunction {
// Direct pointer manipulation
}
Using SafeFunction and UnsafeFunction concepts
Header only websocket client library
https://github.com/humz2k/fast-websocket-client
https://redd.it/1iak421
@r_cpp
Switching context from Haskell back to C++
Some C++ topics suddenly popped up for me, so now I find I have to do the context switch. It will be fine, but a little painful.
I have grow use to Haskell's expressiveness and being able to represent algorithms in a very laconic manner. For instance, I did the Levenshtein Distance algorithm in 3 lines of code:
lev "" ys = length ys
lev xs "" = length xs
lev (x : xs) (y : ys) | x == y = lev xs ys
| otherwise = 1 + minimum lev xs ys, lev (x : xs) ys, lev xs (y : ys)
Here is the same in C++, at least according to the Perplexity LLM:
// I don't count the #includes in my line count!
#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
int LevenshteinDistance(const std::string& source, const std::string& target) {
const sizet m = source.size();
const sizet n = target.size();
// Create a 2D matrix to store distances
std::vector<std::vector<int>> distance(m + 1, std::vector<int>(n + 1));
// Initialize the matrix
for (sizet i = 0; i <= m; ++i) {
distance[i][0] = i; // Deletion cost
}
for (sizet j = 0; j <= n; ++j) {
distance0j = j; // Insertion cost
}
// Compute the distances
for (sizet i = 1; i <= m; ++i) {
for (sizet j = 1; j <= n; ++j) {
int cost = (sourcei - 1 == targetj - 1) ? 0 : 1; // Substitution cost
distanceij = std::min({
distancei - 1j + 1, // Deletion
distanceij - 1 + 1, // Insertion
distancei - 1j - 1 + cost // Substitution
});
}
}
return distancemn; // The bottom-right cell contains the Levenshtein distance
}
The problem here, as I see it, is that C++ does not have list comprehension, nor infinite arrays. As a result, what only took 3 lines in Haskell takes 20 lines in C++, not counting the comments and whitespace and the #include. And curiously, it's the exact same algorithm.
I love C++ but...!
Painful? You bet.
https://redd.it/1iagp60
@r_cpp
Vector of variants as struct of vectors?
Just saw this CppCon talk about improving a vector of variants:
https://www.youtube.com/watch?v=VDoyQyMXdDU
The proposed solution is storing mixed types in a single vector along with a metadata vector to identify them and their offset.
But I feel like it has lots of downsides, especially when it comes to changing the type of an element,
as it can trigger the shift or reallocation of all data (breaking important vector api contracts).
The alternative I was thinking about during the presentation was more along the lines of a struct of multiple vectors, one per variant sub-type, plus a metadata vector storing an id + index into one of these vectors.
An intrusive free list could also be used to reuse erased elements memory inside the vectors (preserving index of others elements).
It's not a perfect solution either (e.g. still suffer from the proxy reference issue for operator[\]) but it seems more flexible and to have less surprising behaviors than the original solution (also less padding).
What do you think?
I'm sure other people already though of that but I couldn't find any open source implementation out there.
https://redd.it/1iacrpj
@r_cpp
I have a problem with a school project.
I'm doing a C++ code where I have to upload a local ESP8266 server for data rolling, there will be a button on the website and it will draw a random number, so far so good, it's going smoothly. However, on the ESP8266 board the number doesn't turn on all the LEDs, for example the number 6, I'll show you here the code and the photo of the display:
#include <ESP8266WiFi.h>
#include <ESP8266WebServer.h>
// Configuração do WiFi
const char* ssid = "SPEED TURBO-ELGFJ";
const char* password = "F20112017";
ESP8266WebServer server(80);
// Define os valores dos dígitos para o display de 7 segmentos
const byte digitos[10][7] = {
{HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, LOW}, // 0
{LOW, HIGH, HIGH, LOW, LOW, LOW, LOW}, // 1
{HIGH, HIGH, LOW, HIGH, HIGH, LOW, HIGH}, // 2
{HIGH, HIGH, HIGH, HIGH, LOW, LOW, HIGH}, // 3
{LOW, HIGH, HIGH, LOW, LOW, HIGH, HIGH}, // 4
{HIGH, LOW, HIGH, HIGH, LOW, HIGH, HIGH}, // 5
{HIGH, LOW, HIGH, HIGH, HIGH, HIGH, HIGH},// 6
{HIGH, HIGH, HIGH, LOW, LOW, LOW, LOW}, // 7
{HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH}, // 8
{HIGH, HIGH, HIGH, LOW, LOW, HIGH, HIGH} // 9
};
// Pinos GPIO do ESP8266
#define PIN_A 4 // GPIO4 (D2)
#define PIN_B 0 // GPIO0 (D3)
#define PIN_C 2 // GPIO2 (D4)
#define PIN_D 14 // GPIO14 (D5) - Inferior
#define PIN_E 12 // GPIO12 (D6)
#define PIN_F 13 // GPIO13 (D7)
#define PIN_G 15 // GPIO15 (D8) - Meio
#define PIN_DP 16 // GPIO16 (D0)
// Página da interface web
const char webpage[] PROGMEM = R"rawliteral(
<!DOCTYPE html>
<html>
<head>
<title>Rolar Dado</title>
<style>
body { font-family: Arial, sans-serif; text-align: center; margin-top: 50px; }
button { padding: 10px 20px; font-size: 18px; }
#result { font-size: 24px; margin-top: 20px; }
</style>
</head>
<body>
<h1>Rolar Dado</h1>
<button onclick="rollDice()">Rolar</button>
<div id="result"></div>
<script>
function rollDice() {
var xhttp = new XMLHttpRequest();
xhttp.onreadystatechange = function() {
if (this.readyState == 4 && this.status == 200) {
document.getElementById("result").innerHTML = "Número: " + this.responseText;
}
};
xhttp.open("GET", "/roll", true);
xhttp.send();
}
</script>
</body>
</html>
)rawliteral";
void setup() {
Serial.begin(115200);
// Configuração dos pinos do display de 7 segmentos
pinMode(PIN_A, OUTPUT);
pinMode(PIN_B, OUTPUT);
pinMode(PIN_C, OUTPUT);
pinMode(PIN_D, OUTPUT);
pinMode(PIN_E, OUTPUT);
pinMode(PIN_F, OUTPUT);
pinMode(PIN_G, OUTPUT);
pinMode(PIN_DP, OUTPUT);
// Teste inicial dos segmentos G e D
testeSegmentos();
// Conexão WiFi
WiFi.begin(ssid, password);
Serial.print("Conectando a ");
Serial.println(ssid);
while (WiFi.status() != WL_CONNECTED) {
delay(1000);
Serial.print(".");
}
Serial.println();
Serial.println("Conectado ao WiFi");
Serial.print("Endereço IP: ");
Serial.println(WiFi.localIP());
// Configuração do servidor
server.on("/", handleRoot);
server.on("/roll", handleRollDice);
server.begin();
Serial.println("Servidor iniciado");
}
void loop() {
server.handleClient();
}
void handleRoot() {
server.send_P(200, "text/html", webpage);
}
void handleRollDice() {
int diceNumber = random(1, 7); // Gera um número entre 1 e 6
char result[2];
itoa(diceNumber, result, 10);
server.send(200, "text/plain", result);
Static variable initialization order fiasco
Hi, this is a well known issue in C++ but I still don't get to see it being worked upon by the committee. And a significant drawback of C++ when you don't know how static const variables across different compilation units requiring dynamic initialization using a method call or more than one method calls in order to initialize it, takes place in order for it to be used in other compilation units. This issue has been present since C++ exists and I still don't see it getting the attention it deserves, besides replacing the variable with a singleton class, or similar hacks using a runonce, which is just a make up on top of the fact that proper, in-order initialization of global variables across compilation units in C++ is still undefined.
https://redd.it/1ia8vkz
@r_cpp
When should I abandon projects that rely on horrible dependencies?
Hi friends.
This week I tried to build google's Mediapipe with cpp on Windows. After 2 days of finding one build bug after another, bad Bazel configs for the main repo and on the dependency-level, wrestling with lackluster documentation, bad python configs, and excessive segmentation in the workspace logic across the project files, I have checked out. This was mainly because, after 21 hours of fixing one build problem, only to get another one, then another, and another, it just made me think "this is bad code. I'd much rather implement all the the AI myself and link them later. At least I can make the project useful for others even if it takes some time to finish."
This has made me curious about how other people handle these issues. How long are you willing to wrestle with badly designed depencendies?
https://redd.it/1ia2kio
@r_cpp
Jonas Minnberg: Web Assembly (With less Web, and more Assembly)
https://youtu.be/M6fYblORvqU
https://redd.it/1i9y6kj
@r_cpp
Simple way/guideline to make library conan/vcpkg compatible?
Hi,
so I have this fancy library of mine https://github.com/koniarik/vari \- variadic pointers. The thing is that I don't have much experience with conan/vcpkg but would like to try to add support for it into these. (Some with conan, none with vcpkg) How to approach this?
That is, are there some sane materials that would show me how to make bare minimum C++ package? in a way that it is easily updated in the package managers in longterm?
P.S: If you want take a look at the lib itself I would like that, but so far it's not integrated anywhere
https://redd.it/1i9s90e
@r_cpp
std::nontype_t: What is it, and Why?
https://biowpn.github.io/bioweapon/2025/01/25/std-nontype.html
https://redd.it/1i9pkho
@r_cpp
Statistical Sampling of Memory Profiler
I am a newbie to this field. I am working on a memory profiler where the aim is to generate peak memory usage (with thread and stack trace information) over the duration of program execution. There might be multiple memory peaks during a program which needs to be reported correctly. My current understanding is that it is too expensive (both runtime and memory wise) for the profiler to track every single allocation and deallocation. So we need to sample some of the allocations and deallocations (not all), and use statistical methods to arrive to peak memory usage with some amount of confidence. Sorry for being vague, this is what I know. Is any literature or GitHub code available for understanding statistical profiling? What are the information that needs to be dumped by the profiler into a file so that statistical methods can be applied?
https://redd.it/1i9kz53
@r_cpp
First job c++
What should I know before applying for the job. For various specialties like game dev, web dev, software dev or something else.
I mostly thing I can’t apply for the job because I don’t know enough
https://redd.it/1i9j6z3
@r_cpp
LevelDB Explained - Implementation and Optimization Details of Key-Value Writing
This article provides an in-depth analysis of LevelDB's write mechanism, detailing the complete process from the Put interface to WAL logging and MemTable persistence. Through source code analysis, it reveals how LevelDB achieves 400,000 writes per second throughput through core technologies like WriteBatch merging strategy, dual MemTable memory management, WAL sequential write optimization, and dynamic Level0 file throttling. It also explores engineering details such as mixed sync write handling, small key-value merge optimization, and data consistency in exceptional scenarios, helping you master the design essence and implementation strategies of LevelDB's high-performance writing.
LevelDB Explained - Implementation and Optimization Details of Key-Value Writing
https://redd.it/1i9f9b9
@r_cpp
Proposal: Introducing Linear, Affine, and Borrowing Lifetimes in C++
This is a strawman intended to spark conversation. It is not an official proposal. There is currently no implementation experience. This is one of a pair of independent proposals. The other proposal relates to function colouring.
**caveat**
This was meant to be written in the style of a proper ISO proposal but I ran out of time and energy. It should be sufficient to get the gist of the idea.
# Abstract
This proposal introduces **linear, affine, and borrowing lifetimes** to C++ to enhance safety and expressiveness in resource management and other domains requiring fine-grained control over ownership and lifetimes. By leveraging the concepts of linear and affine semantics, and borrowing rules inspired by Rust, developers can achieve deterministic resource handling, prevent common ownership-related errors and enable new patterns in C++ programming. The default lifetime is retained to maintain compatibility with existing C++ semantics. In a distant future the default lifetime could be inverted to give safety by default if desired.
**Proposal**
We add the concept of lifetime to the C++ type system as **type properties**. A type property can be added to any type. Lifetime type related properties suggested initially are, linear, affine, or borrow checked. We propose that other properties (lifetime based or otherwise) might be modelled in a similar way. For simplicity we ignore allocation and use of move semantics in the examples below.
* **Linear Types**: An object declared as being of a linear type must be used exactly once. This guarantees deterministic resource handling and prevents both overuse and underuse of resources.
Example:
struct LinearResource { int id; };
void consumeResource(typeprop<linear> LinearResource res) { // Resource is consumed here. }
void someFunc()
{
LinearResource res{42};
consumeResource(res); // Valid
consumeResource(res); // Compile-time error: res already consumed.
}
* **Affine Types** \- An object declared as affine can be used at most once. This relaxes the restriction of linear types by allowing destruction without requiring usage.
Example:
struct AffineBuffer { void* data; size_t size; };
void transferBuffer(typeprop<affine> AffineBuffer from, typeprop<affine> AffineBuffer& to) {
to = std::move(from);
}
AffineBuffer buf{nullptr, 1024};
AffineBuffer dest;
transferBuffer(std::move(buf), dest); // Valid
buf = {nullptr, 512}; // Valid: resetting is allowed
* **Borrow Semantics** \- A type with borrow semantics restricts the references that may exist to it.
* There may be a single mutable reference, or
* There may be multiple immutable references.
* The object may not be deleted or go out of scope while any reference exists.
Borrowing Example in Rust
fn main() { let mut x = String::from("Hello");
// Immutable borrow
let y = \&x;
println!("{}", y); // Valid: y is an immutable borrow
// Mutable borrow
// let z = &mut x; // Error: Cannot mutably borrow \`x\` while it is immutably borrowed
// End of immutable borrow
println!("{}", x); // Valid: x is accessible after y goes out of scope
// Mutable borrow now allowed
let z = &mut x;
z.push\_str(", world!");
println!("{}", z); // Valid: z is a mutable borrow
}
Translated to C++ with typeprop
include <iostream>
include <string>
struct BorrowableResource { std::string value; };
void readResource(typeprop<borrow> const BorrowableResource& res) { std::cout << res.value << std::endl; }
void modifyResource(typeprop<mut\_borrow> BorrowableResource& res) { res.value += ", world!"; }
int main() { BorrowableResource x{"Hello"};
// Immutable borrow
readResource(x); // Valid: Immutable borrow
// Mutable borrow
// modifyResource(x); // Compile-time error: Cannot mutably borrow while x is immutably borrowed
// End of immutable borrow
readResource(x); // Valid: Immutable borrow ends
// Mutable borrow now
Function Colouring in C++ Using requires Constraints (A Strawman Proposal for linking new properties to functions)
# 1. Introduction
This is a strawman intended to spark conversation. It is not an official proposal. There is currently no implementation experience. This is one of a pair of independent proposals.
# 1.1 Problem Statement
Modern software development increasingly requires tools to enforce **semantic constraints** on functions, such as safety guarantees, immutability, and async execution. While C++20 introduced **concepts** to define and enforce type-based constraints, there is no standardized mechanism to enforce semantic properties like **safety**, **immutability**, or **execution contexts** at the function level.
This proposal introduces **function colouring** as a general-purpose mechanism to categorize and enforce semantic constraints on functions (or methods). The goal is to improve program correctness, readability, and maintainability by enhancing the existing `requires` syntax to express these constraints/properties.
# 2. Proposal
Every member or free function can be annotated to indicate that it has a property. We refer to this property as a "colour." In current C++, colour properties exist only for member functions, where we have:
* `const`
* `virtual`
* `override`
* `noexcept`
In other languages, there are properties such as:
* **async** \- is this function asynchronous? *Async functions prevent blocking operations in asynchronous contexts and ensure non-blocking execution.*
* **pure** \- does the function have side effects? *Pure functions enable optimizations by guaranteeing that functions depend only on their inputs and have no observable side effects.*
* **safe** \- are there restrictions on using unsafe operations such as pointers? *Safety-critical systems often require strict separation between safe and unsafe operations.*
We propose to make this mechanism generic such that users can define their own properties using concepts. We use concepts because "colors" are part of the type system, and concepts represent types.
Independently of the coloring mechanism itself, it is possible to propose special "color" concepts like **pure** and **safe**, which cannot be implemented directly by programmers using concepts because they would require compiler analysis. The mechanism creates an extension point allowing new "colors" to be invented. We might add "color" concepts to `std::experimental` or allow vendors to provide their own through a compiler plugin mechanism.
# 3. Motivation and Use Cases
# **3.1 Coloring Functions as **pure
# Why Coloring is Useful
In many codebases, functions are logically categorized as **pure** when they:
* Do not mutate state.
* Rely only on immutable data sources.
* Don't produce side effects.
While member functions can be qualified with `const`, this is not possible for free functions or lambdas. Coloring these functions explicitly provides compile-time guarantees, making the code more self-documenting and resilient.
# Motivating Example
Languages like D and Fortran allow us to declare functions as side-effect-free. This enables the compiler to make optimizations that are not possible with functions that have side effects.
template<NumericType T>
T square(T x) requires PureFunction {
return x * x;
}
# **3.2 Coloring Functions as **safe
# Why Coloring is Useful
Safety-critical systems (e.g., automotive, medical) often require strict separation between **safe** and **unsafe** operations. For example:
* **Safe** functions avoid raw pointers or unsafe operations.
* **Unsafe** functions perform low-level operations and must be isolated.
Function coloring simplifies safety analysis by encoding these categories in the type system.
# Motivating Example
void processSensorData(std::shared_ptr<Data> data) requires SafeFunction {
// Safe memory operations
}
void rawMemoryOperation(void* ptr) requires UnsafeFunction {
// Direct pointer manipulation
}
Using `SafeFunction` and `UnsafeFunction` concepts
Looking for ways to micro benchmark a SPSC Queue latency in a multithreaded environment
This is what i have so far, any help or insights is well appreciated.
template<typename ElementType>
static void BM_IESPSCQueue_Latency(benchmark::State& state)
{
const unsigned int N = state.range(0);
IESPSCQueue<ElementType> Queue1(N), Queue2(N);
for (auto _ : state)
{
std::thread Thread = std::thread([&]
{
for (int i = 0; i < N; i++)
{
ElementType Element;
benchmark::DoNotOptimize(Element);
while (!Queue1.Pop(Element)) {}
while (!Queue2.Push(Element)) {}
}
});
auto Start = std::chrono::high_resolution_clock::now();
for (int i = 0; i < N; i++)
{
while (!Queue1.Push(ElementType())) {}
ElementType Element;
benchmark::DoNotOptimize(Element);
while (!Queue2.Pop(Element)) {}
}
auto End = std::chrono::high_resolution_clock::now();
auto Elapsed = std::chrono::duration_cast<std::chrono::duration<double>>(End - Start);
state.SetIterationTime(Elapsed.count());
Thread.join();
benchmark::ClobberMemory();
}
state.SetItemsProcessed(N * state.iterations());
}
https://redd.it/1i94mtf
@r_cpp