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
Post #24701
21
Channel Public Channel
C+ C++ - Reddit
@r_cpp
- Subscribers
- 229
- Photos
- 48
- Videos
- 8
- Links
- 25.5K
Showing posts older than #24702 · Back to latest
Older Posts 20 shown
Post #24700
15
we can simply add N characters without first creating a string with them
// Instead of creating a string with 10 'a' characters and adding
... + text + std::string{10, 'a'} + ...
// we use a string expression that simply places 10 'a' characters into the result
... + text + expr_pad<char>{10, 'a'} + ...
The [simstr](https://github.com/orefkov/simstr) library already has many such "smart" string expressions out of the box - for example, joining strings from a container, conditional selection from two expressions, replacing substrings. There are string expressions that take a number and place their decimal or hexadecimal representation into a string (for the decimal representation, `operator+` is specially overloaded for numbers and you can simply write `text + number`).
Using [this library](https://github.com/orefkov/simstr), the code for working with strings will be easier to write, and it will work faster.
The acceleration of string operations has been confirmed by [many benchmarks](https://orefkov.github.io/simstr/results.html).
# Usage examples
# Adding strings with numbers
std::string s1 = "start ";
int i;
....
// Was
std::string str = s1 + std::to_string(i) + " end";
// Became
std::string str = +s1 + i + " end";
`+s1` \- converts `std::string` into an object - a string expression, for which there is an efficient concatenation with numbers and string literals.
According to benchmarks, [acceleration is 1.6 - 2 times](https://orefkov.github.io/simstr/results.html#bs70109915512075798510).
# Adding strings with numbers in hex format
....
// Was
std::string str = s1 + std::format("0x{:x}", i) + " end";
// Became
std::string str = +s1 + e_hex<HexFlags::Short>(i) + " end";
Acceleration in [**9 - 14 times!!!**](https://orefkov.github.io/simstr/results.html#bs146911715078927772520)
# Adding multiple literals and searching in std::string_view
// It was like this
size_t find_pos(std::string_view src, std::string_view name) {
// before C++26 we can not concatenate string and string_view...
return src.find("\n- "s + std::string{name} + " -\n");
}
// When using only "strexpr.h" it became like this
size_t find_pos(ssa src, ssa name) {
return src.find(std::string{"\n- " + name + " -\n"});
}
// And when using the full library, you can do this
size_t find_pos(ssa src, ssa name) {
// In this version, if the result of the concatenation fits into 207 characters, it is produced in a buffer on the stack,
// without allocation and deallocation of memory, acceleration is several times. And only if the result is longer than 207 characters -
// there will be only one allocation, and the concatenation will be immediately into the allocated buffer, without copying characters.
return src.find(lstringa<200>{"\n- " + name + " -\n"});
}
`ssa` \- alias for `simple_str<char>` \- analogue of `std::string_view`, allows you to accept any string object as a function parameter with minimal costs, which does not need to be modified or passed to the C-API: `std::string`, `std::string_view`, `"string literal"`, `simple_str_nt`, `sstring`, `lstring`. Also, since it is also a "string expression", it allows you to easily build concatenations with its participation.
According to measurements, [acceleration is 1.5 - 9 times](https://orefkov.github.io/simstr/results.html#bs68116594352702954700).
You can see more examples on [GitHub](https://github.com/orefkov/simstr).
https://redd.it/1qiyxis
@r_cpp
GitHub GitHub - orefkov/simstr: Yet another C++ strings library implementation Yet another C++ strings library implementation. Contribute to orefkov/simstr development by creating an account on GitHub. // Instead of creating a string with 10 'a' characters and adding
... + text + std::string{10, 'a'} + ...
// we use a string expression that simply places 10 'a' characters into the result
... + text + expr_pad<char>{10, 'a'} + ...
The [simstr](https://github.com/orefkov/simstr) library already has many such "smart" string expressions out of the box - for example, joining strings from a container, conditional selection from two expressions, replacing substrings. There are string expressions that take a number and place their decimal or hexadecimal representation into a string (for the decimal representation, `operator+` is specially overloaded for numbers and you can simply write `text + number`).
Using [this library](https://github.com/orefkov/simstr), the code for working with strings will be easier to write, and it will work faster.
The acceleration of string operations has been confirmed by [many benchmarks](https://orefkov.github.io/simstr/results.html).
# Usage examples
# Adding strings with numbers
std::string s1 = "start ";
int i;
....
// Was
std::string str = s1 + std::to_string(i) + " end";
// Became
std::string str = +s1 + i + " end";
`+s1` \- converts `std::string` into an object - a string expression, for which there is an efficient concatenation with numbers and string literals.
According to benchmarks, [acceleration is 1.6 - 2 times](https://orefkov.github.io/simstr/results.html#bs70109915512075798510).
# Adding strings with numbers in hex format
....
// Was
std::string str = s1 + std::format("0x{:x}", i) + " end";
// Became
std::string str = +s1 + e_hex<HexFlags::Short>(i) + " end";
Acceleration in [**9 - 14 times!!!**](https://orefkov.github.io/simstr/results.html#bs146911715078927772520)
# Adding multiple literals and searching in std::string_view
// It was like this
size_t find_pos(std::string_view src, std::string_view name) {
// before C++26 we can not concatenate string and string_view...
return src.find("\n- "s + std::string{name} + " -\n");
}
// When using only "strexpr.h" it became like this
size_t find_pos(ssa src, ssa name) {
return src.find(std::string{"\n- " + name + " -\n"});
}
// And when using the full library, you can do this
size_t find_pos(ssa src, ssa name) {
// In this version, if the result of the concatenation fits into 207 characters, it is produced in a buffer on the stack,
// without allocation and deallocation of memory, acceleration is several times. And only if the result is longer than 207 characters -
// there will be only one allocation, and the concatenation will be immediately into the allocated buffer, without copying characters.
return src.find(lstringa<200>{"\n- " + name + " -\n"});
}
`ssa` \- alias for `simple_str<char>` \- analogue of `std::string_view`, allows you to accept any string object as a function parameter with minimal costs, which does not need to be modified or passed to the C-API: `std::string`, `std::string_view`, `"string literal"`, `simple_str_nt`, `sstring`, `lstring`. Also, since it is also a "string expression", it allows you to easily build concatenations with its participation.
According to measurements, [acceleration is 1.5 - 9 times](https://orefkov.github.io/simstr/results.html#bs68116594352702954700).
You can see more examples on [GitHub](https://github.com/orefkov/simstr).
https://redd.it/1qiyxis
@r_cpp
Post #24699
11
How to concatenate strings quickly? Expression Templates to the rescue!
In this short post, I want to briefly describe the "Expression Templates" technique I use in the [simstr](https://github.com/orefkov/simstr) library to speed up string concatenation. The main point is that when adding several string operands, temporary intermediate strings are not created, into which characters are sequentially added, which leads to repeated allocation and movement of characters from buffer to buffer. Instead, the length of the final result is calculated only once, space is allocated for it only once, and the characters of the operands are copied directly to the final buffer in their place.
This is achieved using so-called "string expressions".
A string expression is an object of any type that has the following methods:
size_t length() const; // Returns the length of its operand
K* place(K* ptr) const; // Places the characters of the result into the provided buffer, returns the position after them
To check that a type is a string expression, a concept is created
template<typename A>
concept StrExpr = requires(const A& a) {
typename A::symb_type;
{ a.length() } -> std::convertible_to<size_t>;
{ a.place(std::declval<typename A::symb_type*>()) } -> std::same_as<typename A::symb_type*>;
};
Then any string object that wants to be initialized from a string expression will first request its length, then allocate the necessary space, and ask the string expression to be placed in that space.
And then a little template magic. We create a template class `strexprjoin`:
template<StrExpr A, StrExprForType<typename A::symb_type> B>
struct strexprjoin {
using symb_type = typename A::symb_type;
const A& a;
const B& b;
constexpr strexprjoin(const A& a_, const B& b_) : a(a_), b(b_){}
constexpr size_t length() const noexcept {
return a.length() + b.length();
}
constexpr symb_type* place(symb_type* p) const noexcept {
return b.place(a.place(p));
}
};
As you can see, this class itself is a string expression. It stores references to two other string expressions. When its length is requested, it returns the sum of the lengths of the expressions stored in it. When asked to place characters, it first places the characters of the first expression, and then the second.
It remains to make a template addition operator for two string expressions:
template<StrExpr A, StrExprForType<typename A::symb_type> B>
constexpr strexprjoin<A, B> operator+(const A& a, const B& b) {
return {a, b};
}
Now any two objects that satisfy the string expression concept can be added, and the result will be a `strexprjoin` object, storing references to its terms: `e1 + e2 --> ej[e1, e2]`. And since this new object also satisfies the string expression concept, you can also apply addition with the next string expression: `e1 + e2 + e3 --> ej[e1, e2] + e3 --> ej[ej[e1, e2], e3]`. Thus, you can build chains of several operands.
When a string object, during initialization, requests the required length from the final result of addition operations, it will return the sum of the lengths of the operands included in it, and then sequentially place their characters into the resulting buffer.
This technology provides fast concatenation of several strings. But this technique is not limited to this. After all, a string expression can not only copy a string, but also create strings itself.
For example, you can create a string expression that generates N given characters:
template<typename K>
struct expr_pad {
using symb_type = K;
size_t len;
K s;
constexpr expr_pad(size_t len_, K s_) : len(len_), s(s_){}
constexpr size_t length() const noexcept {
return len;
}
constexpr symb_type* place(symb_type* p) const noexcept {
if (len)
std::char_traits<K>::assign(p, len, s);
return p + len;
}
};
And voila,
GitHub GitHub - orefkov/simstr: Yet another C++ strings library implementation Yet another C++ strings library implementation. Contribute to orefkov/simstr development by creating an account on GitHub. In this short post, I want to briefly describe the "Expression Templates" technique I use in the [simstr](https://github.com/orefkov/simstr) library to speed up string concatenation. The main point is that when adding several string operands, temporary intermediate strings are not created, into which characters are sequentially added, which leads to repeated allocation and movement of characters from buffer to buffer. Instead, the length of the final result is calculated only once, space is allocated for it only once, and the characters of the operands are copied directly to the final buffer in their place.
This is achieved using so-called "string expressions".
A string expression is an object of any type that has the following methods:
size_t length() const; // Returns the length of its operand
K* place(K* ptr) const; // Places the characters of the result into the provided buffer, returns the position after them
To check that a type is a string expression, a concept is created
template<typename A>
concept StrExpr = requires(const A& a) {
typename A::symb_type;
{ a.length() } -> std::convertible_to<size_t>;
{ a.place(std::declval<typename A::symb_type*>()) } -> std::same_as<typename A::symb_type*>;
};
Then any string object that wants to be initialized from a string expression will first request its length, then allocate the necessary space, and ask the string expression to be placed in that space.
And then a little template magic. We create a template class `strexprjoin`:
template<StrExpr A, StrExprForType<typename A::symb_type> B>
struct strexprjoin {
using symb_type = typename A::symb_type;
const A& a;
const B& b;
constexpr strexprjoin(const A& a_, const B& b_) : a(a_), b(b_){}
constexpr size_t length() const noexcept {
return a.length() + b.length();
}
constexpr symb_type* place(symb_type* p) const noexcept {
return b.place(a.place(p));
}
};
As you can see, this class itself is a string expression. It stores references to two other string expressions. When its length is requested, it returns the sum of the lengths of the expressions stored in it. When asked to place characters, it first places the characters of the first expression, and then the second.
It remains to make a template addition operator for two string expressions:
template<StrExpr A, StrExprForType<typename A::symb_type> B>
constexpr strexprjoin<A, B> operator+(const A& a, const B& b) {
return {a, b};
}
Now any two objects that satisfy the string expression concept can be added, and the result will be a `strexprjoin` object, storing references to its terms: `e1 + e2 --> ej[e1, e2]`. And since this new object also satisfies the string expression concept, you can also apply addition with the next string expression: `e1 + e2 + e3 --> ej[e1, e2] + e3 --> ej[ej[e1, e2], e3]`. Thus, you can build chains of several operands.
When a string object, during initialization, requests the required length from the final result of addition operations, it will return the sum of the lengths of the operands included in it, and then sequentially place their characters into the resulting buffer.
This technology provides fast concatenation of several strings. But this technique is not limited to this. After all, a string expression can not only copy a string, but also create strings itself.
For example, you can create a string expression that generates N given characters:
template<typename K>
struct expr_pad {
using symb_type = K;
size_t len;
K s;
constexpr expr_pad(size_t len_, K s_) : len(len_), s(s_){}
constexpr size_t length() const noexcept {
return len;
}
constexpr symb_type* place(symb_type* p) const noexcept {
if (len)
std::char_traits<K>::assign(p, len, s);
return p + len;
}
};
And voila,
Post #24698
19
factors at play:
We approached the problem anew, and fresh eyes quickly saw several areas for improvement that had nothing to do with the implementation language per se.
Other improvements came about because we were using a different language with its own idioms, strengths, and weaknesses that forced some new thinking.
We rewrote the C++ version to incorporate those improvements and to backport some of the new ideas from using Rust.
Writing solutions to the same problem in multiple languages has significant benefits, but of course, it is expensive and hard to justify in commercial settings. Perhaps we should repeat this
For the most part, the two versions are feature equivalent (a few things are not possible in Rust). They also have very similar performance characteristics, with neither being significantly faster than the other in most scenarios.
https://redd.it/1qjbxwl
@r_cpp
We approached the problem anew, and fresh eyes quickly saw several areas for improvement that had nothing to do with the implementation language per se.
Other improvements came about because we were using a different language with its own idioms, strengths, and weaknesses that forced some new thinking.
We rewrote the C++ version to incorporate those improvements and to backport some of the new ideas from using Rust.
Writing solutions to the same problem in multiple languages has significant benefits, but of course, it is expensive and hard to justify in commercial settings. Perhaps we should repeat this
gf2 exercise in a third language someday!For the most part, the two versions are feature equivalent (a few things are not possible in Rust). They also have very similar performance characteristics, with neither being significantly faster than the other in most scenarios.
https://redd.it/1qjbxwl
@r_cpp
Post #24697
19
Implementing a Numerical Library in both C++ and Rust
It is available both as a C++ library and as a Rust crate with similar, though not identical, interfaces and features.
Even if you aren't involved in the mathematics of bit-space, you may find comparing the two implementations interesting.
Mathematicians refer to bit-space as GF(2)). It is the simplest Galois Field with just two elements, 0 and 1.
All arithmetic is modulo 2, so what starts in bit-space stays in bit-space. Addition/subtraction becomes the
# Principal Classes & Types
The principal C++ classes and Rust types in the two versions of
|C++ Class|Rust Type|Description|
|:-|:-|:-|
|
|
|
|
|
As you can see, there are is a name change to accommodate idioms in the languages; the C++
The
There are other classes and types in
The
The classes and types are efficient and pack the individual bit elements into natural unsigned word blocks. There is a rich interface for setting up and manipulating instances, and for allowing them to interact with each other.
The C++ library has a comprehensive long-form documentation site, its code is available here.
The Rust crate is available on crates.io, its source code is available here, and there is documentation on docs.rs. The Rust documentation is complete but a little less comprehensive than the C++ version, mainly because
All the code is under a permissive MIT license.
The C++ version predates the Rust crate. We ported to Rust manually, as, at least for now, LLMs cannot handle this sort of translation task and produce anything that is at all readable or verifiable.
As you might expect with a rewrite, the new version considerably improved on the original. There were two beneficial
gf2 focuses on efficient numerical work in bit-space, where mathematical entities such as vectors, matrices, and polynomial coefficients are limited to zeros and ones.It is available both as a C++ library and as a Rust crate with similar, though not identical, interfaces and features.
Even if you aren't involved in the mathematics of bit-space, you may find comparing the two implementations interesting.
Mathematicians refer to bit-space as GF(2)). It is the simplest Galois Field with just two elements, 0 and 1.
All arithmetic is modulo 2, so what starts in bit-space stays in bit-space. Addition/subtraction becomes the
XOR operation, and multiplication/division becomes the AND operation. gf2 uses those equivalences to efficiently perform most operations by simultaneously operating on entire blocks of bit elements at a time. We never have to worry about overflows or carries as we would with normal integer arithmetic. Moreover, these operations are highly optimised in modern CPUs, enabling fast computation even on large bit-matrices and bit-vectors.# Principal Classes & Types
The principal C++ classes and Rust types in the two versions of
gf2 are:|C++ Class|Rust Type|Description|
|:-|:-|:-|
|
BitArray|BitArray|A fixed-size vector of bits.||
BitVec|BitVec|A dynamically-sized vector of bits.||
BitSpan|BitSlice|A non-owning view into contiguous ranges of bits.||
BitPoly|BitPoly|A polynomial over GF(2).||
BitMat|BitMat|A dynamically-sized matrix of bits.|As you can see, there are is a name change to accommodate idioms in the languages; the C++
BitSpan class corresponds to the BitSlice type in Rust (C++ uses spans, Rust uses slices). There are other changes in the same vein elsewhere — C++ vectors have a size() method, Rust vectors have a len() method, and so on.The
BitArray, BitVec, and BitSpan/BitSlice classes and types share many methods. In C++, each satisfies the requirements of a BitStore concept. In Rust, they implement a BitStore trait. In either case, the BitStore core provides a rich common interface for manipulating collections of bits. Those functions include bit accessors, mutators, fills, queries, iterators, stringification methods, bit-wise operators on and between bit-stores, arithmetic operators, and more.There are other classes and types in
gf2 to support linear algebra operations, such as solving systems of linear equations, finding matrix inverses, and computing eigenvalues and eigenvectors. Among other things, the interface includes methods for examining the eigen-structure of large bit-matrices.The
BitPoly class provides methods to compute x^N mod p(x), where p(x) is a bit-polynomial and N is a potentially large integer.The classes and types are efficient and pack the individual bit elements into natural unsigned word blocks. There is a rich interface for setting up and manipulating instances, and for allowing them to interact with each other.
The C++ library has a comprehensive long-form documentation site, its code is available here.
The Rust crate is available on crates.io, its source code is available here, and there is documentation on docs.rs. The Rust documentation is complete but a little less comprehensive than the C++ version, mainly because
docs.rs does not support MathJax—a long-standing issue for scientific Rust.All the code is under a permissive MIT license.
The C++ version predates the Rust crate. We ported to Rust manually, as, at least for now, LLMs cannot handle this sort of translation task and produce anything that is at all readable or verifiable.
As you might expect with a rewrite, the new version considerably improved on the original. There were two beneficial
Post #24696
44
ISO C++ 2026-01 Mailing is now available
https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2026/#mailing2026-01
https://redd.it/1qewi79
@r_cpp
https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2026/#mailing2026-01
https://redd.it/1qewi79
@r_cpp
Post #24695
47
Designated Initializers, the best feature of C++20 · Mathieu Ropert
https://mropert.github.io/2026/01/15/designed_initializers/
https://redd.it/1qelm4y
@r_cpp
mropert.github.io Designated Initializers, the best feature of C++20 · Mathieu Ropert Of all the features added to C++ over the past years, I think Designated Initializers is both the best and one of the least talked about. Time to right that wrong. https://mropert.github.io/2026/01/15/designed_initializers/
https://redd.it/1qelm4y
@r_cpp
Post #24694
45
How do exceptions work in C++ on Linux?
https://pvs-studio.com/en/blog/posts/cpp/1333/
https://redd.it/1qehue6
@r_cpp
https://pvs-studio.com/en/blog/posts/cpp/1333/
https://redd.it/1qehue6
@r_cpp
Post #24693
33
fil-qt: A Qt Base build with Fil-C experience
https://git.qt.io/cradam/fil-qt
https://redd.it/1qedgkf
@r_cpp
GitLab Cristian Adam / fil-qt · GitLab GitLab Community Edition https://git.qt.io/cradam/fil-qt
https://redd.it/1qedgkf
@r_cpp
Post #24692
31
Placement new on stack object
Hello everyone, I recently learned about placement new, but so far I can only find examples of it's usage on heap memory.
I was wondering if it's valid for stack allocated objects to reuse their memory.
For example if i have
would this be valid? additionally what if I use it ok member variables of the class in the same way?
https://redd.it/1qdzg2q
@r_cpp
Hello everyone, I recently learned about placement new, but so far I can only find examples of it's usage on heap memory.
I was wondering if it's valid for stack allocated objects to reuse their memory.
For example if i have
auto fn(){
Type object{};
object.~Type();
new (&object) Type;
}
would this be valid? additionally what if I use it ok member variables of the class in the same way?
https://redd.it/1qdzg2q
@r_cpp
Post #24691
25
Post #24690
28
Support for C++26 Reflection has been merged into GCC trunk!
https://gcc.gnu.org/git/?p=gcc.git;a=commitdiff;h=4b0e94b394fa38cdc3431f3cfb333b85373bd948
https://redd.it/1qdn04o
@r_cpp
https://gcc.gnu.org/git/?p=gcc.git;a=commitdiff;h=4b0e94b394fa38cdc3431f3cfb333b85373bd948
https://redd.it/1qdn04o
@r_cpp
Post #24689
27
C++ Podcasts & Conference Talks (week 3, 2025)
Hi r/cpp! Welcome to another post in this series. Below, you'll find all the C++ conference talks and podcasts published in the last 7 days:
# 📺 Conference talks
# CppCon 2025
1. **"Best Practices for AI Tool Use in C++ - Jason Turner - CppCon 2025"** ⸱ +5k views ⸱ 13 Jan 2026 ⸱ 01h 02m 10s
2. **"Making C++ Safe, Healthy, and Efficient - John Lakos - CppCon 2025"** ⸱ +4k views ⸱ 08 Jan 2026 ⸱ 01h 10m 30s
3. **"Lazy and Fast: Ranges Meet Parallelism in C++ - Daniel Anderson - CppCon 2025"** ⸱ +4k views ⸱ 09 Jan 2026 ⸱ 01h 06m 39s
4. **"Back To Basics: C++ Strings and Character Sequences - Nicolai Josuttis - CppCon 2025"** ⸱ +3k views ⸱ 12 Jan 2026 ⸱ 01h 05m 18s
5. **"Agentic C++ Debugging Live! - Without a Safety Net - Daisy Hollman & Mark Williamson - CppCon 2025"** ⸱ +1k views ⸱ 14 Jan 2026 ⸱ 01h 06m 26s
# Meeting C++ 2025
1. **"C++23 tools you would actually use - Alex Dathskovsky - Meeting C++ 2025"** ⸱ +1k views ⸱ 10 Jan 2026 ⸱ 01h 00m 20s
2. **"Towards Safety and Security in C++26 - Daniela Engert - Meeting C++ 2025"** ⸱ +1k views ⸱ 08 Jan 2026 ⸱ 01h 02m 21s
3. **"Sanitize for your Sanity: Sanitizers tools for Modern C++ - Evgenii Seliverstov - Meeting C++ 2025"** ⸱ +600 views ⸱ 12 Jan 2026 ⸱ 01h 00m 00s
4. **"Monadic Operations in C++23 - Robert Schimkowitsch - Meeting C++ 2025"** ⸱ +300 views ⸱ 14 Jan 2026 ⸱ 00h 54m 35s
# NDC TechTown 2025
1. **"The Real Problem of C++ - Klaus Iglberger - NDC TechTown 2025"** ⸱ +1k views ⸱ 13 Jan 2026 ⸱ 00h 56m 59s
2. **"More Speed & Simplicity: Practical Data-Oriented Design in C++ - Vittorio Romeo - NDC TechTown 2025"** ⸱ +600 views ⸱ 13 Jan 2026 ⸱ 01h 07m 20s
3. **"How to declare a constant in C++ - Mikhail Matrosov - NDC TechTown 2025"** ⸱ +100 views ⸱ 13 Jan 2026 ⸱ 00h 51m 36s
4. **"Adventures in Serialization: A Flexible Approach for Embedded Systems in C++ - Jørn Bersvendsen"** ⸱ +100 views ⸱ 13 Jan 2026 ⸱ 00h 57m 19s
Sadly, there are no new podcasts this week.
This post is an excerpt from the latest issue of ***Tech Talks Weekly*** which is a free weekly email with all the recently published Software Engineering podcasts and conference talks. Currently subscribed by +7,900 Software Engineers who stopped scrolling through messy YT subscriptions/RSS feeds and reduced FOMO. Consider subscribing if this sounds useful: *https://www.techtalksweekly.io/*
Let me know what you think. Thank you!
https://redd.it/1qdhijf
@r_cpp
YouTube Best Practices for AI Tool Use in C++ - Jason Turner - CppCon 2025 https://cppcon.org
---
Best Practices for AI Tool Use - Jason Turner - CppCon 2025
---
AI (LLMs) are becoming prolific in C++ tooling. Virtually everything has an AI bot built in or available to it. Common wisdom says that these tools simply regurgitate… Hi r/cpp! Welcome to another post in this series. Below, you'll find all the C++ conference talks and podcasts published in the last 7 days:
# 📺 Conference talks
# CppCon 2025
1. **"Best Practices for AI Tool Use in C++ - Jason Turner - CppCon 2025"** ⸱ +5k views ⸱ 13 Jan 2026 ⸱ 01h 02m 10s
2. **"Making C++ Safe, Healthy, and Efficient - John Lakos - CppCon 2025"** ⸱ +4k views ⸱ 08 Jan 2026 ⸱ 01h 10m 30s
3. **"Lazy and Fast: Ranges Meet Parallelism in C++ - Daniel Anderson - CppCon 2025"** ⸱ +4k views ⸱ 09 Jan 2026 ⸱ 01h 06m 39s
4. **"Back To Basics: C++ Strings and Character Sequences - Nicolai Josuttis - CppCon 2025"** ⸱ +3k views ⸱ 12 Jan 2026 ⸱ 01h 05m 18s
5. **"Agentic C++ Debugging Live! - Without a Safety Net - Daisy Hollman & Mark Williamson - CppCon 2025"** ⸱ +1k views ⸱ 14 Jan 2026 ⸱ 01h 06m 26s
# Meeting C++ 2025
1. **"C++23 tools you would actually use - Alex Dathskovsky - Meeting C++ 2025"** ⸱ +1k views ⸱ 10 Jan 2026 ⸱ 01h 00m 20s
2. **"Towards Safety and Security in C++26 - Daniela Engert - Meeting C++ 2025"** ⸱ +1k views ⸱ 08 Jan 2026 ⸱ 01h 02m 21s
3. **"Sanitize for your Sanity: Sanitizers tools for Modern C++ - Evgenii Seliverstov - Meeting C++ 2025"** ⸱ +600 views ⸱ 12 Jan 2026 ⸱ 01h 00m 00s
4. **"Monadic Operations in C++23 - Robert Schimkowitsch - Meeting C++ 2025"** ⸱ +300 views ⸱ 14 Jan 2026 ⸱ 00h 54m 35s
# NDC TechTown 2025
1. **"The Real Problem of C++ - Klaus Iglberger - NDC TechTown 2025"** ⸱ +1k views ⸱ 13 Jan 2026 ⸱ 00h 56m 59s
2. **"More Speed & Simplicity: Practical Data-Oriented Design in C++ - Vittorio Romeo - NDC TechTown 2025"** ⸱ +600 views ⸱ 13 Jan 2026 ⸱ 01h 07m 20s
3. **"How to declare a constant in C++ - Mikhail Matrosov - NDC TechTown 2025"** ⸱ +100 views ⸱ 13 Jan 2026 ⸱ 00h 51m 36s
4. **"Adventures in Serialization: A Flexible Approach for Embedded Systems in C++ - Jørn Bersvendsen"** ⸱ +100 views ⸱ 13 Jan 2026 ⸱ 00h 57m 19s
Sadly, there are no new podcasts this week.
This post is an excerpt from the latest issue of ***Tech Talks Weekly*** which is a free weekly email with all the recently published Software Engineering podcasts and conference talks. Currently subscribed by +7,900 Software Engineers who stopped scrolling through messy YT subscriptions/RSS feeds and reduced FOMO. Consider subscribing if this sounds useful: *https://www.techtalksweekly.io/*
Let me know what you think. Thank you!
https://redd.it/1qdhijf
@r_cpp
Post #24688
27
Post #24687
29
Time in C++: Creating Your Own Clocks with <chrono>
https://www.sandordargo.com/blog/2026/01/14/clocks-part-7-custom-clocks
https://redd.it/1qdc5la
@r_cpp
Sandor Dargo’s Blog Time in C++: Creating Your Own Clocks with <chrono> In earlier articles of this series, we walked through the foundations of <chrono>, explored the essential clocks (system_clock, steady_clock, high_resolution_clock), and even looked at the extra clocks introduced in C++20 — not to mention why converting between… https://www.sandordargo.com/blog/2026/01/14/clocks-part-7-custom-clocks
https://redd.it/1qdc5la
@r_cpp
Post #24686
24
Hylo, a language that can be an inspiration for better C++ style.
I keep following with interest the development of Hylo.
I think this talk about structured concurrency:
https://www.youtube.com/watch?v=k6fI4asLJxo
And this one about Hylo itself are a good view for all C++ developers the same way Lisp is a good language to learn from it.
https://www.youtube.com/watch?v=5lecIqUhEl4
https://redd.it/1qdbw22
@r_cpp
YouTube Concurrency Hylomorphism - Lucian Radu Teodorescu - ACCU 2024 ACCU Membership: https://tinyurl.com/ydnfkcyn
---
Concurrency Hylomorphism - Lucian Radu Teodorescu - ACCU 2024
---
In the rapidly evolving landscape of software development, the demand for safe, efficient and easy concurrent programming solutions has never… I keep following with interest the development of Hylo.
I think this talk about structured concurrency:
https://www.youtube.com/watch?v=k6fI4asLJxo
And this one about Hylo itself are a good view for all C++ developers the same way Lisp is a good language to learn from it.
https://www.youtube.com/watch?v=5lecIqUhEl4
https://redd.it/1qdbw22
@r_cpp
Post #24685
26
im fed up with thie error
└─$ /usr/bin/env /bin/sh /tmp/Microsoft-MIEngine-Cmd-a24agjq2.a0q
/bin/sh: 0: cannot open /tmp/Microsoft-MIEngine-Cmd-a24agjq2.a0q: No such file
i did edit the tasks.json and launch .json but still its giving me this error every time does someone have a fix?
im using vs code on linux btw
https://redd.it/1qd92bd
@r_cpp
└─$ /usr/bin/env /bin/sh /tmp/Microsoft-MIEngine-Cmd-a24agjq2.a0q
/bin/sh: 0: cannot open /tmp/Microsoft-MIEngine-Cmd-a24agjq2.a0q: No such file
i did edit the tasks.json and launch .json but still its giving me this error every time does someone have a fix?
im using vs code on linux btw
https://redd.it/1qd92bd
@r_cpp
Post #24684
23
Post #24683
22
More Speed & Simplicity: Practical Data-Oriented Design in C++ - Vittorio Romeo - NDC TechTown 2025
https://www.youtube.com/watch?v=zDFSDBcIqhE
https://redd.it/1qcxedk
@r_cpp
YouTube More Speed & Simplicity: Practical Data-Oriented Design in C++ - Vittorio Romeo - NDC TechTown 2025 This talk was recorded at NDC TechTown in Kongsberg, Norway. #ndctechtown #ndcconferences #developer #softwaredeveloper
Attend the next NDC conference near you:
https://ndcconferences.com
https://ndctechtown.com/
Subscribe to our YouTube channel and… https://www.youtube.com/watch?v=zDFSDBcIqhE
https://redd.it/1qcxedk
@r_cpp
Post #24682
24
attend. Find out more including how to get a VISA at https://homeofficemedia.blog.gov.uk/electronic-travel-authorisation-eta-factsheet-january-2025/
https://redd.it/1qcv3n7
@r_cpp
homeofficemedia.blog.gov.uk Electronic Travel Authorisation (ETA) factsheet – November 2025 We are making improvements to deliver a more streamlined, digital immigration system which will be quicker and more secure for the millions of people who pass through the UK border each year. Visitors to the UK need an Electronic Travel … https://redd.it/1qcv3n7
@r_cpp