Doubly Linked List help

[kikiyox77]

Using Doubly linked list and I am gonna ask for help on one of the functions since I am completely stuck. I think I can get it down if I can get help with one of the functions I need to do for the Doubly linked list. Thanks in advance for the help :)

This is the DoublyList.h

(removed, DMCA)

This is the DoublyList.cpp:

(removed, DMCA)

So at the moment, this is how my Functions.cpp file looks like
Then this is the Functions.cpp:

#include "DoublyList.h"
#include <ostream>
using namespace std;

void DoublyList::insertInOrder(int insert)
{
	Node* current = first;
	Node* newNode = new Node(insert, nullptr, first);

	if (current == nullptr)
	{
		current = newNode;
		count = 1;
	}

	while (current != nullptr)
	{
		if (newNode->getData() > current->getData())
			current->setNext(newNode);
		else
			newNode->setNext(current);

		current = current->getNext();
		++count;
	}
}

So what the insertInOrder() function is suppose to do is whenever the function is called, there is an integer that gets inserted to the list from least to greatest:
Member function insertInOrder
Parameter: an integer to insert
Inserts the item in ascending order.

[gunnerfunner]

- use nullptr rather than NULL
- destroyList() can be replaced by ~DoublyList() outright
- a separate DoublyList::insertFront() breaks the list order, e.g.

1 -> 2 -> 3 -> 4//existing list
insertFront(7);
insertInOrder(6);//where does 6 go? before 7? after 4?  

unless insertFront() is followed by sorting the list which would be equivalent to insertInOrder() and so insertFront() is superflous

#include <iostream>
#include <random>
#include <vector>
#include <chrono>
#include <algorithm>

constexpr auto SIZE = 20;
constexpr auto low_bound = -500;
constexpr auto up_bound = 500;

struct Node
{
    int m_data = 0;
	Node* m_prev = nullptr;
	Node* m_next = nullptr;

	Node() {}
	Node (const int& data) : m_data (data){}
	Node(const int& data, Node* prev, Node* next)
		: m_data(data), m_prev(prev), m_next(next) {}
    ~Node() {std::cout << "Goodbye " << m_data << "\n";}
};

struct DoublyList
{
    size_t m_counter = 0;
    Node* m_first = nullptr;
    Node* m_last = nullptr;

    DoublyList(){}
    ~DoublyList();
    void insertInOrder(const int& data);
    void display()const;
};

int main()
{
    auto seed = std::chrono::system_clock::now().time_since_epoch().count();//seed
    std::default_random_engine dre(seed);//engine
    std::uniform_int_distribution<int> di(low_bound,up_bound);//distribution

    std::vector<int> data(SIZE);
    std::generate(data.begin(), data.end(), [&dre, &di]{ return di(dre);});
    //http://en.cppreference.com/w/cpp/algorithm/generate

    DoublyList dl{};
    for (const auto& elem : data)dl.insertInOrder(elem);
    dl.display();
}

void DoublyList::insertInOrder(const int& data)
{
    if(!m_first)//list is empty
    {
        Node* temp = new Node(data);
        m_first = m_last = temp;
        ++m_counter;
    }
    else
    {
        if(data <= m_first -> m_data)//data <= list first, so insert in front ...
        {
            Node* temp = new Node(data, nullptr, m_first);
            m_first -> m_prev = temp;
            m_first = temp;
            ++m_counter;
        }
        else //... else iterate through list to find where to insert data
        {
            Node* data_checker = m_first;
            bool inserted = false;
            while (data_checker -> m_next)
            {
                if(data <= data_checker -> m_next -> m_data)
                {
                    Node* temp = new Node(data, data_checker, data_checker -> m_next);

                    temp -> m_next -> m_prev = temp;
                    temp -> m_prev -> m_next = temp;
                    ++m_counter;
                    inserted = true;
                    break;
                }
                else
                {
                     data_checker = data_checker -> m_next;
                }
            }
            if (inserted == false)//reached list end w/o insert, so ...
            {
                Node* temp = new Node(data, m_last, nullptr);
                m_last -> m_next = temp;
                m_last = temp;
                ++m_counter;
             }
        }
    }
}
void DoublyList::display()const
{
    if (!m_first)
    {
        std::cout << "List empty, nothing to display \n";
    }
    else
    {
        Node* q = m_first;
        std::cout << "List with " << m_counter << " elements: \n";
        while(q)
        {
            std::cout << q -> m_data << " <-> ";
            q = q -> m_next;
        }
        std::cout << " NULL \n";
    }
}
DoublyList::~DoublyList ()
{
    Node* temp = m_first;
    while (temp)
    {
        Node* m_next = temp -> m_next;
        delete temp;
        temp = m_next;
    }
    m_first = nullptr;
    m_counter = 0;
}

[kikiyox77]

okay, so it somewhat works. So it is suppose to reads in the function everytime and it is called in the main function and checks to see if its the least or greatest. but then it only outputs one of the values and its the least one.

so it reads 37, 49, 18, 53, 21, 73
but it only prints out 18

it is suppose to print out 18, 21, 37, 49, 53, 73

but this is my code at the moment for the insertInOrder function:

void DoublyList::insertInOrder(const int& insert)
{
	Node* newNode = new Node(insert, nullptr, first);

	if (!first)
	{
		first = newNode;
		last = newNode;
		++count;
	}
	
	else
	{
		if (newNode->getData() <= first->getData())
		{
			newNode = first->getPrev();
			first = newNode;
			++count;
		}

		else 
		{
			Node* current = first;
			bool inserted = false;
			while (current->getNext())
			{
				if (insert <= current->getData())
				{
					Node* check = new Node(insert, current, current->getNext());
					check = check->getPrev()->getNext();
					++count;
				}
				current = current->getNext();
			}

			if (inserted)
			{
				Node* temp = new Node(insert, last, nullptr);
				temp = last->getNext();
				last = temp;
				++count;
			}
		}
	}
}

[kikiyox77]

I will also add in the print function to see if its right as well
its suppose to print:
18 21 37 49 53 73

void DoublyList::print():

void DoublyList::print() const
{
	Node* current = first;
	while (current != nullptr)
	{
		cout << current->getData() << " ";
		current = current->getNext();
	}
}

[gunnerfunner]

newNode = first->getPrev();
should be:
first->setPrev() = newNode
there are several other inconsistencies like an extra Node object declared on line 29 which keeps the object declared on line 3 unused, etc
suggest you at least try and understand my code properly, i.e. if you wish to utilize it of course, and then try and convert it to class-based from struct-based with accessors and mutators
as you're using the overloaded ctors you also need to make sure that the order of declaration and initializations are consistent