chaine.cpp

/*
[FR] Implementation du concept de Liste chaînée en C++ vue en cours
[ANG] Implementation of chain list concept in C++
@licence = GPL-3
@author = Dervaux Esteban
*/
#include <iostream>   // For std::cout & std::endl
#include <stdexcept>  // For std::runtime_error
#include <string>     // For std::string, std::to_string(), std::pop_back()
//#include <cassert>  // For check the code with some cases
using std::string;    // Shortcut for std::string to string

struct node {
    int value;
    node* previous;
    // Model of a constructor of an struct
    node(int val, node* prev) : value(val), previous(prev) {}
};

/* NodeChain is an node manager using none fixed memory bloc */
class NodeChain {
    private :
        unsigned int size; // Size of the chain
        node* sommet; // Pointer to an node at the first place of the chain
    public :
        /* ----- Main methods ----- */
        void pushNode(int value) {
            /* Insert new node in memory */
            sommet = new node(value, sommet);
            std::cout << "Added node with value: " << value << std::endl;
            size++;
        }

        void pullNode(const unsigned int index) {
            /* Pull a node from the chain using her index */
            if(index >= size) {
                throw std::runtime_error("IndexError, index >= size of the Chain, index = "+std::to_string(index)+", index need to be < size");
            }
            node* pulledNode = getByIndex(index);
            if (index == size-1) {
                // In cas we pulled the sommet
                sommet = sommet->previous; // Now the first element is the next one
            } else if (index == 0) {
                // In case we pulled the first element at index 0
                getByIndex(1)->previous = nullptr;
            } else {
                // In common case
                node* nextNode = getByIndex(index+1);
                node* previousNode = getByIndex(index-1);
                nextNode->previous = previousNode;
            }
            delete pulledNode; // Pull out the node from RAM
            size--; // Decrement size because we pulled an element     
        }

        node* getByIndex(unsigned int index) {
            /* Return an pointer of the node in the node chain at the index index*/
            node* actualNode = sommet;
            if(index >= size) {
                throw std::runtime_error("IndexError, index > size of the Chain, index = "+std::to_string(index));
            }
            
            for (size_t i = size-1; i > index; i--) {
                // We go back to the previous and set it the actual index time
                actualNode = actualNode->previous;
            };
            return actualNode; // Return result
        }

        /* ----- Chain representation methods ----- */
        string getChainToString() {
            /* Return the chain as a string */
            string chain = "[";
            if (size != 0) {
                node* actualNode = sommet;
                for (size_t i = size-1; i > 0; i--) {
                    chain += std::to_string(actualNode->value) + ", ";
                    actualNode = actualNode->previous;
                };
                chain.pop_back(), chain.pop_back();
            }
            return chain+"]"; // Return a chain like "[a, b, c, d]"
        }

        /* ----- Constructor and destructor ----- */
        NodeChain() {
            size = 0; // At the construction, the chain is empty
            sommet = nullptr;
        }
        ~NodeChain() {
            while (sommet != nullptr) {
                node* toDelete = sommet;
                    std::cout << "Delete sommet : " << sommet << std::endl;
                sommet = sommet->previous;
                delete toDelete;
            };
            delete sommet; // Enfin tue le sommet
            
        }
};

/* Test function for NodeChain*/
class TestNodeChain {
private:
    // Test getChainToString with empty chain
    int Test_emptyGetChainToString() {
        NodeChain lambdaChain;
        string result = lambdaChain.getChainToString();
        return (result == "[]") ? 0 : 1;
    }
    // Test push with some value
    int Test_pushNode() {
        NodeChain lambdaChain;
        lambdaChain.pushNode(10);
        lambdaChain.pushNode(0.5);
        return (lambdaChain.getChainToString() == "[10, 0.5]") ? 0 : 1;
    }


public:
    TestNodeChain() {
    };
    ~TestNodeChain(){};
};


int main(int argc, char const *argv[]) {
    NodeChain manage;
    std::cout << manage.getChainToString() << std::endl;
    manage.pushNode(10); // Create new node
    manage.pushNode(20); // Create new node
    manage.pushNode(30); // Create new node
    manage.pushNode(40); // Create new node
    std::cout << manage.getChainToString() << std::endl;
    manage.pullNode(1); // Deleted second node
    std::cout << manage.getChainToString() << std::endl;
    // "manage" stop being used so the deconstructor of NodeManager is call
    // All node's has been destroyed from the ram
    return 0;
}