cout << factorial(7);
...

int factorial (int f)
{
  return f <= 1 ? 1 : f*factorial(f-1);
}

1.1.4 stable rev. 510

From Wikipedia, the free encyclopedia that anyone can edit

Converting a call to a branch or jump in such a case is called a tail call optimization.

For normal, non-recursive function calls, this is usually a micro-optimization that saves little time and space, since there are not that many different functions available to call. When dealing with recursive or mutually recursive functions, however, the stack space and the number of returns saved can grow to huge numbers, since a function can call itself, directly or indirectly, a huge number of times. In fact, it often asymptotically reduces stack requirements from linear, or O(n) stack space, to constant, or O(1) stack space.

V>Я не совсем понимаю принцип действия этого предполагаемого restrict. Это мы как бы "обещаем" компилятору что-то? А кто контоллирует выполнение обещания?

There are three reasons that "restrict" isn't part of C++ already:

— The committee felt that enough was being added to C++ already so that new features should be minimized. An isolated feature such as "restrict" could and should be tried out in the communities in which it is most needed before it is added it to Standard C++.
— The "restrict" feature cannot in general be verified to be safe by a compiler. The committee felt that more work was needed to see if a better-behaved alternative could be found.
— The C++ Standard Library provides valarray as a mechanism to support high-performance Fortran-like vector computation.

The reasons for reconsidering "restrict" are:

— "restrict" appears to be becoming increasingly useful as more processors acquire architectural features such as long pipelines and parallel execution. When "restrict" was first discussed by the C++ committee, maybe 5 percent of all processors used by the -- C++ community had the high-performance features that made "restrict" valuable. Today, I suspect that percentage is closer to 95 percent.
— We have not (to the best of my knowledge) found an alternative that lends itself to static type checking in a general C++ environment.
— The valarray part of the C++ Standard Library has not yet taken hold on a significant scale. If it does, valarray will have no problem coexisting with "restrict." Thus, the bigger issue is the coordination between the C and C++ national and ISO committees. However, every vendor of C and C++ implementations face a dilemma between conformance to a divergent standard and making the full set of facilities available in all contexts.

Interview With Bjarne Stroustrup http://www.research.att.com/~bs/devXinterview.html

To contrast, the committee has rejected many proposals. For example:

Several proposals for direct support for concurrency
Renaming of inherited names (sec12.8)
Keyword arguments (sec6.5.1)
Several proposals for slight modifications of the data hiding rules
Restricted pointers (``son of noalias'') (sec6.5.2)
Exponentiation operator (sec11.5.2)
Automatically generated composite operators
User­defined operator.() (sec11.5.2)
Nested functions
Binary literals
General initialization of members within a class declaration.

Bjarne Stroustrup:
The Design and Evolution of C++

open Array;;
let msort xs = 
    let rec sort bgn fin =
        let rec merge bgn mid fin =
            let shift () = blit xs bgn xs (bgn + 1) (mid - bgn) in
            if mid >= fin || bgn >= mid then ()
            else let x, y = xs.(bgn), xs.(mid) in
                 let change () = (shift (); xs.(bgn) <- y) in
                 let bgn, mid = if x <= y then (bgn + 1, mid)
                                else (change (); (bgn, mid + 1))
                 in merge bgn mid fin in
        if fin - bgn <= 1 then ()
        else let mid = (fin + bgn) / 2 in
             let () = sort bgn mid; sort mid fin
             in merge bgn mid fin
    in sort 0 (length xs);;

open List;;
let rec qsort = function
     | [] -> []
     | (x::xs) -> let left,right = partition ((>) x) xs
                  in qsort left @ x::qsort right;;

#include <iostream>
#include <functional
// ААААА. сколько кода поскипнуто :)

__forceinline int __fastcall factorial (int f)
{

00401000  push        esi  
00401001  mov         esi,ecx

  return f <= 1 ? 1 : f*factorial(f-1);

00401003  cmp         esi,1 
00401006  jg          factorial+0Fh (40100Fh) 
00401008  mov         eax,1 
0040100D  pop         esi

}

0040100E  ret

  return f <= 1 ? 1 : f*factorial(f-1);

0040100F  lea         ecx,[esi-1] 
00401012  call        factorial (401000h) 
00401017  imul        eax,esi 
0040101A  pop         esi

}

0040101B  ret

unsigned __fastcall fact_(unsigned n, unsigned accum)
{
  return n > 1 ? fact_(n-1, n*accum) : accum;
}

unsigned factorial(unsigned n)
{
  return fact_(n, 1);
}

unsigned __fastcall fact_(unsigned n, unsigned accum)
{
    return n > 1 ? fact_(n-1, n*accum) : accum;
00401000  cmp         ecx,1 
00401003  mov         eax,edx 
00401005  jbe         fact_+12h (401012h) 
00401007  mov         edx,ecx 
00401009  imul        edx,eax 
0040100C  dec         ecx  
0040100D  jmp         fact_ (401000h) 
}
00401012  ret

(* список - это всего лишь  *)
type 'a list = Nil | Cons of 'a * 'a list

(* "агрегаты" ;) *)
let (::) fst snd = Cons (fst, snd);;

let rec (@) l1 l2 =
  match l1 with
    [] -> l2
  | hd :: tl -> hd :: (tl @ l2)

let partition p l =
  let rec part yes no = function
  | [] -> (rev yes, rev no)
  | x :: l -> if p x then part (x :: yes) no l else part yes (x :: no) l in
  part [] [] l

(* ну а точнее родной окамловский список - это (определение a-la haskell): *)
type 'a list = [] | 'a :: 'a list

#include "stdafx.h"

#pragma inline_recursion(on)
#pragma inline_depth(2)

__forceinline int __fastcall factorial (int f)
{
  return f <= 1 ? 1 : f*factorial(f-1);
}

void Print(int i)
{
    printf("%d\n", i);
}

__declspec(noinline) void Test()
{
    Print(factorial(7));
}

void main()
{
    __asm int 3;
    Test();
}

__forceinline int __fastcall factorial (int f)
{
00401000  push        ecx  
  return f <= 1 ? 1 : f*factorial(f-1);
00401001  cmp         ecx,1 
00401004  mov         dword ptr [esp],ecx 
00401007  jg          factorial+10h (401010h) 
00401009  mov         eax,1 
}
0040100E  pop         ecx  
0040100F  ret              
00401010  push        ebp  
  return f <= 1 ? 1 : f*factorial(f-1);
00401011  lea         ebp,[ecx-1] 
00401014  cmp         ebp,1 
00401017  jg          factorial+24h (401024h) 
00401019  mov         eax,1 
0040101E  imul        eax,ecx 
00401021  pop         ebp  
}
00401022  pop         ecx  
00401023  ret              
  return f <= 1 ? 1 : f*factorial(f-1);
00401024  push        ebx  
00401025  lea         ebx,[ebp-1] 
00401028  cmp         ebx,1 
0040102B  jg          factorial+3Ch (40103Ch) 
0040102D  mov         eax,1 
00401032  imul        eax,ebp 
00401035  pop         ebx  
00401036  imul        eax,ecx 
00401039  pop         ebp  
}
0040103A  pop         ecx  
0040103B  ret              
  return f <= 1 ? 1 : f*factorial(f-1);
0040103C  push        edi  
0040103D  lea         edi,[ebx-1] 
00401040  cmp         edi,1 
00401043  jg          factorial+58h (401058h) 
00401045  mov         eax,1 
0040104A  imul        eax,ebx 
0040104D  imul        eax,ebp 
00401050  pop         edi  
00401051  imul        eax,ecx 
00401054  pop         ebx  
00401055  pop         ebp  
}
00401056  pop         ecx  
00401057  ret              
  return f <= 1 ? 1 : f*factorial(f-1);
00401058  push        esi  
00401059  lea         esi,[edi-1] 
0040105C  cmp         esi,1 
0040105F  jg          factorial+78h (401078h) 
00401061  mov         eax,1 
00401066  imul        eax,edi 
00401069  imul        eax,ebx 
0040106C  imul        eax,ebp 
0040106F  pop         esi  
00401070  imul        eax,ecx 
00401073  pop         edi  
00401074  pop         ebx  
00401075  pop         ebp  
}
00401076  pop         ecx  
00401077  ret              
  return f <= 1 ? 1 : f*factorial(f-1);
00401078  lea         ecx,[esi-1] 
0040107B  call        factorial (401000h) 
00401080  imul        eax,esi 
00401083  imul        eax,edi 
00401086  mov         ecx,dword ptr [esp+10h] 
0040108A  imul        eax,ebx 
0040108D  imul        eax,ebp 
00401090  pop         esi  
00401091  imul        eax,ecx 
00401094  pop         edi  
00401095  pop         ebx  
00401096  pop         ebp  
}
00401097  pop         ecx  
00401098  ret