C++ 茎叶图。 我不明白如何制作链表的链表

Question

I have a project making a stem and leaf plot with linked lists and I keep getting errors that I don't even understand. How do you make a linked list of linked lists? I have to do it this way for the assignment so I can't do it in an alternate way and I have to work from the files below. My top stem linked list works, but it doesn't seem to be accessing the leaf portion and I'm getting the following error:

"The instruction at 0x0000000000404050 referenced at 0x000000000000001E. The memory could not be read."

Here is my code:

* Driver.cpp
*/

#include <iostream>
#include <string>
#include <iomanip>
#include <fstream>

using namespace std;

#include "StemAndLeaf2.h"

int main()
{

 ifstream fin("input.txt");

 int x;
 unsigned short leafunit, stemunit;

 fin >> leafunit >> stemunit;

 StemAndLeaf one;
 one.setLeafUnit(leafunit);
 one.setStemUnit(stemunit);

 while (fin >> x)
 {
   one.addTerm(x);
   cout << "Insert: " << x << endl;
   cout << "StemAndLeafPlot: " << endl;
   cout << one << endl;
 }

 cout << "The smallest term: " << one.getSmallestTerm() << endl;
 cout << "The largest term: " << one.getLargestTerm() << endl;
 
   return 0;
}

/*
* SteamAndLeaf2.h
*/

#ifndef STEAMANDLEAF2_H_
#define STEAMANDLEAF2_H_

#include <math.h>
#include <list>
#include <ostream>
// DO NOT REMOVE THE LINE BELOW
/* CMSC341_TEST_INCLUDES */

#include "Stem2.h"

class StemAndLeaf
{
   // DO NOT REMOVE THE LINE BELOW
   /* CMSC341_FRIEND_CLASSES */
public:
   StemAndLeaf(){FRONT_ptr = NULL; REAR_ptr = NULL;};
   ~StemAndLeaf()
   {
       while(FRONT_ptr != NULL)
       {
           Cursor = FRONT_ptr;
           FRONT_ptr = Cursor->getNext();
           delete Cursor;
       }
   }

   unsigned short getLeafUnit() const { return leafUnit; }
   void setLeafUnit(unsigned short leafUnit) { this->leafUnit = leafUnit; }
   unsigned short getStemUnit() const { return stemUnit; }
   void setStemUnit(unsigned short stemUnit) { this->stemUnit = stemUnit; }

   /**
    * @brief Get the smallest term in the datastructure. The term MUST be reconstructed
    *
    * @return unsigned short
    */
   unsigned short getSmallestTerm() const
   {
       return ((FRONT_ptr->getValue()*10))+(FRONT_ptr->findSmallestValue()));
   }

   /**
    * @brief Get the largest term in the datastructure. The term MUST be reconstructed
    *
    * @return unsigned short
    */
   unsigned short getLargestTerm() const
   {
       return ((REAR_ptr->getValue()*10))+(REAR_ptr->findLargestValue()));
   }


   /**
    * @brief Adds the term to the data structure. Insertion MUST be ordered, both for Stem and the Leaf
    *
    * @param term the value to add
    */
   void addTerm(unsigned short term)
   {
       Insert = new Stem();
       Insert->setValue(term/10);
       Insert->setLeafList(Insert->getLeafLink());
       if(isEmpty())
       {
           Insert->setLeafCount(1);
           Insert->insert(term%10);
           FRONT_ptr = Insert;
           REAR_ptr = Insert;
       }
       else
       {
           for(Cursor = FRONT_ptr; Cursor != NULL; Prev = Cursor, Cursor = Cursor->getNext())
           {
               Insert->setLeafCount(1);
               Insert->insert(term%10);
               if((Cursor == FRONT_ptr) && (Cursor->getValue() > Insert->getValue()))
               {
                   Insert->setNext(Cursor);
                   FRONT_ptr = Insert;
               }
               else if((Cursor == REAR_ptr) && (Cursor->getValue() < Insert->getValue()))
               {
                   Cursor->setNext(Insert);
                   REAR_ptr = Insert;
               }
               else if((Prev->getValue() < Insert->getValue()) && (Cursor->getValue() > Insert->getValue()))
               {
                   Prev->setNext(Insert);
                   Insert->setNext(Cursor);
               }
               else if(Insert->getValue() == Cursor->getValue())
               {
                   if(!Cursor->insert(term%10))
                   {
                       Cursor->incrementLeafCount();
                   }
               }
               break;
           }
       }
   }

   /*
    * Used to display/debug the StemAndLeaf diagram
    * will look exactly like this (using example in project):
    *
    * 0 | 0:1
    * ...
    * 2 |
    * 3 | 6:2 9:1
    *
    * You will not be given too much data to overrun 80 characters
    */
   friend std::ostream &operator<<(std::ostream &out, const StemAndLeaf &x)//;
   {
       out << x.FRONT_ptr->getValue() << " | ";
       return out;
   }

private:
   unsigned short leafUnit; // increment of each leaf in this particular structure
   unsigned short stemUnit; // increment of each stem in this particular structure

   Stem *FRONT_ptr, *REAR_ptr, *Insert, *Prev, *Cursor;

   inline bool isEmpty() const { return FRONT_ptr == nullptr; }

};
#endif /* STEAMANDLEAF2_H_ */

/*
 * Steam2.h
 */
#ifndef STEM2_H_
#define STEM2_H_
#include <ostream>
#include <list>
// DO NOT REMOVE THE LINE BELOW
/* CMSC341_TEST_INCLUDES */

#include "Leaf2.h"

class Stem
{
    // DO NOT REMOVE THE LINE BELOW
    /* CMSC341_FRIEND_CLASSES */

public:
    Stem(){FRONT_ptr = NULL; REAR_ptr = NULL;}
    virtual ~Stem(){};

    unsigned short getLeafCount() const { return m_LeafCount; }
    void setLeafCount(unsigned short LeafCount) { m_LeafCount = LeafCount; }
    void incrementLeafCount() { m_LeafCount++; }
    void decrementLeafCount() { m_LeafCount--; }

    Leaf *getLeafLink() const {return FRONT_ptr;}
    void setLeafList(Leaf *LeafList) { FRONT_ptr = LeafList; }

    unsigned short getValue() const { return m_Value; }
    void setValue(unsigned short value) { m_Value = value; }

    Stem *getNext() const { return m_Next; }
    void setNext(Stem *next) { m_Next = next; }

    /**
     * @brief Add the value to the stem. Returns trues if a new lef was created
     *
     * @param value The number to insert
     * @return true if a new leaf was created
     * @return false if we've seen the value before
     */
    bool insert(unsigned short value)
    {
        Insert = new Leaf();
        Insert->setValue(value);
        if(FRONT_ptr = NULL)
        {
            FRONT_ptr = Insert;
            REAR_ptr = Insert;
            return true;
        }
        else
        {
            for(Cursor = FRONT_ptr; Cursor != NULL; Prev = Cursor, Cursor = Cursor->getNext())
            {
                if(Cursor->getValue() == Insert->getValue())
                {
                    Cursor->incrementCount();
                    return false;
                }
                else
                {
                    if((Cursor == FRONT_ptr) && (Cursor->getValue() > Insert->getValue()))
                    {
                        Insert->setNext(Cursor);
                        FRONT_ptr = Insert;
                    }
                    else if((Cursor == REAR_ptr) && (Cursor->getValue() < Insert->getValue()))
                    {
                        Cursor->setNext(Insert);
                        REAR_ptr = Insert;
                    }
                    else if((Prev->getValue() < Insert->getValue()) && (Cursor->getValue() > Insert->getValue()))
                    {
                        Prev->setNext(Insert);
                        Insert->setNext(Cursor);
                    }
                    return true;
                }
            }
        }
    }
    unsigned short findSmallestValue()
    {
        if(FRONT_ptr != NULL){
        return FRONT_ptr->getValue();}
        else {return 0;}
    }
    unsigned short findLargestValue()
    {
        if(REAR_ptr != NULL){
        return REAR_ptr->getValue();}
        else {return 0;}
    }

private:
    // they are given the code for a L.L.
    Leaf *FRONT_ptr, *REAR_ptr, *Insert, *Prev, *Cursor;

    /**
     * Stem Value
     */
    unsigned short m_Value;

    /**
     * How many leaves in this stem
     */
    unsigned short m_LeafCount;

    /**
     * Pointer to the next stem
     */
    Stem *m_Next;
};
#endif /* STEM2_H_ */

/*
*Leaf2.h
*/

#ifndef LEAF2_H_
#define LEAF2_H_

#include <ostream>
// DO NOT REMOVE THE LINE BELOW
/* CMSC341_TEST_INCLUDES */


struct Leaf
{
    // DO NOT REMOVE THE LINE BELOW
    /* CMSC341_FRIEND_CLASSES */

    Leaf()
        : m_Count(1)
    {
    }

    unsigned short getValue() const { return m_Value; }
    void setValue(unsigned short value) { m_Value = value; }

    unsigned short getCount() const { return m_Count; }
    void setCount(unsigned short count) { m_Count = count; }
    void incrementCount() { m_Count++; }
    void decrementCount() { m_Count--; }

    Leaf *getNext() const { return m_Next; }
    void setNext(Leaf *next) { m_Next = next; }

    /**
     * @brief Operator overload to print the Leaf in a nice format According to
     * the project description the format should be "value:count"
     *
     * @param out
     * @param leaf
     * @return std::ostream&
     */
    friend std::ostream &operator<<(std::ostream &out, const Leaf &leaf)
    {
        out << leaf.m_Value << ":" << leaf.m_Count;
        return out;
    }

private:
    unsigned short m_Value;
    unsigned short m_Count;
    Leaf *m_Next;
};
#endif /* LEAF2_H_ */

The input file is a .txt file with the following values:

1
10
22
13
8
23

I get the error even if I turn everything after the "add term" call into a comment, and I know the leaf portion isn't working because when I run the "findSmallestTerm" and "findLargestTerm" it only gives me the stem value. There's a lot wrong with my code beyond just the error with the leaf values but I'm not asking for the answer to the whole project, I just need help on getting the stem and leaf lists to connect, if that makes sense. Sorry to just dump all of the code here, but I don't know which part of it is the problem so I didn't know what would be relevant or not.

UPDATE: I deleted some of the unnecessary code and added the info for the input file.

Answer 1

The crash is caused by uninitialized data members and wrong check statements:

if(FRONT_ptr = NULL)

This should be:

if(FRONT_ptr == NULL)

Stem::m_Next should be inited:

Stem *m_Next=NULL;

Stem::m_Next should be inited:

Leaf *m_Next=NULL;

The variable Prev should be inited after entering the for loop:

void addTerm(unsigned short term) {
    // Prev should be inited or the crash happens
    for (Prev = Cursor, Cursor = FRONT_ptr; Cursor != NULL;
         Prev = Cursor, Cursor = Cursor->getNext()) {
}
}

The Stem class should have destructors to avoid memory leak:

virtual ~Stem() {
  while (FRONT_ptr != NULL) {
    Cursor = FRONT_ptr;
    FRONT_ptr = Cursor->getNext();
    delete Cursor;
  }
};

The code also have other some bad smell and bugs:

• Temporary variables should not be data members: INsert, Prev, Cursor
• Stem::Insert , StemAndLeaf::Insert have memory leaks when the data have existed in the list, the new elements haven't been inserted into the list, the pointer should be deleted
• Forget to check if pointer is NULL before accessing it: getSmallestTerm , getLargestTerm