Question

Data Structure in C++

I keep getting the same warning, and I cant seem to fix it.. Can you explain to me what I am doing wrong?

Warning:

dlist.cc: In function 'std::ostream& operator<<(std::ostream&, dlist&)':
dlist.cc:66:10: error: invalid initialization of reference of type 'std::ostream& {aka std::basic_ostream&}' from expression of type 'dlist::node*'
dlist.cc: In function 'dlist operator+(dlist&, dlist&)':
dlist.cc:93:8: error: invalid operands of types 'dlist::node*' and 'dlist::node*' to binary 'operator+'
dlist.cc:97:8: error: could not convert 'result' from 'int' to 'dlist'

My code:

#include "dlist.h"

dlist::node*dlist::at(int n){

        node*current = head();

        while(n != 0){

                current= current->next;

                n--;

        }

        return current;

}

void dlist::insert(node *previous, int value){

        node*n = new node{value, previous -> next,previous};

        previous -> next = n;

}

void dlist::del(node* which){

        node*c= which -> next;

        which -> next = which-> next-> next;

        delete c;

}

void dlist::push_back(int value){

        node*c = tail();

        insert(c,value);

}

void dlist::push_front(int value){

        insert(head(), value);

}

void dlist::pop_front(){

        node*n = head();

        n = head() -> next;

        delete n;

}

void dlist::pop_back(){

        node*n = tail();

        n = tail() -> prev;

        delete n;

}

int dlist::size(){

        node*c = head();

        int s = 0;

        while(c){

                c = c -> next;

                s++;

        }

        return s;

}

bool dlist::empty(){

        if(size() == 0)

                return true;

        else

                return false;

}

std::ostream& operator<< (std::ostream& out, dlist& l){

        dlist::node*c = l.head();

        while(true){

                out << c;

                c = c-> next;

                return c;

        }

}

bool operator== (dlist& a, dlist& b){

        dlist::node* ca = a.head();

        dlist::node* cb = b.head();

        while(ca&&cb){

                if(ca-> next != cb->next)

                        return false;

                else{

                        ca = ca->next;

                        cb = cb->next;

                }

        }

                if(ca== nullptr && cb == nullptr)

                                return true;

                else

                        return false;

}

dlist operator+ (dlist& a, dlist& b){

        dlist::node* ca = a.head();

        dlist::node* cb = b.head();

        int result;

        while(ca&&cb){

                ca + cb = result;

                ca = ca -> next;

                cb = cb -> next;

        }

return result;

}

dlist reverse(dlist& l){

        dlist l2;

        dlist::node* c = l.head();

        while(c->next!=l.tail()){

                l2.push_front(c->next->value);

                c = c-> next;

        }

return l2;

}

"dlist.h"

#pragma once
/*
  dlist.h
  Doubly-linked lists of ints
 */
#include 

class dlist {
  public:
    dlist() { }

    // Implement the destructor, to delete all the nodes
    ~dlist();

    struct node {
        int value;
        node* next;
        node* prev;
    };

    node* head() const { return _head; }
    node* tail() const { return _tail; }

    // **** Implement ALL the following methods ****

    // Returns the node at a particular index (0 is the head).
    node* at(int);

    // Insert a new value, after an existing one
    void insert(node *previous, int value);

    // Delete the given node
    void del(node* which);

    // Add a new element to the *end* of the list
    void push_back(int value);

    // Add a new element to the *beginning* of the list
    void push_front(int value);

    // Remove the first element
    void pop_front();

    // Remove the last element
    void pop_back();

    // Get the size of the list
    int size();

    // Returns true if the list is empty (size == 0)
    bool empty();

  private:
    node* _head = nullptr;
    node* _tail = nullptr;
};

// **** Implement ALL the following functions ****

/* out << l
   Prints a list to the ostream out. This is mostly for your convenience in
   testing your code; it's much easier to figure out what's going on if you
   can easily print out lists!
*/
std::ostream& operator<< (std::ostream& out, dlist& l);

/* a == b
   Compares two lists for equality, returning true if they have the same
   elements in the same positions. (Hint: it is *not* enough to just compare
   pointers! You have to compare the values stored in the nodes.)
*/ 
bool operator== (dlist& a, dlist& b);

/* a + b
   Returns a new list consisting of all the elements of a, followed by all the
   elements of b (i.e., the list concatenation).
*/
dlist operator+ (dlist& a, dlist& b);

/* reverse(l)
   Returns a new list that is the *reversal* of l; that is, a new list 
   containing the same elements as l but in the reverse order.
*/
dlist reverse(dlist& l);

​

Answer 1

See , what is needed first

   Returns a new list consisting of all the elements of a, followed by all the

   elements of b (i.e., the list concatenation).

the list concatenation : Iterate the first list then again iterate the secodn list , So resultant list will have 2n lements if both the list are of length n

dlist operator+ (dlist& a, dlist& b){

        dlist::node* ca = a.head();

        dlist::node* cb = b.head();

        int result;

        while(ca&&cb){

                ca + cb = result; ///Error , because u cannot add two address as well as you are assigning integer to it

                ca = ca -> next;

                cb = cb -> next;

        }

return result; //Wrong , result is integer and return type is dlist

}

===========================================================================

How to solve it :

  
Algorithm
dlist::node* result = nullptr;

while(a ) {
insert (result , a->data );
a =. a->next;
}
while(b ) {
insert (result , b->data );
b =. b->next;
}

return result;

Do in this way, It will work ..You just need to attach all the nodes of a and b to result ,

Eg : if a contains 2,3,4,5 , , , if b contains 6,7,8, 9, ,
Then result should contain 2,3,4,5,6,7,8 , , ,


Thanks, let me know if there is any concern.