-
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
Statistics on increasing complexity of the C++ compiler
I always pay attention to assessing the complexity of programming in a particular language. Programming is indeed not an easy task and this is perceived as a fact and usually does not require any confirmation.
But the concept of “complexity” is akin to the term “heap”. For some, five coconuts is not so much, but for someone who ate one and “didn’t want any more,” this means that even one coconut will be too much for him.
The same goes for the complexity of programs. It seems that the constant increase in the complexity of programs is obvious to everyone and is observed in all areas of application of IT technologies, and programming languages themselves become more and more complex as they develop, but assessing “complexity” using numerical metrics is a problem. obviously a thankless task, but also “You can’t manage what you can’t measure...”
Typically, talk of “complexity” only implies value judgments without any numerical evaluation. And since I am personally interested in the issue of the complexity of programming languages, I decided to calculate the complexity of implementing the gcc compiler on some conditional “parrots”. What if we could see some patterns of difficulty changing over time?
Choosing "parrots" to measure
I didn’t come up with my own and calculate empirical program code metrics and, as a “parrot,” I decided to take the simplest metric SLOC (Source Lines of Code) - the number of lines of source code compiler, which is very easy to calculate.
But it will be possible to evaluate the complexity of a language with its help only under the following assumption: the complexity of the language should be directly dependent on the complexity of its implementation, if simple syntactic structures require less code than more complex ones.
Of course, using the “number of lines of source code” metric has its drawbacks, since it strongly depends on the programming language used, the style of source code and, in general, does not allow correct comparison of several different projects.
But for numerically assessing the complexity of code within one project, the SLOC metric is well suited.
# Methodology for calculating SLOC
Initially I tried to use a simple bash script with mask search and counting the number of lines in source files via wc -l. But after a while it became clear that I had to invent another bicycle.
So I decided to take a ready-made utility SLOCCount, which can analyze almost three dozen types of sources.
Moreover, it counts not just the number of lines of source code, but can ignore comments, exclude duplicate files from the calculation (compares their hash sums), and also displays the estimated labor intensity, an approximate estimate of the cost of developing the analyzed project file and other characteristics.
I was initially interested in the volume of source codes in C/C++ and, possibly, in assembler, if there were a lot of such files. But after I started working, I was very glad that I did not reinvent the wheel, but took a ready-made toolkit, because it separately calculates the statistics of the Yacc/Bison parser source files (.y), which determines the actual complexity of the parser (read the complexity of the programming language syntax).
I took the old gcc sources from https://gcc.gnu.org/mirrors.html, but before running the analyzer I deleted the directories of other compilers (ada, fortran, java, etc.) so that they would not be included in the final statistics.
Results in "parrots"
Yearly сhart of GCC complexity
Yearly chart Yacc/Bison parser code size
Yearly chart size of entire GCC source code (C and C++ languages only)
Unfortunately, the Yacc/Bison parser was
rusty.hpp: A Borrow Checker and Memory Ownership System for C++20 (+Option, Result, Non-Nullable Values) (heavily inspired from Rust)
https://github.com/Jaysmito101/rusty.hpp
https://redd.it/1cjvt35
@r_cpp
Visualizing C++ data structures during debugging
https://github.com/sunxfancy/DSViz/blob/master/doc/how-to-dbg-data-structure.md
https://redd.it/1cjsijj
@r_cpp
A simple shell made in c++
I was bored so why not
https://github.com/natesworks/shelly
https://redd.it/1cjc5pi
@r_cpp
CppCast: JSON for Modern C++
https://cppcast.com/json_for_modern_cpp/
https://redd.it/1cj557p
@r_cpp
Runtime polymorphism vs. compile time polymorphism in games?
I am curious about the use cases of each, specifically in games development.
I have recently learned how to use templates so my knowledge isn't great, but I was wondering if the performance benefits of compile time polymorphism means that game developers will opt to use it if they can instead of runtime polymorphism.
Here are some other questions I had:
1. Is there a conflict of readability there at all?
2. Is runtime polymorphism generally fine enough to keep?
3. What are some common cases where you would use compile time polymorphism?
4. I hear complex class hierarchies are avoided in triple A. Does this influence the use of templates at all?
https://redd.it/1cj3gim
@r_cpp
jsoncons version 0.175.0 supports JSON Schema Drafts 4, 6, 7, 2019-9 and 2020-12
https://github.com/danielaparker/jsoncons/blob/master/doc/ref/jsonschema/jsonschema.md
https://redd.it/1cixecq
@r_cpp
std::signal and portability
On POSIX systems sem\_post is signal safe. So in the past when I wanted to catch ctrl-c I would do something like this, in this order:
* Create a semaphore (sem\_create with an initial value of 0)
* Launch a second thread that would sem\_wait. Once the semaphore was released from the signal handler, control the shutdown process of the application.
* Register a signal handler using std::signal to catch SIGINT, that signal handler does nothing except call sem\_post when SIGINT is detected, which is a signal safe function [As defined here](https://man7.org/linux/man-pages/man7/signal-safety.7.html). I prefer to keep the signal handler as simple as possible, I don't want other teammates to add code to the signal handler that might not be signal safe. I did put a warning in the signal handler, it's surely to be ignored.
Implementing the above works on Linux, if signals are enabled. Besides "don't use signals", it'd be nice to have a more portable approach to shutting down when ctrl-c is received.
Unfortunately, I don't think I can get away with using std::semaphore because there's no guarantee that std::semaphore::release() will be signal safe (guessing the reason for that is because it would constrain implementation too much).
One alternative, which I really don't like, is to set a flag in the signal handler and in the second thread, instead of a sem\_wait, use while (flag\_not\_set) std::this\_thread::sleep\_for(std::chrono::seconds(1));
For those that catch ctrl-c, what is your general approach?
I'm hoping for more portable alternatives.
https://redd.it/1ciq5ic
@r_cpp
C++ Show and Tell - May 2024
Use this thread to share anything you've written in C++. This includes:
* a tool you've written
* a game you've been working on
* your first non-trivial C++ program
The rules of this thread are very straight forward:
* The project must involve C++ in some way.
* It must be something you (alone or with others) have done.
* Please share a link, if applicable.
* Please post images, if applicable.
If you're working on a C++ library, you can also share new releases or major updates in a dedicated post as before. The line we're drawing is between "written in C++" and "useful for C++ programmers specifically". If you're writing a C++ library or tool for C++ developers, that's something C++ programmers can use and is on-topic for a main submission. It's different if you're just using C++ to implement a generic program that isn't specifically about C++: you're free to share it here, but it wouldn't quite fit as a standalone post.
Last month's thread: https://www.reddit.com/r/cpp/comments/1bsxuxt/c_show_and_tell_april_2024/
https://redd.it/1cilqq4
@r_cpp
making a faster std::function, a different way to type erase
link : [https://godbolt.org/z/9TT4846xo](https://godbolt.org/z/9TT4846xo)
Experimented with a function wrapper with no inheritance and virtual methods. This is not a complete function wrapper implementation but it can serve as a reference. This implementation does not need to allocate if constructed with a function pointer but for lambdas, an allocation happens and function pointers are used to store type information. This seems to perform better than std::function especially with non-optimized builds, optimized builds speed up on the other hand varies from compiler to compiler. Clang18.1 and GCC13.2 for example can optimize out the loop in the naive/stupid test functions(in the godbolt link) while MSVC can't.
Also, I'm not sure if there are any UBs going on here.
template<typename T>
struct sfunc;
template<typename R, typename ...Args>
struct sfunc<R(Args...)>
{
// we already know the return type and the arguments
// just make function pointers from it
// A normal type erasure would do virtual methods and inheritance
// but I decided to not do that for this expreriment
R (*lambda_caller)(void*, Args...) {nullptr};
R (*function_pointer)(Args...) {nullptr};
void* (*lambda_copier)(void*) {nullptr};
void (*lambda_deleter)(void*) {nullptr};
void* lambda {nullptr};
template<typename F>
sfunc(F f)
{
*this = f;
}
sfunc() {}
sfunc(const sfunc& f)
{
*this = f;
}
sfunc(sfunc&& f)
{
*this = f;
f = {0};
}
sfunc& operator = (const sfunc& f)
{
if(lambda_deleter)
{
lambda_deleter(lambda);
lambda = nullptr;
}
lambda_caller = f.lambda_caller;
function_pointer = f.function_pointer;
lambda_deleter = f.lambda_deleter;
lambda_copier = f.lambda_copier;
if(lambda_copier){
lambda = lambda_copier(f.lambda);
}
return *this;
}
template<typename ...>
struct is_function_pointer;
template<typename T>
struct is_function_pointer<T>
{
static constexpr bool value {false};
};
template<typename T, typename ...Ts>
struct is_function_pointer<T(*)(Ts...)>
{
static constexpr bool value {true};
};
template<typename F>
auto operator = (F f)
{
if constexpr(is_function_pointer<F>::value == true)
{
function_pointer = f;
if(lambda_deleter)
{
lambda_deleter(lambda);
lambda_deleter = nullptr;
lambda = nullptr;
}
}
else
{
function_pointer = nullptr;
if(lambda_deleter){
lambda_deleter(lambda);
}
lambda = {new F{f}};
// store type info through function pointers from lambdas
lambda_caller = [](void* l, Args... args)
{
auto& f {*(F*)l};
return f(std::forward<Args>(args)...);
};
lambda_copier = [](void* d)
{
auto r {new F{*((F*)d)}};
return (void*)r;
};
lambda_deleter = [](void* d){
delete (F*)d;
};
}
}
R operator()(Args... args)
{
// I tried solutions where I dont do the branch here but it resulted in slower code
if(lambda){
return lambda_caller(lambda,
Johan Berg : Using C callbacks in C++
https://youtu.be/-K3jPBhzMRQ
https://redd.it/1ciauxw
@r_cpp
Question about mass-refactor tools
Hi
I have some code bases with lots of sub-optimal programming practices, due from being legacy code, and from time-pressure causes. A lot of those issues can be easly solved by using refactoring tools, for example:
* Changing symbol style (for example mixed snake case with pascal case)
* Moving non-trivial method implementation from header to source files.
* Formatting issues, among others.
Is there any tool that can be used for performing these refactors across the entire code base?
https://redd.it/1chz3hc
@r_cpp
C++ fstream
Does anyone know how to solve the problem of entering Cyrillic characters in a file input stream?
When I try to enter Russian characters into a file, I get scribbles.
https://redd.it/1chtfok
@r_cpp
What's the point with the MISRA guidelines for C++?
https://www.perforce.com/resources/qac/misra-c-cpp
MISRA is a set of guidelines for C++ for embedded systems, there are strange rules like (from the link):
>
>Rule 14.9
>An if (expression) construct shall be followed by a compound statement. The else keyword shall be followed by either a compound statement, or another if statement.
>
>Rule 14.10
>All if … else if constructs shall be terminated with an else clause.Rule 14.9
>
>Rule 59
The statement forming the body of an "if", "else if", "else", "while", "do ... while", or "for" statement shall always be enclosed in braces
what's the point with these? why would not following these rules cause problems?
https://redd.it/1chu4j3
@r_cpp
Anyone using wxWidgets for commercial cross platform desktop app?
I searched the sub and while there are not many questions related to wxWidgets, they are mostly for hobby/college projects. I was wondering if anyone here has used wxWidgets for developing commericial desktop apps. I would ask in the wxWidgets sub, but there's only like 250 members. Please share if you do and how's your experience with it especially stuffs like code signing in Mac/Windows, etc. Thanks!
https://redd.it/1chqqx0
@r_cpp
What is the Fastest code editor or ide for c++ ?
I want free code editor that compile and debug code within millisecond.. i have good computer btw.
https://redd.it/1cjzysg
@r_cpp
I made a C++ lightweight unit testing / fuzzing / logging / assertion framework
https://github.com/sunxfancy/zeroerr/blob/master/Readme.en.md
https://redd.it/1cjt45y
@r_cpp
Messing with lifetime
https://biowpn.github.io/bioweapon/2024/05/03/messing-with-lifetime.html
https://redd.it/1cjqjmr
@r_cpp
Compilation of gripping C++ conference talks from 2023
https://pvs-studio.com/en/blog/posts/1120/
https://redd.it/1cjasf8
@r_cpp
File modes in C++20
https://euroquis.nl//blabla/2024/04/30/chmod.html
https://redd.it/1cj3rg7
@r_cpp
Awaiting a set of handles with a timeout, part 3: Going beyond two - The Old New Thing
https://devblogs.microsoft.com/oldnewthing/20240502-00/?p=109721
https://redd.it/1cj23ib
@r_cpp
how to use special characters
Hello guys, a question, is there a library or some method to be able to use special characters "¿,á" or cimilars when wanting to make a cout(sorry for my bad english)
https://redd.it/1cirr20
@r_cpp
What are the Cppx, Cppx-Blue, and Cppx-Gold languages on Compiler Explorer
I was trying to search this on Google, but the only thing I came across is Lock3 Software's Clang fork that supports blue and gold (https://github.com/lock3/cppx). What exactly are these languages? I know they are modifications to vanilla C++ adding support for things like reflection and metaclasses, but that is all I know.
https://redd.it/1cipoil
@r_cpp
std::forward<Args>(args)...);
}
return function_pointer(std::forward<Args>(args)...);
}
~sfunc()
{
if(lambda_deleter){
lambda_deleter(lambda);
}
}
};
https://redd.it/1ciek1o
@r_cpp
CLion unused includes cleanup
Hi,
CLion is doing good job for me with quite precise hints which include is unused.
However I work with team on quite big repos with many many unused includes
How I can use CLion to automatically cleanup it?
Or at least make it easier than walking from file to file
https://redd.it/1ciduio
@r_cpp
Awaiting a set of handles with a timeout, part 2: Continuing with two
https://devblogs.microsoft.com/oldnewthing/20240501-00/?p=109718
https://redd.it/1ci8v1d
@r_cpp
How do you get into High-Performance Computing?
I would like to have a career in High Performance Computing but I don't know how to develop the skills that'll make me employable. I'm going to make an educated guess and say that the primarily applications of HPC can be found in academia (e.g., astronomy, physics), finance (high-frequency trading), AI, and defense (radar, DSP, communication systems).
Do SW devs who work in High Performance Computing pick up a general technical skillset and are hired in any industry?
Or do they first specialize in one industry and jump to other industries (e.g., start out in defense doing DSP HPC for communication systems, and then get hired by a finance company)?
I'm currently working for a defense contractor and have the opportunity to go back for a Masters degree on their dime. There's an opportunity to go back to school for masters but I can't decide whether to go back for DSP (Digital Signals Processing) or for HPC (as a pure compsci discipline).
this job looks like a nice low-bar gateway into HPC but I don't want to be stuck doing radar my entire career (defense has great educational perks but does not pay well; also, tech tends to be aged and there's a lot of red tape that slows down pace of development - which means there are fewer opportunities to make impactful change that'll justify a pay raise).
https://redd.it/1chy760
@r_cpp
What is the most disgusting compiler error you have ever gotten?
I'm just curious. Often I get very long compiler errors, where the substance is actually just a mere 1 line somewhere in that output. For example if I forget to include a forward declared type within a vector / shared_ptr good luck.
What is the nastiest error you had ?
https://redd.it/1chvadh
@r_cpp
Ask cpp: change destructor call order
I’ve stumbled onto a problem where the easiest solution would be to reverse destructor call order (base destructor first, then derived destructor). However, I cant pull this off, and my reasearch on the web cannot find a way around this “automatic” stack unwinding problem. Does anyone have any suggestions how to pull this off?
Background: I have an Actor programming model, and the base destructor unregisters the actor from the work threads and other house keeping. The derived actors do their unique cleanup. However in a multithreaded environment, the derived actor can get its destructor called first, but before the base destructor can deregister, a message gets actioned for a partially destoyed actor. An elegant generic fix would be for deregistering (base cleanup) to happen before derived cleanup. A less elegant solution is to force each derived actor to call a “terminate” member function early in the destructor.
https://redd.it/1chr1ov
@r_cpp
Forge Stronger Code: Emulating Rust’s Approach for Unit Testing in C++
https://itnext.io/forge-stronger-code-emulating-rusts-approach-for-unit-testing-in-c-cfccbdf2be16?source=friends_link&sk=69ef271e0d45869c9f65ce490a681a9b
https://redd.it/1chl70n
@r_cpp
