veca | A simple 2D and 3D vector library for JS | Animation library

Use the %% operator

It's because you are using std::cbegin (const begin) and std::cend (const end) in std::sort.
It means, that you can't change the order of your array!
Just replace it with std::begin and std::end like this:

As pointed out by @super and @Jarod42 the solution is very simple:

Don't use a template template argument in the base class or the expression templates for operators but instead replace the return type of double operator[] by auto.

The standard derived-to-base conversion sequences take the length of the inheritance chain into account when ranking conversion sequences, a close base would be deemed a better conversion sequence than a one that is further up the inheritance chain. And that in turn affects pointers and references too!

Sadly, since smart pointers are user defined types, they cannot benefit from this behavior. All three overloads are viable via a (valid) user defined conversion. And the "ranks" of the individual bases don't affect the ranking of the overloads.

But that doesn't mean we can't re-introduce the ranking impose by a derived-to-base conversion. We just need to do so via another argument. And by employing tag-dispatch, we can do just that.

We can define a helper utility type:

You can prevent memory leaks by using a principle of ownership: At every point, there needs to be an owner who is responsible for freeing the memory.

In the first example, the owner is the main function: It undoes all the allocations.

In the second example, each graph node has shared ownership. Both vecA and the linked nodes share ownership. They are all responsible in the sense that they all call free if necessary.

So in this sense, both versions have a relatively clear ownership. The first version is even using a simpler model. However: The first version has some issues with exception safety. Those are not relevant in this small program, but they will become relevant once this code is embedded into a larger application.

The issues come from transfer of ownership: You perform an allocation via new A. This does not clearly state who the owner is. We then store this into the vector. But the vector itself won't call delete on its elements; it merely call destructors (no-op for a pointer) and deletes its own allocation (the dynamic array/buffer). The main function is the owner, and it frees the allocations only at some point, in the loop at the end. If the main function exits early, for example due to exception, it won't perform its duties as the owner of the allocations - it won't free the memory.

This is where the smart pointers come into play: They clearly state who the owner is, and use RAII to prevent issues with exceptions:

Assignment to a 2d array:

Initialization lists are wrappers around const arrays.

unique_ptrs that are const cannot be moved-from.

We can hack around this (in a perfectly legal way) like this:

Consider the following minimal example of your problem:

1. It's a pity, but by now significance testing is supported only for independent samples. In your examples you want compare statistics on the dependent samples. You can ran significance calculations for independent proportions but results will be inaccurate.
2. Including multiple statistics is not difficult - you need just sequentially write tab_stat_. But complex table layout really is a challenge :(
3. Variable names for statistic always should be written in the tab_cells. After that you can write statistic functions with tab_stat_mean, tab_stat_cpct and etc. You can find documentation by printing ?tab_pivot in the R console. It is a standard way of getting manual for R functions.