CPlusPlus | repository contains some material I 've created to teach | Learning library

execve() is not a wrapper for system(); it is a wrapper for the execve syscall itself.

execve() replaces the current process, so you’ll probably need to fork() and then execute execve() in the child process, thereby emulating the behaviour of system().

C++ gives you the ability to shoot yourself in the foot.

Initialising an integral type variable to 0 is a machine instruction typically of the form

std::vector is the fastest STL container for linear iterations like in your scenario. This is simply because memory is contiguously allocated and therefore can benefit of caching mechanisms. A vector iterator just increments a pointer internally.

You might improve performance further by trying to use a smaller type than int when possible.

In your case I think parallelization/SIMD would give largest performance boost for reduction. This might be achieved by auto vectorization (check project compiler settings).

You could also try OMP to do this like this (not tested)

OutputIterator here is an exposition-only name for the template parameter. It has no specific functionality.

The linked site unfortunately doesn't specify which types are allowed as template argument for OutputIterator. If you take instead e.g. the cppreference.com page for std::copy_if, you see that it specifies that the type must be a LegacyOutputIterator (aka an output iterator).

This is a term describing specific requirements that the type must satisfy in order to be allowed to be used with std::copy_if.

An output iterator type is just an iterator type which allows writing to the dereferenced iterator. For the details see https://en.cppreference.com/w/cpp/named_req/OutputIterator.

On the page you linked for std::back_inserter, it says that it is a function returning a std::back_insert_iterator. When you use std::back_inserter(...) in the argument list of std::copy_if, you are passing it this returned object, not the std::back_inserter itself.

If you click on the name of that type on the linked page, you will see that it specifies that std::back_insert_iterator is a LegacyOutputIterator.

So, it is allowed to be used in std::copy_if.

std::ostream_iterator is also an output iterator and therefore usable in std::copy_if. It is only used to "iterate" and write to std::ostream streams. It is not related to std::back_inserter. It is not related to std::vector either and you are not using it in your example.

"Iterate" here is not quite correct, because it doesn't really iterate anything. When writing to the dereferenced std::ostream_iterator it simply outputs the value to the associated std::ostream. This is why it says that ++ on it is a noop. There is nothing to do to advance it.

If you look closely at the specification of ranges​::​size in [range.prim.size], except when the type of R is the primitive array type, ranges​::​size obtains the size of r by calling the size() member function or passing it into a free function.

And since the parameter type of transform() function is reference, ranges::size(r) cannot be used as a constant expression in the function body, this means we can only get the size of r through the type of R, not the object of R.

However, there are not many standard range types that contain size information, such as primitive arrays, std::array, std::span, and some simple range adaptors. So we can define a function to detect whether R is of these types, and extract the size from its type in a corresponding way.

Even an empty class needs space to store itself, the minimum size of a class is therefore 1. As your no argument DataStructure class is empty and a member it takes up space and causes the rest of the members to take more space to allow for alignment. Making the base non-empty fixes the issue:

The compiler will use the name pow to find a set of candidate functions. Since you wrote using namespace std; (bad idea) this includes std::pow overloads. There are [edit]at least[/edit] 5 such overloads. (Compilers may add more overloads for efficiency).

Next up, for each overload that can accept 2 arguments, the compiler will determine 2 conversion sequences. So in total the compiler ends up with (at least) 5x2 conversion sequences

In overload resolution, the overload with the best conversion sequences is chosen. This requires that there is one overall winner amongst all overloads. If there is no clear winner, it would be ambiguous. This can easily happen with 5 overloads and 2 conversion sequences each: one overload can have the best conversion sequence for the first sequence, and another overload for the second sequence.

Note that in this case, you expect ties between conversion sequences. For instance,

If static_cast(-1) < static_cast(0) yields true, int[static_cast(-1) < static_cast(0)] leads to int[1] (true could be converted to int (and then std::size_t) implicitly with value 1), which is an array type.

If static_cast(-1) < static_cast(0) yields false, int[static_cast(-1) < static_cast(0)] leads to int[0] (false could be converted to int (and then std::size_t) implicitly with value 0), which is an invalid array type and SFINAE would discard the specialization from the overload set. (The size of array must be greater than zero (unless using in new[]-expression)).

You seem to be running your simulation in "release" mode, not "debug" mode. While this will let your simulation run much faster, it omits a lot of sanity checks and prints only minimal information about what is happening in your simulation. For all of these reasons, it is highly recommended to only run a simulation in "release" mode after it is completely finished.

For information on how to run a simulation in debug mode, see the Veins FAQ entry "How can I debug my OMNeT++ simulation models? How do I create a stack trace?" at http://veins.car2x.org/documentation/faq/

When running your simulation in debug mode, you should see a lot more log information that explains what is going on in the simulation. For example, the log output might look like this: