재귀함수와 비재귀 함수 성능비교 코드

#include 
#include 
#include 
#include 
void funcTask() // 작업함수
{
 int i;
 for(i=0; i<1000000; i++){};
}
int recu_factorial(int n)
{
 if( n == 0)
  return 1;
 else
 {
  funcTask();
  return n*recu_factorial(n-1);
 }
}
int iter_factorial(int n)
{
 int ret = 1;
 while(n>0)
 {
  ret *= n;
  n--;
  funcTask();
 }
 return ret;
}
double performFunc(int (*func)(int), int nLoopCnt, char *pszText)
{
 //clock_t stime, etime;
 //stime = clock();
 //etime = clock();
 //elaspeTime = (((double)(etime-stime))/CLOCKS_PER_SEC);
 LARGE_INTEGER liCounter1, liCounter2, liFrequency;
 QueryPerformanceFrequency(&liFrequency);  // retrieves the frequency of the high-resolution performance counter    
 QueryPerformanceCounter(&liCounter1);         // Start
 func(nLoopCnt);
 QueryPerformanceCounter(&liCounter2);         // End
 (double)(liCounter2.QuadPart - liCounter1.QuadPart) / (double)liFrequency.QuadPart;
 double elaspeTime;
 
 elaspeTime = (double)(liCounter2.QuadPart - liCounter1.QuadPart) / (double)liFrequency.QuadPart;
 return elaspeTime;
}
int main(int argc, char** argv)
{
 double dRecuTime = 0;
 double dIterTime = 0;
 int i = 0;
 for(i=0; i<100; i++)
 {
  dRecuTime = performFunc(recu_factorial, i+1, "recu_factorial");
  dIterTime = performFunc(iter_factorial, i+1, "iter_factorial"); 
  printf("Loop Count : %d, %C\n", i+1, (dRecuTime > dIterTime) ? 'I' : 'R'); // 반복함수가 재귀함수보다 빠르다면 'I' 재귀가 빠르면 'R'
  // 반복함수와 재귀함수 수행시간 출력
  printf("iter_factorial\t: %0.8f %C\n", dIterTime);
  printf("recu_factorial\t: %0.8f %C\n", dRecuTime);
 }
 
 return 0;
}

알고리즘 책에서는 보통 재귀함수보다는 비재귀함수의 성능이 월등하다고 들 한다.

하지만 실제로 재귀함수와 비재귀 함수의 성능을 직접 비교하고 보니 성능의 확연한 차이를 발견하긴 힘들어 보인다. 

다만 스택의 깊이가 500회정도로 제한되어 있어 반복 루프가 500회 이상인 경우는 비재귀함수를 사용할 수 밖에 없다는 점이 비재귀함수의 이점이라고??? 할 수 있겠다. 

그점을 제외하고는 재귀함수보다 훨씬 코드도 길고 복잡한 비재귀함수를 사용하는 것이 전반적으로 옳은가 하는 생각이 든다....