-
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
VRSFML: my Emscripten-ready fork of SFML
https://vittorioromeo.com/index/blog/vrsfml.html
https://redd.it/1evl9v1
@r_cpp
FreeTDS/MS SQL Login validation
I've managed to get my application to initialize DB params and prompt user for login details which connect successfully if correct.
I am however having trouble implementing either a Loop or a Try/Catch block to stop the application from exiting with the following as soon as the credentials are incorrect:
"FreeTDS db-lib: exiting because client error handler returned INT_EXIT for msgno 20002"
Is there a way to catch this specific error perhaps and syntactically/logically what's the best way to approach it?
Many thanks
https://redd.it/1evg4h0
@r_cpp
Is there any new update on metaclasses?
I ask this before but C++26 has made some progress on reflection so it there some new on metaclasses?
https://redd.it/1ev7eex
@r_cpp
CSS parsing in C++ with an in-depth look
>CSS parsing in C++ with an in-depth look
https://redd.it/1ev4015
@r_cpp
Question about compile time error when creating a template using type_traits for checking if a tuple contains a type
I'm following a tutorial about template metaprogramming and I am facing a compile time error when I define a template as follows:
template <typename SEARCH, typename TUPLE, size_t start_from = 0>
struct contains_type
: if_<(start_from >= std::tuple_size<TUPLE>::value), std::false_type,
typename if_<
std::is_same<SEARCH,
std::tuple_element_t<start_from, TUPLE>>::value,
std::true_type,
contains_type<SEARCH, TUPLE, start_from + 1>>::type>::type {};
Here `if_` is similar to `std::conditional_t`. I am using this template in my `main` function as follows:
std::tuple<int, bool, float, std::string> t =
std::make_tuple(42, true, 8.1, "hello");
std::cout << std::boolalpha << contains_type<double, decltype(t)>::value
<< std::endl;
std::cout << std::boolalpha << contains_type<std::string, decltype(t)>::value
<< std::endl;
The error I get is:
error: static assertion failed due to requirement '4UL < sizeof...(_Types)': tuple_element index out of range
This is on the line where I am doing:
std::is_same<SEARCH,
std::tuple_element_t<start_from, TUPLE>>::value,
Even though I have the base case defined in my first `if_` (`start_from >= std::tuple_size<TUPLE>::value`), why do I have this error?
https://redd.it/1euwl8o
@r_cpp
see three writes of 3 chars. So std::fsteam does internal buffering? Maybe that's the way it derives from std::basic_filebuf?
Okay, next program:
Iteration count 9 * 1024:
sizet count {
9 * 1024
};
std::string payload("aaa");
while (count-- != 0) {
fs << payload;
}
Strace:
>openat(AT\FDCWD, "test_stream_3.txt", O_RDWR|O_CREAT|O_APPEND, 0666) = 3
>lseek(3, 0, SEEK_END) = 49980
>writev(3, [{iov_base="aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"..., iov_len=8190}, {iov_base="aaa", iov_len=3}\], 2) = 8193
>writev(3, [{iov_base="aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"..., iov_len=8190}, {iov_base="aaa", iov_len=3}\], 2) = 8193
>writev(3, [{iov_base="aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"..., iov_len=8190}, {iov_base="aaa", iov_len=3}\], 2) = 8193
>write(3, "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"..., 3069) = 3069
>close(3) = 0
So what we see is that std::fstream is smart enough to auto-vectorize IO! This is really surprising to me. After seeing this trace I decided to dig into the libstdc++ and find out the logic behind vectorization, and I found... nothing. Grep showed zero calls to writev(). A simple search in fstream and related headers did not reference writev(). So the natural question is: where does vectorization happen?
The next experiment I conducted was to try to see if maybe the kernel somehow decides that it can vectorize things?
So I drafted the same logic using plain write() calls.
std::string payload("bbbbb");
sizet count {
9 * 1024
};
while (count-- != 0) {
write(fd, payload.cstr(), payload.size());
}
strace:
>......
>write(3, "bbbbb", 5) = 5
>write(3, "bbbbb", 5) = 5
>write(3, "bbbbb", 5) = 5
>write(3, "bbbbb", 5) = 5
>write(3, "bbbbb", 5) = 5
>write(3, "bbbbb", 5) = 5
>write(3, "bbbbb", 5) = 5
>write(3, "bbbbb", 5) = 5
>write(3, "bbbbb", 5) = 5
>exit_group(0) = ?
Strace just shows a ton of calls to write: exactly what I expected when std::fstream::write()-ing into the stream.
And the last experiment was to benchmark explicitly vectorized IO against fstream.
std::vector < iovec > iov;
std::string payload("bbbbb");
for (
auto : state) {
iov.emplaceback(iovec {
.iovbase = payload.data(), .iovlen = payload.size()
});
}
writev(fd, iov.data(), iov.size());
And the benchmark showed interesting result:
>
>Benchmark Time CPU Iterations
>
>BM_BenchmarkFstreamWrite 24.0 ns 24.0 ns 28733493
>BM_BenchmarkPosixWrite 1828 ns 1828 ns 384717
>BM_BenchmarkPosixScatterWrite 37.9 ns 37.9 ns 16676420
DIY writev() is almost two times slower than std::fstream::write!
What are your interpretations of these results? How to understand where the vectorization happens? Maybe I should abandon my idea of having custom file abstractions and use std::fstream.
I am using 6.10.3-1-default with gcc 13.3.1 with optimization levels set to -O2.
Thank you for reading!
https://redd.it/1euqu08
@r_cpp
MMeter: a simple C++ profiler library
I made a simple profiler in an hour library wayyy back when I couldn't use industry-standard tools, and expanded on it later. Review and constructive criticism is welcome!
Link: https://github.com/LMauricius/MMeter
I tried to explain more details in the README, but I'll paste what I suppose you guys would be most curious about:
Features:
Function measurement
Scope measurement
Thread-safety
Structured output
Why not use valgrind?
Originally, I made this tool while waiting for a system update on a rolling-release OS, because I couldn't install valgrind until everything else was up-to-date.
The tool ended up as a standalone thing with a few specific pros compared to mature industry-standard profilers.
It is simple and minimal
You can simply choose the areas of interest for profiling
Completely portable. It relies only on standard C++17
It is MUCH faster. since it profiles only select areas of interest, it shouldn't interfere with non-profiled code performance, aside from possible cache misses. Chore timing is taken into account, of course.
https://redd.it/1euqh4p
@r_cpp
Re-Writing Snake Game with Design By Contract after 2 years
2 years back I had written a snake game with functional programming in mind. Repo link: [https://github.com/RishabhRD/snake](https://github.com/RishabhRD/snake) .
The main motive **WAS** to explore simplicity, value semantics and 'Action, Model, View' architecture.
However, few days back I revised my codebase and found that I couldn't achieve local reasoning in my codebase. And its surely not simple. I wanted to achieve value semantics but I didn't know what even a value is? For me std::string\_view was a good example of value semantics.
But in these 2 years I got to learn about **Design By Contract**. Thanks to Sean Parent and Dave Abrahams recent talks. Also I got a chance to read **Elements of Programming** (thanks to legend Alex Stepanov) and realize what exactly values and objects are.
So, I rewrote the whole thing from scratch. Few things I tried to apply while rewriting the game:
* Think of preconditions and post-conditions while writing a function.
* Only argument types doesn't define the domain of the function, but precondition + types do
* Violating precondition is not an error but a bug. So stop handling precondition violation.
* Try to provide APIs where its hard to violate preconditions. Use your type-system.
* Inability to satisfy post-condition is an error.
* While testing a function, post-conditions should be tested and maybe we can move towards proofs someday.
* With composition of functions, there is logical composition of preconditions and post-conditions that would define correctness of program.
* Stronger precondition and weaker post-condition leads to less responsibility of function. So we should crave for that. However, should not trade efficiency for the same.
* Classes should try to have one responsibility and that is to maintain the class invariants.
* If post-conditions and class invariants are getting complex think of if its the right design.
* Generic programming really helps to achieve the same. Generic programming approach try to depend on minimal requirements that is enough to achieve the post-conditions.
* For writing generic functions, its important to understand the relationships. Sean Parent's talk on Better Code: Relationships would help. [https://youtu.be/ejF6qqohp3M](https://youtu.be/ejF6qqohp3M)
* Try to provide generic and efficient basis for the class that free functions can use to achieve use-case related tasks. (Its really hard, most of the time goes into realizing what exactly is this thing...)
* Algorithms are important learn them.
Now the code looks like this:
template <Coordinate CoordType>
class snake {
// Class Invariants:
// - body_coords.size() >= 1
// - Every adjacent element (t, h) is st: t comes after h in snake body
// - for every adjacent element (x, y) of body_coords:
// x == y || is_adjacent(x, y)
And modern C++ standard library helps in many cases like std::variant for handling closed type hierarchy. Language features like concepts is a really good step towards generic programming. C++(26 or 29 hopefully) contracts would be a rather good step towards more formal code and enforcing design by contract.
Best part of C++ is the C++ community. We have a lot of great minds like Sean Parent, Dave Abrahams and many more. Now C++ is not just about syntax but about programming ideas in general. And we have many initiatives towards many different goals.
If we would be more formal about our code rather than be more defensive it would be lot less buggy.
At last this game is surely not a perfect program. But rather a simple program to test programming techniques and designs that we can apply to real programs later on.
Everyone's review is highly appreciated and pointing the mistakes (that I must have made) would be even so much helpful for me. I am open for discussion on every aspect.
Thank you everyone for your time.
https://redd.it/1eufmrb
@r_cpp
Cpp2 is looking absolutely great. Will convert some code to Cpp2
Hello everyone,
Last night I was skimming through Cpp2 docs. I must say that the language is absolutely regular, well-thought.
Things I like:
- Parameter passing.
- Regular from verbose to a lambda function syntax, all regular.
- The is keyword works safely for everything and, even if at first I was a bit wary of hiding too much, I thnk that it convinced me that it is a good and general way to hide safe operations.
- The capturing$ and interpolating$ unified syntax by value or by reference$& (not sure if that is the order or $& or it is &$, just forgot, from the top of my head) without verbosity.
- Definite last use of variables makes an automatic move when able to do it, removing the need to use moves all the time.
- Aliases are just ==.
- Templates are zero-verbosity and equally powerful.
- Pattern matching via inspect.
Things that did not look really clear to me were (they make sense, but thinking in terms of C++...):
- Things such as BufferSize : i32 == 38925 which is an alias, that translates to constexpr. Is there an equivalent of constexpr beyond this in the language?
I still have to read the contracts, types and inheritance, metafunction and reflection, but it looks so great that I am going to give it a try and convert my repository for some benchmarks I have to the best of my knowledge.
The conversion will be just a 1-to-1 as much as possible to see how the result looks at first, limiting things to std C++ (not sure how to consume dependencies yet).
My repo is here: https://github.com/germandiagogomez/words-counter-benchmarks-game , in case someone wants to see it. I plan to do it during the next two-to-four weekends if the available time gives me a chance, not sure when exactly, I am a bit scarce about time, but I will definitely try and experiment and feedback on it.
https://redd.it/1euacbu
@r_cpp
portable C++ dev environment for linux
So I saw another thread about this and OP mentioned a portable IDE usable on a usb stick. This got me wondering if a fully portable dev environment with compiler, debugger, perhaps third parties, and code editor (VS Code ideally) is possible for linux. Assuming my host machines will run Linux. I know Windows has an option https://github.com/skeeto/w64devkit but it's strictly for the terminal.
https://redd.it/1eu59k2
@r_cpp
Which IDE for C/C++ ?
Hello everyone, i noticed VS code was not always practical. Do you guys know a good IDE for C/C++ ? If possible which exists on a portable version for usb key.
https://redd.it/1etza8w
@r_cpp
On what Context would you not Buy Visual Assist?
pls give explanation also.
https://redd.it/1etro08
@r_cpp
Which to choose for system programming and why ?
I want to learn a system programming language (not for the job) and I won't write low level stuffs like kernels and so , I just want to go unlimited , let me give more context , I'm coming from a huge python background and ML beside software like Flutter and android , Picking a system language can help me write native things like for inference(prediction for ml model), performance gains and much , my problem is , I'm torn between choosing C/C++ , Rust and Zig ,
I learned Rust for a few but everyone and I see lots of videos tells me that it's very difficult so I got frustrated and stopped then,
I learned Zig and I liked it but lots of things are missing cause It's new
I didn't learn C but most ppl recommend it to me , I just love to ask because when I learn a language and dive into it then I found problems and start learn a new one makes me feel that I wasted time and achieved 0 progress , so help choose with reasons , thank you so much
https://redd.it/1eto3kg
@r_cpp
Run button gives an error in VSCode
Hello. I am new to C++, VSCode and Linux. I am trying to learn coding and am using VSCode as a text editor. I wrote some really simple code, but when I try to run it using coderunner's run button, it gives an error.
Error is this:
--------------------------------------------------------------------------------------------------------------------------------------------------
* Executing task: C/C++: g++ build active file
Starting build...
/usr/bin/g++ -fdiagnostics-color=always -g /home/anar/Dev/C++/HelloWorld/src/Main.cpp -o /home/anar/Dev/C++/HelloWorld/src/Main
/usr/bin/ld: /tmp/ccWSZxFR.o: in function `main':
/home/anar/Dev/C++/HelloWorld/src/Main.cpp:7:(.text+0xa): undefined reference to `Log(char const*)'
collect2: error: ld returned 1 exit status
Build finished with error(s).
* The terminal process failed to launch (exit code: -1).
* Terminal will be reused by tasks, press any key to close it.
--------------------------------------------------------------------------------------------------------------------------------------------------
My code is this (file name Main.cpp):
#include <iostream>
void Log(const char message);
int main()
{
Log("Hello World!");
std::cin.get();
}
I also have Log.cpp:
#include <iostream>
void Log(const char message)
{
std::cout << message << std::endl;
}
There are in the same folder. What could be the problem?
https://redd.it/1eti691
@r_cpp
10 years of Dear ImGui (long post)
https://github.com/ocornut/imgui/issues/7892
https://redd.it/1etg7on
@r_cpp
I hate using chars and floats in imgui.
The author should have wrote the library in C, not C++. Because it uses loads of raw pointers, doesn't uses std::string, uses floats instead of doubles and doesn't support cmake.
I have to convert the output of other libraries into string then to char again and vice versa and it sucks.
I think the idea behind the library is amazing. It is easy to refactor, modularize and to write...
If you write it as C program.
Here is my rant, remember me it when you try to execute SQL queries in imgui.
https://redd.it/1evit4e
@r_cpp
Fresh graduate looking for a job
I just graduated from a bachelors in Electrical Engineering and I applied for a few C++ jobs and I got rejected till now. I just changed my CV and I took a CI CD pipeline online course and added that in my CV, I do not have any professional experience, did my (project) internship at school, which does not count as professional experience. what can I write in my CV or motivational letter that will make me standout? Thank you!
https://redd.it/1evbojx
@r_cpp
C++ libraries and frameworks equivalent to Python
Hi I'm moving from python to C++ for production. I'm wondering what's equivalent common frameworks in C++ comparing to python. Specifically I'm looking for the following:
1. Pytest/unittest (python unit test framework)
2. Numpy/Scipy (scientific computing library)
3. scikit learn (ML library)
4. logging
there are more I have to think about. But any crucial development library/framework helps
https://redd.it/1ev5hp9
@r_cpp
std::deque.pushfront(10) vs std::vector.insert(vec.begin(), 10): What's the difference?
I was browsing the DevDocs.io documentation the other day and noticed that std::deque had two functions to push elements both at the back and the front of the list. The two functions were named pushback and pushfront. However std::vector also has a function that lets you insert elements at the front at back: std::vector.insert(vec.begin(), ...) and std::vector.pushback(). It just made me wonder: what is the difference between the two? I haven't actually used std::deque before so there are probably some stuff about it that I don't know.
https://redd.it/1ev488u
@r_cpp
noexcept affects libstdc++’s unordered_set
https://quuxplusone.github.io/blog/2024/08/16/libstdcxx-noexcept-hash/
https://redd.it/1euvoqo
@r_cpp
Question on fstream and input/output vectorization(readv()/writev()) on Linux
Hi there!
I am working on a database, particularly building the storage engine(https://github.com/lnikon/tinykvpp) right now, and I assigned myself the task of creating separate file abstractions(e.g. I really like how it is done in leveldb, thus having RandomAccessFile, SequentialFile, AppendOnlyFile, etc...).
So, while designing my approach to this, I started evaluating my current way of doing file IO - fstreams versus plain POSIX write(), and simple Google benchmark:
static void
BMBenchmarkFstreamWrite(benchmark::State & state) {
const std::string filename("teststream.txt");
std::fstream fs(filename, std::fstream::in |
std::fstream::out |
std::fstream::app |
std::fstream::ate);
if (!fs.isopen()) {
std::cerr << "unable to open" << filename << '\n';
exit(EXITFAILURE);
}
std::string payload("aaaaa");
for (auto : state) {
benchmark::DoNotOptimize(fs.write(payload.cstr(), payload.size()));
}
std::filesystem::remove(filename);
}
BENCHMARK(BMBenchmarkFstreamWrite);
static void
BMBenchmarkPosixWrite(benchmark::State & state) {
const
std::string filename("teststream2.txt");
int
fd = open(filename.cstr(), OWRONLY | OAPPEND | OCREAT, 0644);
if (fd == -1) {
std::cerr << "Unable to open " << filename << '\n';
}
std::string payload("bbbbb");
for (
auto : state) {
write(fd, payload.cstr(), payload.size());
}
std::filesystem::remove(filename);
}
BENCHMARK(BMBenchmarkPosixWrite);
static void BMBenchmarkFstreamWrite(benchmark::State & state) {
const std::string filename("teststream.txt");
std::fstream fs(filename, std::fstream::in | std::fstream::out | std::fstream::app | std::fstream::ate);
if (!fs.isopen()) {
std::cerr << "unable to open" << filename << '\n';
exit(EXITFAILURE);
}
std::string payload("aaaaa");
for (auto : state) {
benchmark::DoNotOptimize(fs.write(payload.cstr(), payload.size()));
}
std::filesystem::remove(filename);
}
BENCHMARK(BMBenchmarkFstreamWrite);
static void BMBenchmarkPosixWrite(benchmark::State & state) {
const std::string filename("teststream2.txt");
int fd = open(filename.cstr(), OWRONLY | OAPPEND | OCREAT, 0644);
if (fd == -1) {
std::cerr << "Unable to open " << filename << '\n';
}
std::string payload("bbbbb");
for (auto : state) {
write(fd, payload.cstr(), payload.size());
}
std::filesystem::remove(filename);
}
BENCHMARK(BMBenchmarkPosixWrite);
shows following result:
>
>Benchmark Time CPU Iterations
>
>BM_BenchmarkFstreamWrite 24.0 ns 24.0 ns 30455681
>BM_BenchmarkPosixWrite 2001 ns 2001 ns 356052
So, simple POSIX write() is slower almost 100 times. This result really shocked me. I decided to `strace` the program and saw that for sufficiently big inputs std::fstream::write's got vectorized! What do I mean by 'sufficiently big input'? Well, the payload length is only e.g. 3 chars, then fstream does a
Let's examine the following small programs and their straces. To simulate the load I wrapped the write() into a while loop. The payload size is the same for all test cases, only the iteration count changes.
Iteration count: 3
sizet count {
3
};
std::string payload("aaa");
while (count-- != 0) {
fs << payload;
}
Strace:
>openat(AT\FDCWD, "test_stream_3.txt", O_RDWR|O_CREAT|O_APPEND, 0666) = 3
lseek(3, 0, SEEK_END) = 40755
write(3, "aaaaaaaaa", 9) = 9
close(3) = 0
What we see is a simple write of 9 characters. But what would I've expected is to
E-Regex v0.1.0 released! (MIT License)
I've just released a regex library that offers full matching capabilities, even at compile time!
Regexes are optimized using an heuristic engine and it is possible to inspect some aspects of the generated tree.
constexpr eregex::match<R"((\d+)-(\d+)-(\d+))"> matcher;
auto [match, year, month, day] = matcher("1970-01-01");
A tokenizer, built on regexes, is provided too:
enum class type
{
WORD,
NUMBER
};
constexpr auto tokenizer
= eregex::tokenization::tokenizer<token {type::WORD, "a-z+"},
token {type::NUMBER, "\\d+"},
separator {"\\s"}> {};
auto res = tokenizer("a 123 def");
for (auto token: res)
{
...
}
I would appreciate any feedback and suggestions!
https://github.com/cmargiotta/e-regex
https://redd.it/1euh66i
@r_cpp
C++ coding protection!
Hey there! I was wondering if there was any way to protect my code from nosy weirdos (decompilers), I read about packers but I am not too sure what it is or how it works all I know is that I want to protect my code.
Obviously I could implement a legal license but people are going to give a rats-ass about my license.
If you know of any obfuscators or anything that could help please link it :D
#AntiCodeTheft #StopStealingCode #swag
https://redd.it/1eucvii
@r_cpp
Quant Finance Cpp Core Dev
Plain and simple:
- I’m an extremely busy python dev
- I want to move into more low-level development in finance (eventually)
- my cpp is rusty - so is my general OS knowledge
If you had to recommend one, maybe two (max) resources that I can drill to get to a competent level to get to a cpp role, what would it/they be?
Thanks!
https://redd.it/1eu5x3z
@r_cpp
C++ programming course
Hey everyone this is a computer engineer who will start a programming C++ programming course at 28/8/2024 For only
20 USD The course will be a great start to learn programming and one of the highly demanded programming languages and if you don't know anything about
programming it's totally fine we will teach you everything
The course will be held at zoom online meetings cuz it's easily accessed by everyone and we will learn basic
programming concepts till OOP Programing with lotsss of hands on projects The course duration is 1 month, 2 sessions per week each session is 2hrs supported by a telegram group to answer all your questions
24/7
Notes :
1. You can pay 10 USD to reserve a place in our course and the other 10 USD after the course completion
2. The zoom meetings will contain maximum group of 6 members for maximum benefit
3. There is one to one sessions also with
USD
Kindly if you are interested do not hesitate to dm me
https://redd.it/1eu3diy
@r_cpp
Vector to variadic arguments C function
Hey guys,
I came across something and i'm not sure it can be solved, i would appreciate your thoughts and suggestions. Thanks in advance!
In order to keep things simple, I created this version of the problem. To put it briefly, I have a C++ function that takes in a vector, processes it, and then passes the results to a third-party C function that takes variadic arguments. However, it won't compile and throws some error that I added as comment in the code below:
#include <iostream>
#include <vector>
#include <cstdarg>
using namespace std;
// C function from a third-party company that cannot be changed.
extern "C" void cfunction(int numargs, ...) {
valist args;
vastart(args, numargs);
for (int i = 0; i < numargs; ++i) {
int arg = vaarg(args, int);
// Do something
}
vaend(args);
}
// Wrapper to convert vector to variadic arguments
void callCFunctionWithVector(const vector<int>& vec) {
// Do some processing with the vector data
valist args;
vastart(args, vec.size()); // Compiler message:::: error: 'vastart' used in function with fixed args
for (sizet i = 0; i < vec.size(); ++i) {
vaarg(args, vec[i]); // Compiler message:::: error: unknown type name 'vec'
}
cfunction(vec.size(), args);
vaend(args);
}
int main() {
vector<int> myvector = {1, 2, 3, 4, 5, 6, 7};
// Call the C++ function that wraps the C function
callCFunctionWithVector(myvector);
return 0;
}
**Compiler:** Apple clang version 15.0.0 (clang-1500.1.0.2.5)
**Target:** x86\64-apple-darwin23.5.0
CPP Version: 20
https://redd.it/1etui29
@r_cpp
Is CLion Worth it for Hobby Developers
title
https://redd.it/1etq38u
@r_cpp
Is this override valid c++?
Hello,
yesterday I stumbled accross this kind of an override method in a project:
>struct A {
virtual A& fnc() = 0; }; struct B: public A {
B& fnc() override { return *this; } };
Is 'changing' the return type on overriding the method even allowed in the standard?
If so, why?
gcc, clang and msvc do compile this code.
https://redd.it/1etka7w
@r_cpp
What’s so hard about class types as non-type template parameters?
https://brevzin.github.io/c++/2024/08/15/cnttp/
https://redd.it/1ethbdq
@r_cpp
Has std::format caught up to fmt.dev in C++20?
Since `std::runtime_format` won't be available until C++26, we're currently limited to using `std::vformat`, like this:
std::vformat(fmt_str, std::make_format_args(string));
So, my main question is: What do you prefer to use for string formatting—`fmt` or `std::format`? Why?
https://redd.it/1etc126
@r_cpp