Quelle est la différence entre la récursivité et la récursivité de l'instance de classe

Question

Je vais être honnête, je ne suis pas sûr des termes que j'ai utilisés dans le titre.

Fondamentalement, je suis curieux de connaître la différence entre quelque chose comme:

class MyRecursiveClass 
{ 
public: 
    int myData; 
    MyRecursiveClass* nextInLine; 
    int myRecursiveFunction(int data) 
    { 
      data+=myData; 
      if(nextInLine == null) 
       return data; 
      else 
       return nextInLine->myRecursiveFunction(data); 

    } 
} 

et

int staticRecursiveFunction(MyRecursiveClass* target, int currentData) 
{ 
    if(target == null) 
     return currentData; 
    currentData+=target->myData; 
    staticRecursiveFunction(target->nextInLine, currentData); 
} 

ou

int otherStaticRecursiveFunction(MyRecursiveClass* target) 
{ 
    if(target == null) 
     return 0; 
    return target->myData + otherStaticRecursiveFunction(target->nextInLine); 
} 

Fondamentalement, ce que je veux est les différences dans les frais généraux, comme ainsi que de meilleures conditions pour la différence entre les deux méthodologies (j'étais à perte quand j'ai essayé t o Google)

En outre, des opinions personnelles et/ou des préférences. On m'a enseigné la récursivité plus comme un outil pour faire un travail, et j'aimerais entendre des avis professionnels (et amateurs).

aussi bonnes lectures sur les structures récursives/méthodologies seraient appréciés, mais ce n'est pas le but de ce site (plus je ne garde pas poser des questions potentiellement muets)

Answer 1

Je ne vois pas de différence entre les deux sauf que dans un cas vous appelez une méthode statique, et dans l'autre une méthode d'instance.

En ce qui concerne la récursivité, cela ne fait aucune différence. Cela semble être plus sur l'utilisation de la programmation orientée objet que sur la programmation procédurale (et la récursivité s'applique également aux deux). En ce qui concerne les appels, l'appel d'une méthode instance/virtuelle est probablement un peu plus lent sur la plupart des systèmes en raison de la répartition qui doit avoir lieu, mais cela ne peut pas être significatif dans le grand schéma des choses. (Si le coût des appels de méthode est un problème, vous pouvez vous éloigner complètement des récursions et les dérouler en boucle).