1)с процедурное программирование
2)и функциональное программирование
3)+ объектно-ориентированное программирование
4)+ обобщённое программирование (шаблоны C++)

https://code.facebook.com/posts/498597036962415/under-the-hood-building-moments/
There are many alternatives for sharing code between mobile platforms. We wanted to optimize for fast iteration, app performance, and native look and feel. After weighing the alternatives, we chose to write the UI in platform-specific code and the business logic in shared code using C++. Traditionally, C++ is known for providing high performance while lacking easy memory management and higher-level abstractions. However, using modern C++11 features such as std::shared_ptr reference counting, lambda functions, and auto variable declarations, we were able to quickly implement highly performant, memory-safe code.

"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

Вот тут C++ код скомпированный в JavaScript и запущенный в Firefox показывает скорость близкую к native'у — 75ms, на native C++ было 60ms, на C# — 69ms.
Если на C# использовать не низкоуровневый цикл, а transform и лямбду (как было на C++) — то получается 141ms.

C++ скомпилированный в ненативный JavaScript (в веб-браузере, Карл!) оказался практически в два раза быстрее кода на C#?

EP>C++ быстрый не от того что нативный, а от того что даёт бесплатные, либо крайне дешёвые абстракции.
EP>Если на C#/Java писать код без абстракций, то по скорости он будет близок к аналогу на C++ — но такого кода будет намного больше

EP>Если на C#/Java писать код без абстракций, то по скорости он будет близок к аналогу на C++ — но такого кода будет намного больше

.NET Native использует то же сервер, что и компилятор C++, который оптимизирован для статических сценариев предварительной компиляции.

.NET Native способна обеспечить повышение производительности для C++ разработчиков управляемого кода, так как она использует такие же или аналогичные средства, что и C++ за кулисами, как показано в следующей таблице.

EP>А он и не собирался

EP>Я говорю что если брать сферические рассуждения о гипотетической возможности оптимизировать код с тормозных языков до уровня C++ — то да, теоретически это вполне возможно, даже для динамически типизированных

EP>def add(x, y):
EP>    return x + y

EP>def sub(x, y):
EP>    return x - y

EP>def apply(f, *args):
EP>    return f(*args)

EP>print(apply(apply, apply, apply, add, 1, 2))
EP>print(apply(apply, apply, sub, 11, 2))
EP>

EP>auto add = [](auto x, auto y)
EP>{
EP>    return x + y;
EP>};
EP>auto sub = [](auto x, auto y)
EP>{
EP>    return x - y;
EP>};
EP>auto apply = [](auto f, auto... args)
EP>{
EP>    return f(args...);
EP>};

EP>print(apply(apply, apply, apply, add, 1, 2));
EP>print(apply(apply, apply, sub, 11, 2));
EP>

T <T>add(T x, T y):where where T : IAdd
  { return x.add(y)}

public static class <int>Extension:IAdd
{
 int add(int y){this+y}
 static int add(int x,y){x+y}

}

template<typename F>
auto foo(F f)
{
    return f();
}

int main()
{
    auto x = 0;
    return foo([=]{ return x; });
}

EP>template<typename F>
EP>auto foo(F f)
EP>{
EP>    return f();
EP>}

EP>int main()
EP>{
EP>    auto x = 0;
EP>    return foo([=]{ return x; });
EP>}
EP>

 T foo<T>(Func<T> f)
{
  return f();
}

int main()
{
    var x = 0;
    return foo<int>(=>{ return x; });
}

for(int i=0;i<ar.Length,i++)
    var a=ar[i];

S>> T foo<T>(Func<T> f)
S>>{
S>>  return f();
S>>}
S>>

EP>О чём и речь — у тебя внутри foo один тип для разных замыканий с одинаковой сигнатурой — а значит динамический полиморфизм и прочие индерекции, которые на порядок сложнее оптимизировать

return x>>

#include <vector>

int main()
{
    std::vector<int> xs;
    xs[5];
}

/usr/local/include/c++/6.1.0/debug/vector:415:
Error: attempt to subscript container with out-of-bounds index 5, but 
container only holds 0 elements.

Objects involved in the operation:
    sequence "this" @ 0x0x7fff719fd1d0 {
      type = std::__debug::vector<int, std::allocator<int> >;
    }
bash: line 7: 14850 Aborted                 (core dumped) ./a.out

S>>>> T foo<T>(Func<T> f)
S>>>>{
S>>>>  return f();
S>>>>}
S>>>>

EP>>>О чём и речь — у тебя внутри foo один тип для разных замыканий с одинаковой сигнатурой — а значит динамический полиморфизм и прочие индерекции, которые на порядок сложнее оптимизировать

return x>>

EP>То есть ещё раз, код C# чисто по построению намного труднее оптимизировать — для оптимизаций до уровней аналогичных C++ нужно либо язык модифицировать, либо делать оптимизаторы намного более мощные чем оптимизаторы C++

 T foo<T>(Func<T> f)
  {
  return f();
  }

template<typename F>
auto foo(F f)
{
    return f();
}

EP>>То есть ещё раз, код C# чисто по построению намного труднее оптимизировать — для оптимизаций до уровней аналогичных C++ нужно либо язык модифицировать, либо делать оптимизаторы намного более мощные чем оптимизаторы C++

S> T foo<T>(Func<T> f)
S>  {
S>  return f();
S>  }
S>

S>template<typename F>
S>auto foo(F f)
S>{
S>    return f();
S>}
S>

class AbstractF 
{
public:
    virtual int virtual_call() = 0;
};

int foo(AbstractF *f)
{
    return f->virtual_call();
}

struct ConcreteF 
{
    int x;
    int concrete_call()
    {
        return x;
    }
};

int foo(ConcreteF f)
{
    return f.concrete_call();
}

int foo(ConcreteF f)
{
    static_assert(sizeof(ConcreteF) == sizeof(int))
    return f.concrete_call();
}

EP>>Виртуальный вызов и прочее можно соптимизировать, но это очевидно более сложная задача чем заинлайнить простой вызов конкретного метода

·>>>assert вот как-то не прижился в managed языках...
EP>>ЕМНИП Sinix рассказывал что использует их во всю как раз в managed языке.
·>Можно, конечно. Но непонятно зачем. А где он об этом писал?

EP>>>То есть ещё раз, код C# чисто по построению намного труднее оптимизировать — для оптимизаций до уровней аналогичных C++ нужно либо язык модифицировать, либо делать оптимизаторы намного более мощные чем оптимизаторы C++

S>> T foo<T>(Func<T> f)
S>>  {
S>>  return f();
S>>  }
S>>

S>>template<typename F>
S>>auto foo(F f)
S>>{
S>>    return f();
S>>}
S>>

EP>class AbstractF 
EP>{
EP>public:
EP>    virtual int virtual_call() = 0;
EP>};

EP>int foo(AbstractF *f)
EP>{
EP>    return f->virtual_call();
EP>}
EP>

EP>struct ConcreteF 
EP>{
EP>    int x;
EP>    int concrete_call()
EP>    {
EP>        return x;
EP>    }
EP>};

EP>int foo(ConcreteF f)
EP>{
EP>    return f.concrete_call();
EP>}
EP>

class ConcreteF
{
  int x;
  int callee() { return x;}
}
var cf = new ConcreteF(0);
return cf.callee();

S>class ConcreteF
S>{
S>  int x;
S>  int callee() { return x;}
S>}
S>var cf = new ConcreteF(0);
S>return cf.callee();
S>

class ConcreteF
{
  int x;
  int callee() { return x;}
}
Func<...> cf = new ConcreteF(0);
return cf.callee();

EP>>Точно также как и ценность других defensive примочек, а-ля bounds checking

Conditional methods allow developers to create methods whose calls can be placed in the code and then either included or omitted during compilation based on a preprocessing symbol.

EP>>В чём ты видишь отличие? Выход за пределы bounds это есть логическая ошибка, которой в корректном коде нет

EP>>>>То есть ещё раз, код C# чисто по построению намного труднее оптимизировать — для оптимизаций до уровней аналогичных C++ нужно либо язык модифицировать, либо делать оптимизаторы намного более мощные чем оптимизаторы C++

EP>>Именно язык тут и при чём. Если писать на C++ в стиле C# — динамические замыкания, динамический IEnumerable, множество индерекций по памяти — то получим примерно такие же тормоза

EP>>Можно взять этот JS выхлоп и перевести на C# — и он там тоже будет работать быстро, несмотря ни на какой IL

C++ быстрый не от того что нативный, а от того что даёт бесплатные, либо крайне дешёвые абстракции.
Если на C#/Java писать код без абстракций, то по скорости он будет близок к аналогу на C++ — но такого кода будет намного больше

template<typename RandomAccessIterator, typename BinaryPredicate>
void sort(RandomAccessIterator m, unsigned n, BinaryPredicate p)

void Sort(IList<T> m, Comparison<T> comparison)

var xs = new[] { 1, 2, 3 };
var s = 0;
foreach (var item in xs)
{
    s += item;    
}

            var s = 0;
019A34D5  xor         esi,esi  
            foreach (var item in xs)
019A34D7  xor         ecx,ecx  
019A34D9  mov         edi,dword ptr [edx+4]  
019A34DC  test        edi,edi  
019A34DE  jle         019A34EB  

            foreach (var item in xs)
019A34E0  mov         eax,dword ptr [edx+ecx*4+8]  
            {
                s += item;    
019A34E4  add         esi,eax  
019A34E6  inc         ecx  
            foreach (var item in xs)
019A34E7  cmp         edi,ecx  
019A34E9  jg          019A34E0  
            }

template<unsigned SIZE> void size_is();

template<typename F>
auto foo(F f)
{
    size_is<sizeof(F)>();
    return f();
}

int main()
{
    auto x = 0, y = 1;
    foo([=]{ return x; });
    foo([=]{ return x + y; });
}

/tmp/cclb4DzB.o: In function `_Z3fooIZ4mainEUlvE_EDaT_':
main.cpp:(.text+0x1c): undefined reference to `void size_is<4u>()'
/tmp/cclb4DzB.o: In function `_Z3fooIZ4mainEUlvE0_EDaT_':
main.cpp:(.text+0x54): undefined reference to `void size_is<8u>()'
collect2: error: ld returned 1 exit status

EP>>>>>>Виртуальный вызов и прочее можно соптимизировать, но это очевидно более сложная задача чем заинлайнить простой вызов конкретного метода

EP>>И всё таки ты читать не умеешь "более сложная"

EP>>>>>>Виртуальный вызов и прочее можно соптимизировать, но это очевидно более сложная задача чем заинлайнить простой вызов конкретного метода

EP>>>>В любом случае это будет медленная динамическая хрень, против обычного вызова невиртуальной функции. И эту хрень намного тяжелее оптимизировать, простым преобразования C# -> C++ не отделаешься

S>>class ConcreteF
S>>{
S>>  int x;
S>>  int callee() { return x;}
S>>}
S>>var cf = new ConcreteF(0);
S>>return cf.callee();
S>>

EP>class ConcreteF
EP>{
EP>  int x;
EP>  int callee() { return x;}
EP>}
EP>Func<...> cf = new ConcreteF(0);
EP>return cf.callee();
EP>

class ConcreteF
{
  int x;
  int callee() { return x;}
}
return (new ConcreteF(0)).callee();