How to access private data member in C++ Class

I have a question about how to access private data members from another c++ class in a program I am writing. Up front, my question is: how can I access a private data member from outside of that class? All the code that I mention should be listed below, although much of the code for longint.cpp has not been implemented.

I have a class called "Deque" that represents a double ended queue. This double ended queue is made using linked nodes that I call "DequeNode". Each "DequeNode" has the private data members of a next and prev pointer as well as a variable to store a value/item. I have tested the deque.cpp and deque.h files with a driver I wrote and they are working as intended.

I want to make a class called LongInt, that presents an integer. A LongInt is supposed to represent an integer value that cannot be stored in an int variable. A LongInt has three private data members, a Deque object called digits, a bool value to determine if the value being stored in a LongInt is negative or positive, and a function to remove extra 0's at the front of the LongInt object.

I am having trouble writing an output function for the LongInt class. The output function for LongInt should print out all the values of all the nodes of its Deque object. My question is: how am I be able to access the Deque object called "digits" from the output function located in longint.cpp? Specifically, the operator<< function.

Below is the code for the files: deque.h, deque.cpp, longint.h, and longint.cpp.

deque.h:

#ifndef DEQUE_H
#define DEQUE_H
#include <iostream>

using namespace std;

template <class Object>
class Deque {
 public:
  Deque( );                                   // the constructor
  Deque( const Deque &rhs );                  // the copy constructor
  ~Deque( );                                  // the destructor

  bool isEmpty() const;                      // checks if a deque is empty.
  int size() const;                          // retrieves # deque nodes
  const Object &getFront() const;            // retrieve the front node
  const Object &getBack() const;             // retrieve the tail node

  void clear();                              // clean up all deque entries.
  void addFront( const Object &obj );         // add a new node to the front
  void addBack( const Object &obj );          // add a new node to the tail
  Object removeFront( );                      // remove the front node
  Object removeBack( );                       // remove the tail node

  const Deque &operator=( const Deque &rhs ); // assignment

 private:
  struct DequeNode {                          // a deque node
    Object item;
    DequeNode *next;
    DequeNode *prev;
  };
  DequeNode *front;
  DequeNode *back;
};

#include "deque.cpp"
#endif

deque.cpp:

template <class Object>
Deque<Object>::Deque() {                          // the constructor
  front = back = NULL;
}

template <class Object>
Deque<Object>::Deque(const Deque &rhs) {         // the copy constructor
  front = back = NULL;
  *this = rhs;
}

template <class Object>
Deque<Object>::~Deque() {                         // the destructor
  clear();
}

template <class Object>
bool Deque<Object>::isEmpty() const {             // check if a deque is empty
  return front == NULL;
}

template <class Object>
int Deque<Object>::size() const {                 // retrieves # deque nodes
  int i = 0;
  for ( DequeNode *ptr = front; ptr != NULL; ptr = ptr->next ) // traverse que
    ++i;

  return i;
}

template <class Object>
const Object &Deque<Object>::getFront() const {   // retrieve the front node
  if (isEmpty())
    throw "empty queue";
  return front->item;
}

template <class Object>
const Object &Deque<Object>::getBack() const {    // retrieve the tail node
  if (isEmpty())
    throw "empty queue";
  return back->item;
}

template <class Object>
void Deque<Object>::clear() {          // clean up all entries.
  while (!isEmpty())                 // dequeue till the queue gets empty.
    removeFront();
}
// add a new node to front
template <class Object>
void Deque<Object>::addFront(const Object &obj){

  DequeNode *new_node = new DequeNode;

  new_node->prev = NULL;
  new_node->next = front;
  new_node->item = obj;

//Checking for the edge case where we have no nodes
  if (front == NULL){  //If we have no nodes, both front and back get set to the only node.
    back = new_node;
    front = new_node;
  }
  else{ //Else, everything else is handled by this
    front->prev = new_node;
    front = new_node;
  }
}

// add a new node to tail
template <class Object>
void Deque<Object>::addBack(const Object &obj){

  DequeNode *new_node = new DequeNode;
  
  new_node->prev = back;
  new_node->next = NULL;
  new_node->item = obj;
  
//Checking for the edge case where we have no nodes
  if (back==NULL){ //If we have no nodes, both front and back get set to the only node.
    front = new_node;
    back = new_node;
  }
  else{ //Else, everything else is handled by this
    back->next = new_node;
    back = new_node;
  }
}

template <class Object>
Object Deque<Object>::removeFront(){  //remove the front node

  DequeNode *pos = front; //create a pointer to keep track of node to be deleted

  //Need to find a way to access the item being help at the location of front.
  Object removedItem = pos->item;

  if(front == back){ //Case for when there is only a single node left in the Queue.
    front = NULL;
    back = NULL;
  }
  else{ //All other cases should fall into this else statement
    front->next->prev = NULL;
    //front->next = NULL;
    front = front->next;
  }

  delete pos;

  return removedItem;
}

template <class Object>
Object Deque<Object>::removeBack(){   // remove the tail node

  DequeNode *pos = back; //create a pointer to keep track of node to be deleted

  //Need to find a way to access the item being help at the location of front.
  Object removedItem = pos->item;

  if(front==back){
    front = NULL;
    back = NULL;
  }
  else{
    back->prev->next = NULL;
    back = back->prev;
  }

  delete pos;
  return removedItem;
}

template <class Object>
const Deque<Object> &Deque<Object>::operator=(const Deque &rhs) { // assign
  if (this != &rhs) { // avoid self assignment
    clear();
    for (DequeNode *rptr = rhs.front; rptr != NULL; rptr = rptr->next)
      addBack(rptr->item);
  }
  return *this;
}

longint.h:

#ifndef LONGINT_H
#define LONGINT_H
#include <iostream>
#include "deque.h"

using namespace std;

class LongInt {
  friend istream &operator>>(istream &in, LongInt &rhs);
  friend ostream &operator<<(ostream &out, const LongInt &rhs);
 public:
  // Constructors
  LongInt(const string str); 
  LongInt(const LongInt &rhs);
  LongInt();

  // Destructor
  ~LongInt();

  // Arithmetic binary operators
  LongInt operator+(const LongInt &rhs) const;
  LongInt operator-(const LongInt &rhs) const;

  // assignment operators
  const LongInt &operator=(const LongInt &rhs);

  // Logical binary operators
  bool operator< (const LongInt & rhs) const;
  bool operator<=(const LongInt & rhs) const;
  bool operator> (const LongInt & rhs) const;
  bool operator>=(const LongInt & rhs) const;
  bool operator==(const LongInt & rhs) const;
  bool operator!=(const LongInt & rhs) const;

 private:
  Deque<char> digits;
  bool negative;
  void remove0s();
};

#endif

longint.cpp:

#include "longint.h"

//istream &operator>>(istream &in, LongInt &rhs){
  //return in;
//}

ostream &operator<<(ostream &out, const LongInt &rhs){
  cout << << endl;
  return out;
}




//Constructors
//LongInt::LongInt(const string str)
//LongInt::LongInt(const LongInt &rhs)

LongInt::LongInt(){
  digits.addBack(0);
  negative = false;
}

// Destructor
LongInt::~LongInt(){

  
}

// Arithmetic binary operators
//LongInt operator+(const LongInt &rhs) const;
//LongInt operator-(const LongInt &rhs) const;

// assignment operators
//const LongInt &operator=(const LongInt &rhs);

// Logical binary operators
//bool operator< (const LongInt & rhs) const;
//bool operator<=(const LongInt & rhs) const;
//bool operator> (const LongInt & rhs) const;
//bool operator>=(const LongInt & rhs) const;
//bool operator==(const LongInt & rhs) const;
//bool operator!=(const LongInt & rhs) const;