Return a node class - c++

Question

My professor has asks us to reimplement all of the LinkedList functions from scratch. However, since this is a beginner class, he has put a few stipulations on it. Below is the full assignment:
"For list, you must implement everything but get_allocator. For all functions that take an "iterator" as an argument, instead accept a node class. For all functions that return an iterator, return a node instead."
Since LinkedList use pointers, I am not sure how to do return a node without just returning a pointer. What would be the syntax for returning a node pointed to by a pointer called *current?
I am also unsure how to format the functions. For example, what would be the syntax for changing the following function to accept a node class and then return a node(i don't need the code for the function, just how to accept a node and return a node class):
iterator insert (iterator position, const int&x)

Answer 1

"For list, you must implement everything but get_allocator. For all
functions that take an "iterator" as an argument, instead accept a
node class. For all functions that return an iterator, return a node
instead."
Since LinkedList use pointers, I am not sure how to do return a node
without just returning a pointer. What would be the syntax for
returning a node pointed to by a pointer called *current?
I think your professor is talking about accepting and returning pointers (or references) to nodes, not node values (copying nodes). I can say that with some degree of confidence because that's the only way to preserve the underlying semantics of std::list with a one-to-one translation of iterators to nodes (node pointers).
However, if your nodes are just mere aggregates storing pointers themselves and don't try to do any memory management, then you can get away with copying them around, but I'd go with pointers if in doubt.
So, something like this:
iterator insert(iterator position, const T& val)
{
...
}
Would look like this for your practice homework:
LinkedListNode* insert(LinkedListNode* position, const T& val)
{
...
}
If you aren't using templates and can just make it a list of integers or whatever:
LinkedListNode* insert(LinkedListNode* position, int val)
{
...
}
Hope later your professor will make you appreciate the power of the iterator-based versions as those allow you to write function templates that work not only on linked lists but any kind of sequence, for example.

Answer 2

I think you shouldn`t use pointers. Try to use reference or iterators?

Answer 3

To dereference a pointer, use the * operator. For example, if you have a valid pointer-to-int, and you want access to use the int that it points to:
*pointer_to_int = 5;
j = *pointer_to_int / 3;
and so forth. Similarly, if you want to pass the value of the pointed-to-int to a function,
k = SomeFunction(*pointer_to_int, 12, foo);
or return it from a function:
int Function() {
return *pointer_to_int;
}
You can use the syntax *pointer anywhere you might otherwise say, variable.
The syntax for declaring functions that return a type doesn't change based on the type. Suppose you have some function that returns an int:
int MyFunction() { return my_int; }
Or, if it returned an iterator:
iterator MyFunction() { return my_iterator; }
Or, if it returned an Apple:
Apple MyFunction() { return my_apple; }
You see, you just need to replace the name of the return type with whatever type you are returning.
Hopefully, you can see now how to declare a function that returns a node object, and how to return a node object, given that you only have a pointer_to_node.