>Нет, ну есть конечно всякие умные указатели, однако без них кресты не прям таки сразу превращаются в C_с_чем бы то ни было.

Именно сразу и превращаются. По большому счету в чем разница между new\delete и malloc\free, если каждый руками выписывать?
...

unique_ptr нельзя передать просто в метод.
...

Интересно, как вы собрались RAII делать без умных указателей?

At Cassandra Summit opening today, Avi Kivity and Dor Laor (who had previously written KVM and OSv) announced ScyllaDB — an open-source C++ rewrite of Cassandra, the popular NoSQL database. ScyllaDB claims to achieve a whopping 10 times more throughput per node than the original Java code, with sub-millisecond 99%ile latency. They even measured 1 million transactions per second on a single node. The performance of the new code is attributed to writing it in Seastar — a C++ framework for writing complex asynchronous applications with optimal performance on modern hardware.

Вектор поддержкой SIMD типы, такие как Vector4, Matrix3x2, Plane, и Quaternion.

Глянул сейчас. В общем на старой машинке (C2D, WinXP 32) C# unsafe вариант кода исполняется почти с той же производительностью, что и C++ вариант с SIMD

• оптимизировали работу с памятью (а память по факту уже давно является многоуровневой системой кэшей)
  
• запустили user-space TCP/IP стек для определенного вида сетевых карт
  
• и пока не полностью реализовали все функции

var buffer = new int[image.Length];

var buffer = (int[])image.Clone();

for (int i = 0; i < n; i++)
    v[i] = v[i] * u[i];

for (int i = 0; i < v.Length; i++)
    v[i] *= u[i];

"The going word at Facebook is that 'reasonably written C++ code just runs fast,' which underscores the enormous effort spent at optimizing PHP and Java code. Paradoxically, C++ code is more difficult to write than in other languages, but efficient code is a lot easier [to write in C++ than in other languages]." – Herb Sutter at //build/, quoting Andrei Alexandrescu

for (int i = 0; i < n; i++)
A>    v[i] = v[i] * u[i];

for (int i = 0; i < v.Length; i++)
A>    v[i] *= u[i];

struct A {
    virtual void m() {
        std::cout << "A";
    }
};

struct B : A {
    virtual void m() {
        std::cout << "B";
        A::m();
    }
};

int main(int argc, char* argv[]) 
{
    B b;
    b.m();

    return 0;
}

    b.m();
00E15F90  lea         ecx,[b]  
00E15F93  call        B::m (0E11159h)

V>struct A {
V>    virtual void m() {
V>        std::cout << "A";
V>    }
V>};

V>struct B : A {
V>    virtual void m() {
V>        std::cout << "B";
V>        A::m();
V>    }
V>};

V>int main(int argc, char* argv[]) 
V>{
V>    B b;
V>    b.m();

V>    return 0;
V>}
V>

struct A {
    virtual void m() {
        std::cout << "A";
    }
};

struct B : A {
    virtual void m() {
        std::cout << "B";
        A::m();
    }
};

void f(A* a)
{
    a->m();
}

int main(int argc, char* argv[]) 
{
   auto b = new B();
   f(b);
}

void process(T * data) {
  process1(data);
  process2(data);
  process3(data);
  process4(data);
  process5(data);
}

...
G>void f(A* a)
G>{
    a->>m();
G>}
...
G>

int main(int argc, _TCHAR* argv[]) 
{
    B b;
    f(&b);
    return 0;
}

struct C {
    B b;
};

int main(int argc, _TCHAR* argv[]) 
{
    C c;
    f(&c.b);

    return 0;
}

EP>>Смысл есть. Например выше сравнили скорость работы высокоуровневого кода — вполне полезный тест

Complex operator*(Complex x, Complex y)
{
    return {x.re*y.re - x.im*y.im, x.re*y.im + x.im*y.re};
}
// ...
transform(v, u, v.begin(), [](auto x, auto y) { return x*y; });

for ( int i = 0; i < u_ar.length / 2; ++i ) {
    v.re(i, u.re(i) * v.re(i) - u.im(i) * v.im(i) );
    v.im(i, u.re(i)*v.im(i) + u.im(i)*v.re(i));
}

EP>Complex operator*(Complex x, Complex y)
EP>{
EP>    return {x.re*y.re - x.im*y.im, x.re*y.im + x.im*y.re};
EP>}
EP>// ...
EP>transform(v, u, v.begin(), [](auto x, auto y) { return x*y; });
EP>

EP>for ( int i = 0; i < u_ar.length / 2; ++i ) {
EP>    v.re(i, u.re(i) * v.re(i) - u.im(i) * v.im(i) );
EP>    v.im(i, u.re(i)*v.im(i) + u.im(i)*v.re(i));
EP>}
EP>

Complex c1 = Complex.One;
Complex c2 = new Complex(1.4, 2.3);
Complex c3 = c1 * c2;

S>Complex c1 = Complex.One;
S>Complex c2 = new Complex(1.4, 2.3);
S>Complex c3 = c1 * c2;
S>

#include <iostream>
#include <valarray>
#include <complex>

using namespace std;
using namespace literals;

int main()
{
    constexpr auto n = 5;
    valarray<complex<double>> x(2.5 + 10i, n), y(1.2 - 20i, n);
    x *= y;
    for(auto c : x)
        cout << c << endl;
}

valarray<complex<double>> x(2.5 + 10i, n), y(1.2 - 20i, n);
x *= y;