Bonsoir,
 
j'ai un soucis au niveau d'une fonction qui compte le nombre d'element dans ma liste chainée.
Ma fonction est la suivante:
int CountListNode( ListNode* node )
{
      int result = 0;
      while(node->m_next!=NULL)
      {
           result++;
           node=node->m_next;
      }
      return result;
}
 
Quand j'execute mon code, je n'ai pas d'erreur a la compilation mais quand ma console s'ouvre elle plante.
Savez vous d'ou vient le probleme?
 
Merci d'avance.

Il me semble qu'il faut utiliser une variable temporaire
 

Bonsoir,
 
C'est quoi le test que tu fais aussi ?
Si node vaut null alors node->m_next existe pas et plante
 
 

Voila mon programme final:
 
#include <stdio.h>
#include <tchar.h>
#include <assert.h>
#include <process.h>
#include <cstdlib>
#include <iostream>
 
 
using namespace std;
class ListNode
{
public:
ListNode(int value){}
int m_value;
ListNode* m_next;
};
 
int CountListNode( ListNode* node )
{
    int result = 0;
 
    while(node->m_next!=NULL)
    {
        result++;
        node=node->m_next;
    }
 
    return result+1;
}
 
ListNode* ReverseList( ListNode* node )
{
    ListNode *tmp = NULL;
    ListNode *result=NULL;
 
    while(node!=NULL)
    {
        tmp=node;
        node=tmp->m_next;
        tmp->m_next=result;
        result=tmp;
    }
    return result;
}
 
void afficherListe(ListNode* node)
{
    ListNode*tmp = node;
    while(tmp != NULL)
    {
        printf("val = %d et adresse du suivant = %d\n",tmp->m_value, tmp->m_next);
    tmp = tmp->m_next;
    }
    printf("\n" );
}
 
int main()
{
    printf("List Test:\n" );
 
    ListNode node1(1);
    ListNode node2(2);
    ListNode node3(3);
 
    node1.m_next = &node2;
    node2.m_next = &node3;
    node3.m_next = NULL;
 
   afficherListe(&node1);
   ListNode *reverted = ReverseList(&node1);
 
return 0;
}
 
J'ai réglé mon soucis de console qui plante.
Mais il me semble qu'il m'affiche les adresse avec afficherliste pourtant j'avais déja bosser sur un tp du genre et j'avais pas de soucis ca me retournais bien des entiers dans m_value.

Ha c'est bon j'ai rien dit. J'ai réussi a me corriger tout seul j'avais oublier le constructeur.....
Merci tout de meme.

Ce serait un poil plus simple et plus clair ainsi IMHO:

 
ou bien en un peu plus compact
 

 
A+,

Le deuxième code est plus que superflu !

Pour ceux qui ne codent pas souvent en C sans doute, car pour un programmeur C, ça se lit direct:
Faire une incrémentation du compteur tant qu'il y a un noeud suivant.
 
A+,  

Et la version récursive, plus belle, plus subtile :

On peut faire pareil avec les autres fonctions (ex pour afficherListe)

Ca permet aussi très facilement d'afficher la liste à l'envers:

Ainsi, elle n'a pas grand intérêt, puisque pas optimisable par le compilateur, contrairement à celle ci qui fait de la tail-récursion:
 
int CountListNodeRec (ListNode *node, int acc) {
    if (!node) return acc;
    return CountListNode (node->m_next, ++acc);
}
 
int CountListNodeRec (ListNode *node) {
    return CountListNodeRec (node, 0);
}
 
A+,

Qu'on m'explique l'avantage de if (node) do par rapport au while (node)  en terme de beauté/élégance de code.  
Cela revient à faire un test inutile de plus il me semble.

Eh bien comptes le nombre de tests, et tu verras qu'il y en a exactement le même nombre dans chaque cas.
Et l'intérêt du do { ++result; } while ((node = node->m_next)); c'est de mettre en relief dans le test du while la partie qui évolue au fur et a mesure du parcours, plutôt que de la coller quelque part dans le bloc du while. Bref cela permet ici de séparer ce qu'on veut faire a chaque étape, dans le corps du bloc, du procédé de passage d'une étape à la suivante, dans le test d'arrêt du while. On sépare la partie 'itération' de la partie 'traitement à chaque itération'. Ici le traitement est trivial, certes, mais c'est une bonne idée IMHO de se placer dans un contexte un peu homologue à celui des itérateurs.
 
A+,

 
Bah elle a l'intérêt de fonctionner et de pas changer ses interfaces ni de rajouter une seconde fonction. (Quoi que en C++ on doit pouvoir donner une valeur par défaut au second argument et l'appeler avec qu'un seul argument).
Mais c'est vrai, et au passage, par défaut, GCC n'effectue pas d'optimisation des fonctions récursives terminales contrairement à ce qu'on pourrait penser (il faut soit le forcer explicitement soit demander du -O2 ou -O3)

Certes, mais par rapport a la fonction itérative initiale, elle a le défaut d'empiler des appels.
La récursivité, je n'ai rien contre lorsqu'il s'agit de procédures complexes à plusieurs paramètres, mais quand ça se dérécursive de manière triviale avec un accumulateur, je n'en vois pas l'intérêt dans le contexte du C++ (on serait dans le contexte d'un langage fonctionnel, je dis pas).
A+,