Data structure in C++

I keep getting these warnings for my code..

dlist.cc: In member function 'void dlist::insert(dlist::node*, int)': dlist.cc:13:43: warning: missing initializer for member 'dlist::node::prev' [-Wmissing-field-initializers] dlist.cc: In member function 'void dlist::pop_front()': dlist.cc:33:21: error: lvalue required as left operand of assignment dlist.cc: In member function 'void dlist::pop_back()': dlist.cc:39:21: error: lvalue required as left operand of assignment dlist.cc: In member function 'bool dlist::empty()': dlist.cc:54:14: error: lvalue required as left operand of assignment dlist.cc: In function 'std::ostream& operator<<(std::ostream&, dlist&)': dlist.cc:65: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:94:16: error: invalid conversion from 'dlist::node*' to 'int' [-fpermissive] dlist.cc:96:8: error: 'result' was not declared in this scope dlist.cc:97:1: warning: control reaches end of non-void function [-Wreturn-type] dlist.cc: In function 'std::ostream& operator<<(std::ostream&, dlist&)': dlist.cc:68:1: warning: control reaches end of non-void function [-Wreturn-type] dlist.cc: In member function 'bool dlist::empty()': dlist.cc:58:1: warning: control reaches end of non-void function [-Wreturn-type]

I just dont know how to fix it. I would love explanations for the correction also. Thank you!!!

#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 -> next = n; }

void dlist::del(node* which){ node*c= which -> next; which -> next = which-> next-> next; delete c; }

void dlist::push_back(int value){ insert(tail(),value); }

void dlist::push_front(int value){ insert(head(), value); }

void dlist::pop_front(){ node*n = head(); head() = head() -> next; delete n; }

void dlist::pop_back(){ node*n = tail();

tail() = tail() -> prev; }

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(c){ 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(); while(ca&&cb){ int result; ca = ca -> next; cb = cb -> next; result= ca = cb; } return result; }

dlist reverse(dlist& l){ dlist l2;

dlist::node* c = l.head(); while(c){ l2.push_front(c->value); c = c-> next; } return l2; }

dlist.h

#pragma once

/* dlist.h Doubly-linked lists of ints */ #include class dlist { public: 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 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);