C++ - Reddit

Initialization in Modern C++
https://twitter.com/timur_audio/status/1004017362381795329

https://redd.it/8ouogo
@r_cpp

GitHub - Raconfig: C++ declarative wrapper on Boost.Program Options for comfortable configuration handling
https://github.com/rambler-digital-solutions/raconfig

https://redd.it/8or5av
@r_cpp

Qt Creator's Clang Code Model - Qt Blog
http://blog.qt.io/blog/2018/06/05/qt-creators-clang-code-model/

https://redd.it/8oqlru
@r_cpp

simple program but cant understand the output.

Hi guys i am new to c programming . can anyone tell me why the output value of i in the last line is 2. i am confused.

program:\-

#include \

int main\(\){
int i;
i = printf\("Hello\\n"\);
printf\("%d\\n",i\);
i = printf\("%d",printf\("Hello world linux\\n"\)\);
printf\("\\t%d\\n",i\);
return 0;
}

output:\-

Hello

6

Hello world linux

18 2

Thankyou

https://redd.it/8oq6ix
@r_cpp

Need some C++ advice moving forward

So I have a problem with my C\+\+ learning style. It seems like I'm learning a lot through videos, grasping lots of concepts, but I don't know how good I am nor what else I need to know.

I haven't built many large programs, I can build several hundred line, small and simple programs, but can never piece together something big. I'm also attending grad school next year in the Spring at a top 10 CS university. The C\+\+ coursework is very heavy and there are some courses that require understanding programs with 80000\+ lines. This scares me greatly as someone who hasn't built many large programs I guess my 3 main issues are:

1\) What 'intermediate\-advanced' topics should I know?

2\) What are must know topics?

3\) How can I improve to building larger programs? I watch people a couple hours a day build their own moderately large programs\(engines usually\), and I'd like to do the same.

https://redd.it/8onaup
@r_cpp

Constexpr pseudorandom numbers
https://mklimenko.github.io/english/2018/06/04/constexpr-random/

https://redd.it/8ol1y2
@r_cpp

std::array/std::vector in main function declaration?

Hello,


are there any plans to introduce something like

int main(const int argc, const std::array &argv)

or even

int main(const std::vector &argv)

in C++?

As far as I know, C++ is trying to provide alternatives for unsafe or in general less convenient C features. Wouldn't something like this be the next step?
If not, what are some principal problems with doing that?

One guess would be that this is not an option for a freestanding implementation (or for Kernel/Embedded uses), but other than that?

https://redd.it/8ol1a1
@r_cpp

GitHub - ethanhs/cce: commandline compiler explorer
https://github.com/ethanhs/cce#cce---command-line-compiler-explorer

https://redd.it/8oksc8
@r_cpp

Best way to make a large project?

I have a large project I'm planning on making, and each section would be divided into chapters. My original plan is just to make each chapter a function in *Source.cpp* and then have a main function in *Source.cpp*, but is there a better way to do so?

https://redd.it/8okg7i
@r_cpp

Ivan Čukić | Knowing when not to use the STL algorithms - set operations
https://cukic.co/2018/06/03/set-intersection-in-cxx

https://redd.it/8ojqoq
@r_cpp

Which C++ style guide do you follow?

I have been reading Effective C++ series and I wondered about C++ style guides. I've been programming C++ for a few years now but I've never followed any particular style (perhaps a little of Google's C++ style) before.

Google's C++ style is not liked because "it disallows exceptions and lacks C++11 support". **What C++ style do you follow? What are it's pros/cons?**

Edit: spelling

https://redd.it/8oja7y
@r_cpp

plugin-based architecture ?

looking for a lightweight plugin-based architecture that I can integrate into a QT type product. suggestions?

https://redd.it/8oijlp
@r_cpp

Const - Friend of Foe in C++?
https://www.sourcetrail.com/blog/const_friend_or_foe_in_cpp/

https://redd.it/8ohp08
@r_cpp

Everything You Need to Know About std::variant from C++17
https://www.bfilipek.com/2018/06/variant.html

https://redd.it/8ofhjo
@r_cpp

res) capabilities. It is not intended as necessarily the ideal means to mass gzip decompress large numbers of files, none-the-less, it's execution at doing so is rather brisk.

**NOTE:** *The program does tend to write a lot of debug messages (it's an experimental prototype - not production code) so is a good idea to redirect its `stderr` output to a file, or even to `2>/dev/null` in order to see the program execute a closer to optimal speed.*

## The bigger picture

The greater intent of this exploration is to devise a particular reactive programming implementation that will be infused into another github project:

[**Spartan - a "forking" java program launcher**](https://github.com/tideworks/spartan-launcher)

**Spartan brief description:**

*Java supervisor process can launch Java child worker processes (uses Linux fork and then instantiates JVM). Child programs run as same user identity/permissions capability - no authentication or special permissioning necessary. A Spartan-launched Java program thus shares the same Java code amongst parent supervisor and children processes - just as with using `fork()` in C and C++ programming.*

https://redd.it/8oeqq5
@r_cpp

read-multi-stream - C++ reactive prototype application exploring the use of Linux select() and non-block read() to process multiple input file streams

*This is an exploratory program have devised with intent to add a reactive programming model to another open source project called Spartan (see at end). Looking to see if others are interested in this kind of thing - reactive programming, etc.*

# [read-multi-stream](https://github.com/roger-dv/read-multi-stream)

## Introduction

A C++11 prototype application exploring the use of the Linux `select()` system call and `read()` system call, invoked in a non-blocking manner, to process multiple input file streams concurrently.

## Description of program project

The source code is C++11 compliant and has been compiled and successfully executed where used the GNU C++ (g++) 4.8.4 compiler. The program was developed in the JetBrains CLion C++ IDE and is therefore a cmake-based project.

## Description of program operation

The program will process one or more file paths as specified on its command line when invoked. It assumes that each file will be a text file compressed using gzip and thus the file names are expected to end in the `'.gz'` suffix. The program will, for each file, perform a `fork()` system call and then `exec` the `gzip` program (which is assumed can be locatable via the `PATH` environment variable), it will setup redirection of a `gzip` child process `stdout` and `stderr` so that these pipe streams can be processed as input streams by the program's parent process.

The C++ class `read_multi_stream` is used to manage the redirected streams of each forked child process. The method `read_multi_stream::wait_for_io()` is used to wait for i/o activity on these redirected pipes. It will return with a vector populated with any pipe file descriptors that are ready to be read. The program dispatches these active file descriptors to be read via an asynchronously invoked read processing function and then waits on futures of all dispatched file descriptors. When all futures are harvested, then it iterates and calls `read_multi_stream::wait_for_io()` again, repeating the cycle until all pipes have been read to end-of-file condition (or errored out).

The output of the pipes, assumed to be text streams, will be read a text line at a time. The program will write the output of a redirected `stdout` to a file by the same name as the input file, but omitting the `'.gz'` suffix. The redirected `stderr` is written to a file by the same name as this output file but with the suffix `'.err'` appended - any diagnostic output or errors occurring per the processing of a given input file will be written to its corresponding `'.err'` file.

The operation to process a given text line is dealt with as a lambda callable; the current implementation merely writes the text line to the destination output file, however, this lambda callable is where application logic processing could be performed (if any) on each text line at a time.

The C++11 `std::async()` function is used to asychronously process each ready-to-read file descriptor, where the `std::launch::async` option is used to insure is processed on some thread.

GNU g++ 4.8.4 appears to map asychronous invocation directly to pthread library threads. The C++11 standard did not dictate an implementation approach for `std::async()` so it is conceivable that an implementor might utilize a sophisticated thread pool incorporating work stealing algorithms, etc. Future versions of C++ - probably starting at C++20 - will perhaps introduce exectutors and thread pools with richer APIs.

The GNU g++ 4.8.4 implementation of `std::async(std::launch::async, ...)` does exhibit interleaved, round robin concurrency behavior, though, when this program is fed lots of input files to process.

Keep in mind, the nature of the way this program works was devised so as to test out and explore programming with the `select()` system call, in conjunction to non-blocking invocation of the `read()` system call, in conjunction to C++11 asynchronous and concurrency (futu

Classes and objects.

What's the best way to create objects in Cpp? On the stack or heap?

https://redd.it/8odhc8
@r_cpp

About overloaded functions...

i have a question for programmers about overloaded functions, let's say you have 2 overloaded functions one with 2 parameters and the other with 3 parameters and a default value, which one runs?


https://redd.it/8ocpme
@r_cpp

Managing libraries with Nix
https://blog.galowicz.de/2018/02/27/managing_libraries_with_nix/

https://redd.it/8obji4
@r_cpp

NanoRange -- MSVC-compatible implementation of the Ranges TS

For the last few weeks I've been beavering away on a library called NanoRange. It's a C++14 implementation of the C++20 Ranges proposals (formerly the Ranges TS). So it's like Range-V3, except that

* it's very much smaller (it only targets things that are in line for C++20)
* it can be used as a single header, drop-in replacement for ``
* it's compatible with the latest MSVC
* it probably has a lot more bugs :-) (although it does pass the relevant parts of the [CMCSTL2](https://github.com/CaseyCarter/cmcstl2/) test suite)

It's pretty new and still unfinished (in particular, none of the "views" from P0789 are implemented yet), but I'm keen to get some early feedback if anyone fancies trying it out.

The code is available on Github:

https://github.com/tcbrindle/nanorange

There's no documentation to speak of yet, but the Ranges TS itself is (partially) documented [on cppreference.com](http://en.cppreference.com/w/cpp/experimental/ranges)

https://redd.it/8ob7dd
@r_cpp