Creating instances for a linked list class in C++ - c++

Question

I am currently learning C++ linked list and I hit this piece of code from the textbook.I have trouble understanding this:
const string& e
I am trying to write some instances for this class in my main function to see how things works but don't know how.
For example, I want to add 3, 5, 7 to the list and add 1 to the front of the list, than delete 7 from the list.
#include <cstdlib>
#include <iostream>
#include <string>
using std::string;
using namespace std;
class StringNode { // a node in a list of strings
private:
string elem; // element value
StringNode* next; // next item in the list
friend class StringLinkedList; // provide StringLinkedList
// access
};
class StringLinkedList { // a linked list of strings
public:
StringLinkedList(); // empty list constructor
~StringLinkedList(); // destructor
bool empty() const; // is list empty?
const string& front() const; // get front element
void addFront(const string& e); // add to front of list
void removeFront(); // remove front item list
private:
StringNode* head; // pointer to the head of list
};
StringLinkedList::StringLinkedList() // constructor
: head(NULL) { }
StringLinkedList::~StringLinkedList() // destructor
{ while (!empty()) removeFront(); }
bool StringLinkedList::empty() const // is list empty?
{ return head == NULL; }
const string& StringLinkedList::front() const // get front element
{ return head->elem; }
void StringLinkedList::addFront(const string& e) { // add to front of list
StringNode* v = new StringNode; // create new node
v->elem = e; // store data
v->next = head; // head now follows v
head = v; // v is now the head
}
void StringLinkedList::removeFront() { // remove front item
StringNode* old = head; // save current head
head = old->next; // skip over old head
delete old; // delete the old head
}

Answer 1

I tried to look for a duplicate which explains how C++ uses call-by-value.
In C++ a function parameter of type T will make a copy of the object before the function is called.
int myFunction( int value )
{
value = value + 1;
}
int main( int argc, char * argv[] )
{
int elem = 6;
myFunction( elem );
printf( "%d\n", elem ); // elem = 6;
}
In the above example a copy is made of the int value, which is sent to myFunction, and the copy is incremented.
This may not be what is wanted, and we can change the result to 7, by modifying myFunction to take a reference to the value. This is done by using the '&' to describe a reference value.
int myFunction( int & value )
{
value = value + 1;
}
int main( int argc, char * argv[] )
{
int elem = 6;
myFunction( elem );
printf( "%d\n", elem ); // elem = 7;
}
In the above case, no copy is made, and elem gets updated.
There are 2 main reasons you pass references to a function
To allow the value (or object) to be updated.
To avoid the cost of copying the value.
In your quoted example the second case is why the const string & is used (reference to string object). std::string, has costs to construct and destroy, so by sending a reference to avoid this, is more efficient.
To compliment this usage, the reference, is usually made const to convince the compiler that the value should not be changed.