C++ - Reddit
227 subscribers
48 photos
8 videos
1 file
25.4K links
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
Download Telegram
Why CMake encourages distributing it's *.cmake files instead of *.pc for libs configuration.

Some time ago it was a standard that must libraries distributed XYZ.pc files for pkg-config that could be later consumed by any build system (or none). Recently I see trend that it's encouraged to distribute appropriate FindXYZ.cmake or XYZConfig.cmake.

Why is that so? What additional information can be conveyed through cmake files that is crucial for libraries?

https://redd.it/el9b0u
@r_cpp
Anjuta and Test Driven Development

I love working with Anjuta. It was with me during my early days of programming on Linux and taught me a few basics regarding creating programming projects.

Now, the question. I'm working on a rather large C++ library, and I want to implement Test Driven Development, but haven't really found anything that will work natively on Anjuta. I've previously worked with Qt's TDD tools, but have very little experience using others. So this is a kind of growth opportunity for me and I'd like to see what I can use.

I know both Google and Boost provide TDD tools, but which would you recommend or are there others you'd think about using with Anjuta?

Any and all help is appreciated.

https://redd.it/elbiiy
@r_cpp
HttpListener in C++

Hey guys,

Is there in C++ something similar to HttpListener from C#?

Problem at hand is that I need to send http request from React app to my C#/C++ application. I managed to successfuly implement that using HttpListener class from C# but I would prefer to do it in C++.

I tried using boost sockets with WebSockets in JavaScript but it did not quite work. WebSocket connection status hanged at CONNECTING, it never fired onopen event to confirm that connection is established.

https://redd.it/elehna
@r_cpp
Is there any reason why C++20 does not contain constexpr functions for converting to and/or from strings?

Since [More constexpr containers](https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2019/p0784r7.html) and [Making std::string constexpr](https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2019/p0980r1.pdf) were accepted to C++20, allowing transient allocations with strings, is there any reason why there is no way to convert the string to numeric values and vice versa in constexpr context? p0980r1 basically makes everything constexpr in the string header, except for the streaming operators, `getline` and the string conversions. While it's kind of obvious why the first two are not constexpr, I don't see any reason why the last one couldn't be. Initially I thought this would be supported by `std::from_chars` and `std::to_chars` since they are non-allocating, but there seems to be no push to make these constexpr either. The C functions with similar functionality are also out of the picture due to... well, being C functions.

Is there a way something like this could still get into C++20, at least for the from\_chars-like variant (e.g. via NB comments), or at least C++23? Or is there something I'm missing?

https://redd.it/elfpmk
@r_cpp
Need to recover or go to old version of main.cpp in CLion [URGENT]

Hello everyone,

So I did something really stupid. I had a "main.cpp" file in my project in which I had started work on an assignment. Since I have another project where I use the main.cpp as scratch file I went into the important (non scratch) project, removed what was in the main.cpp file and started typing some scratch things. I saved it, ran it and closed CLion. Now I reaaaaaaalllly need to go back to the previous version of the file in the important project asap.

In other words, can I go back to a previous saved version of a main.cpp file? control-zetting does not work since I closed the application already.

Thanks in advance!!!

https://redd.it/elgx9d
@r_cpp
Changing from inheritance to std::variant inverts your header include hierarchy

I have some code I originally wrote in a dynamically typed language, and I'm converting it to C++. This involves applying type discipline to a design which was not designed with static typing in mind.

The code in question (is unrelated to the web, but) was inspired by the idea of cascading style sheets (CSS): it's a simplified declarative description of complicated runtime objects, so that you describe the style of an object with data and something else constructs it.

An important point is that different subtypes of object style have different sets of valid properties. So for instance something describing a linear slider has linear min/max properties, while something involving rotation has properties of rotational (angle) limits.

My first approximation was to create a class hierarchy with common-to-all properties in the base class, and many derived classes for the various specific styles. Standard OOP.

However I decided I wanted to change the style objects to be value types, so that they can be passed by const& or stored by value, without needing to use std::shared\_ptr or other memory management.

In the inheritance model, more-specific style classes included the base class with common properties inside of the derived object. In the updated design, the former base class (now a value type not a base) becomes the bigger object, containing within it the same common properties and a std::variant of all specific styles as a sub-object.

What I found interesting was in the inheritance design the specific style header(s) included the base style header, but with a std::variant based design that relationship is inverted; what had been the base class header now includes all the of the specific style header(s) (in order to be able to describe what's in the std::variant).

This may seem to be a trivial detail about header includes, but I believe in this case it also a deeper point about the difference between inheritance based designs and std::variant based designs.

**tl;dr:** When using inheritance, the more specific class(es) depend(s) on the more abstract class. When using std::variant, the more abstract class depends on the more specific class(es).

https://redd.it/elhf4z
@r_cpp
Grisu-Exact: a variant of Grisu, always producing shortest & correctly rounded outputs

I developed yet another float-to-string conversion algorithm based on Grisu and Ryu. It outperforms Ryu when the number of digits is small (up to 6\~7 for float's, up to 15\~16 for double's). The [paper](https://github.com/jk-jeon/Grisu-Exact/blob/master/other_files/Grisu-Exact.pdf) is not peer-reviewed so the algorithm might contain an error. Also, I didn't thoroughly test if the produced output is really shortest and correctly rounded, although it seems correct. Please check this repository if you are interested:

[https://github.com/jk-jeon/Grisu-Exact](https://github.com/jk-jeon/Grisu-Exact)

https://redd.it/elhev9
@r_cpp
C++ real world applications for non-engineers

I love to code with C++, but I'm not an engineer, and I feel it is more for engineers who program for firmware and microcontrollers, my question how can I can use C++ to program real world applications to get hired?

P.s: I'm not native English speaker so forgive me for any mistakes.

Thank you in advance

https://redd.it/eltc9l
@r_cpp
Fun with variadic lambdas, fold expressions... another zip()

https://godbolt.org/z/WMGg76

So, I've been messing around with C++17's fold expressions, std::apply() and variadic lambdas for a small matrix expression template library I'm working on. I put together a nice implementation of Pythons zip() function to make range based for loops natural and have pulled it out into a gist. It supports all the STL containers (even std::vector<bool>).

Check it out, have I missed something: [github](https://gist.github.com/ConorWilliams/2dc0be178c0917617e475f9da27bf3c6)

https://redd.it/em0twe
@r_cpp
App

Looking to start learning how to make an app for IOS. Where is the best place to start?

https://redd.it/em21kc
@r_cpp
Im learning C++ and Im learning STL now. What should I do next after STL ?

Ive learned everything from Pointers to ploymorphism, streams, inheritance, smart pointers, operator overloading , OOP programming and now Im on a STL just getting into generic programming. Im learning online by myself, and I was wondering can I get a job with my knowledge of C++ now ? And how ? If not should I learn mooore C++ ? What do u recommend ?

Edit: I do practice on a daily basis. Itd be nice if I make friends with actual programmers here.

https://redd.it/em3516
@r_cpp