Question

Please show me how to overload the operators << and >>

#ifndef LINK_LIST
#define LINK_LIST

#include <iostream>
using namespace std;

template <typename T>
struct Int_Node
{
   T value;
   Int_Node<T> *pre, *next;
};

template <typename T>
class Link_List
{
   template <typename U>
   friend ostream &operator<<(ostream &, const Link_List<U> &);// print all integers in the list
   template <typename U>
   friend istream &operator>>(istream &, Link_List<U> &);// input a value at the back of the list, like insert_node(val);

public:
   Link_List();// default constructor
   Link_List(const Link_List &);// copy constructor
   ~Link_List();
   int getSize() const;
  
   const Link_List &operator=(const Link_List &);// assignment operator
   bool operator==(const Link_List &right) const// equality operator
   {
       return (*this == right);
   }
   bool operator!=(const Link_List &right) const// inequality operator
   {
       return !(*this == right);
   }

   T &operator[](int index);// subscript operator for non-const objects
   T operator[](int index) const;// subscript operator for const objects

   bool insert_node(T value);// insert an integer at the back of link list
   bool delete_node();// delete the last node
   bool insert_node(int index, T value);// insert an integer after the i_th position
   bool delete_node(int index);// delete the i_th node

private:
   int size;
   Int_Node<T> *head, *tail;// pointer to the first and the last element of Link_List
};

#endif

Answer 1

template <typename U> friend ostream &operator<<(ostream &os, const Link_List<U> &Obj)// print all integers in the list {    Int_Node<U>*Temp = Obj.head;    os << "Current List : ";    while (Temp != NULL)    {        os << Temp->value << " ";        Temp = Temp->next;    }    os << endl;    return os; } template <typename U> friend istream &operator>>(istream &is, Link_List<U> &Obj)// input a value at the back of the list, like insert_node(val) {    U val;    cout << "Enter Value: ";    is >> val;    Obj.insert_node(val);    return is; }

#pragma once #include"Node.h" #include<iostream> using namespace std; template <typename T> class LinkedList // LinkedList Using Head And Tail. { private:    // Top / Front / Head.    Node<T>*Head;    // Tail / Back / Current.    Node<T>*Current;    // Set Head As It Is A Private Member.    void SetHead(Node<T> *Val) { this->Head = Val; }    // Set Tail As It Is A Private Member.    void SetCurrent(Node<T> *Val) { this->Current = Val; }    // Get Head As It Is A Private Member.    Node<T>* GetHead() { return this->Head; }    // Get Tail As It Is A Private Member.    Node<T>* GetCurrent() { return this->Current; } public:    // Constructor Sets Head And Tail To Null.    LinkedList() { SetHead(NULL); SetCurrent(NULL); }    // Copy Constructor.    LinkedList(LinkedList &obj) // Yes , I Googled This! , Used To Make A New Copy Of Linked List When Passing It To A Function Without Reference So The Orignal List Is Does Not Get Deleted!.    {        Node<T>dummy;        for (Node<T>* o = obj.GetHead(), *n = &dummy; o; o = o->GetNext())        {            n->SetNext(new Node<T>(o->GetData()));            n = n->GetNext();        }        this->Head = dummy.GetNext();    }    // Returns If List Is Empty Or Not.    bool IsEmptyList() { if (GetHead() == NULL) return true; return false; }    // Returns The Data Of Current List From Head.    T GetHeadData() { return GetHead()->GetData(); }    // Returns The Data Of Current List From Tail.    T GetTailData() { return GetCurrent()->GetData(); }    // Prints The Current List From Head To Tail.    void Print()    {        Node<T>*Temp = GetHead();        cout << "Current List : ";        while (Temp != NULL)        {            cout << Temp->GetData() << " ";            Temp = Temp->GetNext();        }        cout << endl;    }    // Inserts The New Value At Head.    void InsertAtHead(int Val)    {        Node<T>*Temp = new Node<T>;        Temp->SetData(Val);        Temp->SetNext(this->Head);        if (GetHead() == NULL)        {            SetHead(Temp);            SetCurrent(Head);        }        else        {            Temp->SetNext(GetHead());            SetHead(Temp);        }    }    // Inserts The New Value At Tail.    void InsertAtTail(T Val)    {        Node<T>*Temp = new Node<T>;        Temp->SetData(Val);        Temp->SetNext(NULL);        if (Head == NULL)        {            SetHead(Temp);            SetCurrent(Head);        }        else        {            GetCurrent()->SetNext(Temp);            SetCurrent(Temp);        }    }    // Deletes The Value At Head.    void DeleteFromHead()    {        if (!IsEmptyList())        {            if (GetHead()->GetNext() != NULL)            {                Node<T>*Temp = GetHead();                SetHead(GetHead()->GetNext());                delete Temp;            }            else            {                Node<T>*Temp = GetHead();                delete Temp;                SetHead(NULL);            }        }      }    // Deletes The Value At Tail.    void DeleteFromTail()    {        if (!IsEmptyList())        {            SetCurrent(GetHead());            if (GetCurrent() == GetHead() && GetCurrent()->GetNext() == NULL)            {                delete GetCurrent();                SetHead(NULL);            }            else            {                while (GetCurrent()->GetNext()->GetNext() != NULL)                {                    SetCurrent(GetCurrent()->GetNext());                }                delete GetCurrent()->GetNext();                GetCurrent()->SetNext(NULL);            }        }    }    // Searches The List For A Value, And Returns The Address Of Node Which Contains The Value.    Node<T>* Search(T Val)    {        SetCurrent(GetHead());        if (IsEmptyList()) return NULL;        else        {            while (GetCurrent() != NULL)            {                if (GetCurrent()->GetData() == Val) return GetCurrent();                SetCurrent(GetCurrent()->GetNext());            }            return NULL;        }    }    // Insert A Value, After A Specific Value.    void InsertAfter(T Check, T Val)    {        SetCurrent(GetHead());        Node<T>* Ptr = Search(Check);        if (!Ptr) cout << "Value Not Found!" << endl;        else        {            Node<T>* Temp = new Node<T>;            Temp->SetData(Val);            Temp->SetNext(Ptr->GetNext());            Ptr->SetNext(Temp);        }    }    // Insert A Value, Before A Specific Value.    void InsertBefore(T Check, T Val)    {        SetCurrent(GetHead());        Node<T>* Ptr = Search(Check);        if (!Ptr) cout << "Value Not Found!" << endl;        else        {            Node<T>* Temp = new Node<T>;            Temp->SetData(Ptr->GetData());            Ptr->SetData(Val);            Temp->SetNext(Ptr->GetNext());            Ptr->SetNext(Temp);        }    }      // Sorts The List Value By Value In Descending, Not Node By Node, Until The List Is Fully In Order.    void SortDescending()    {        Node<T>* Temp;        bool Swap = true;        while(Swap)        {            Swap = false;            SetCurrent(Head);            while (GetCurrent())            {                Temp = GetCurrent();                SetCurrent(GetCurrent()->GetNext());                if (GetCurrent() && Current->GetData() > Temp->GetData())                {                    Swap = true;                    T Val;                    Val = Temp->GetData();                    Temp->SetData(GetCurrent()->GetData());                    GetCurrent()->SetData(Val);                }            }        }    }    // Sorts The List Value By Value In Ascending, Not Node By Node, Until The List Is Fully In Order.    void SortAscending()    {        Node<T>* Temp;        bool Swap = true;        while (Swap)        {            Swap = false;            SetCurrent(Head);            while (GetCurrent())            {                Temp = GetCurrent();                SetCurrent(GetCurrent()->GetNext());                if (GetCurrent() && Current->GetData() < Temp->GetData())                {                    Swap = true;                    T Val;                    Val = Temp->GetData();                    Temp->SetData(GetCurrent()->GetData());                    GetCurrent()->SetData(Val);                }            }        }    }    // Default Destructor.    ~LinkedList() = default; };

#pragma once template <typename T> class Node { private:    T Data;    Node* Next; public:    T GetData() { return this->Data; }    void SetData(T Val) { this->Data = Val; }    Node* GetNext() { return this->Next; }    void SetNext(Node* Val) { this->Next = Val; }    // SetData Cannot Be NULL For Some Structs, So Remove This Statement.    Node() { this->SetData(NULL); this->SetNext(NULL); }    Node(T Val) { this->SetData(Val); }    ~Node() = default; };

IF THERE IS ANY PROBLEM OR YOU HAVE ANY QUERY REGARDING THE SOLUTION KINDLY FEEL FREE TO ASK, AND LEAVE A THUMBS UP WHEN YOU ARE SATISFIED. THANKS!.