class template question

[AeonFlux1212]

Hi! I'm wondering what should be the syntax for this:

#include "functions.h"
#include "enums.h"

enum direction
{
    southeast = 1,
    east = 2,
    northeast = 3,
    northwest = 4,
    west = 5,
    southwest = 6
};

enum position
{
    first,
    last
};

enum coord
{
    x,
    y
};

template<class T> class list;
class dot_cell;

class dot
{
    long double x, y;

  public:
    long double& get_x() return x;
    long double& get_y() return y;
};

class line
{
    friend class dot_cell;

    dot first, last;
};

class dot_cell
{
    friend template<class T> class list<T>;

    line southeast;
    line east;
    line northeast;
    line northwest;
    line west;
    line southwest;

    dot center;

    unsigned long long identifier;

  public:
    long double& get_dot(direction p_direction, position p_pos, coord p_coord)
    {
         if(p_direction == southeast)
         {
              if(p_pos == first)
              {
                   if(p_coord == x) return southeast.first.get_x();
                   else return southeast.first.get_y();
              }
              else
              {
                   if(p_coord == x) return southeast.last.get_x();
                   else return southeast.last.get_y();              }
         }
         else if(p_direction == east)
         {
              if(p_pos == first)
              {
                   if(p_coord == x) return east.first.get_x();
                   else return east.first.get_y();
              }
              else
              {
                   if(p_coord == x) return east.last.get_x();
                   else return east.last.get_y();              }
         }
         else if(p_direction == northeast)
         {
              if(p_pos == first)
              {
                   if(p_coord == x) return northeast.first.get_x();
                   else return northeast.first.get_y();
              }
              else
              {
                   if(p_coord == x) return northeast.last.get_x();
                   else return northeast.last.get_y();
              }
         }
         else if(p_direction == northwest)
         {
              if(p_pos == first)
              {
                   if(p_coord == x) return northwest.first.get_x();
                   else return northwest.first.get_y();
              }
              else
              {
                   if(p_coord == x) return northwest.last.get_x();
                   else return northwest.last.get_y();
              }
         }
         else if(p_direction == west)
         {
              if(p_pos == first)
              {
                   if(p_coord == x) return west.first.get_x();
                   else return west.first.get_y();
              }
              else
              {
                   if(p_coord == x) return west.last.get_x();
                   else return west.last.get_y();
              }
         }
         else if(p_direction == southwest)
         {
              if(p_pos == first)
              {
                   if(p_coord == x) return southwest.first.get_x();
                   else return southwest.first.get_y();
              }
              else
              {
                   if(p_coord == x) return southwest.last.get_x();
                   else return southwest.last.get_y();
              }
         }
    }
};

template<class T> class node
{
    friend template<class T> class list<T>;

    T data;
    unsigned short layer;

    node<T>* prev;
    node<T>* next;

    node<T>* east;
    node<T>* northeast;
    node<T>* northwest;
    node<T>* west;
    node<T>* southwest;
    node<T>* southeast;

  public:
    node<T>()
    {
         prev = NULL;
         next = NULL;

         east = NULL;
         northeast = NULL;
         northwest = NULL;
         west = NULL;
         southwest = NULL;
         southeast =  NULL;
    }

    void set_value(T);
    void init_layer(unsigned int);
};

class cell
{
    terrain_type terrain;
    char hill_forest_jungle_lake;
};

template<class T> class list
{
    node<T>* tail;

    unsigned int number_of_elements;
    unsigned short number_of_layers;

  public:
    list<T>()
    {
         tail = NULL;

         number_of_elements = 0;
         number_of_layers = 0;
    }

    void add_node(T);
    void add_node(node<T>);

    void set_cardinal_coordinates();
};
/*
void node<T>::set_value(T value) data = value;
void node<T>::init_layer(unsigned int number_of_elements)
{
     unsigned short layer = 0;

     while(layer
}

void list<T>::add_node(T param)
{
    node<T>* new_node= new node<T>;
    new_node->set_value(param);

    new_node

     if(!tail)
     {
          tail = new_node;
          return;
     }

     node<T>* current_node = tail;

     while(current_node)
     {
          if(current_node->next == NULL)
          {
               current_node->next = new_node;
               new_node->prev = current_node;
          }

          current_node = current_node->next;
     }

    number_of_elements++;
}

void list<T>::add_node(node<T> object)
{
     node<T>* newNode = new node<T>;
     *newNode = object;

     if(!tail)
     {
          tail = newNode;
          return;
     }

     node<T>* current_node = tail;

     while(current_node)
     {
          if(current_node->next == NULL)
          {
               current_node->next = newNode;
               newNode->prev = current_node;
          }

          current_node = current_node->next;
     }

    number_of_elements++;
} 

template<class T>
void list<T>::set_cardinal_coordinates()
{
    list<dot_cell> dot_cell_list;

    dot_cell first_dot_cell;

    first_dot_cell->southeast->first->x = 0;
    first_dot_cell->southeast->first->y = 0;
    first_dot_cell->southeast->last->x = 1;
    first_dot_cell->southeast->last->y = 0;

    first_dot_cell->east->first->x = first_dot_cell->southeast->last->x;
    first_dot_cell->east->first->y = first_dot_cell->southeast->last->y;
    first_dot_cell->east->last->x = first_dot_cell->east->first->x + cos(60);
    first_dot_cell->east->last->y = first_dot_cell->southeast->last->y + sin(60);

    first_dot_cell->northeast->first->x;
    first_dot_cell->northeast->first->y;
    first_dot_cell->northeast->last->x;
    first_dot_cell->northeast->last->y;

    first_dot_cell->northwest->first->x;
    first_dot_cell->northwest->first->y;
    first_dot_cell->northwest->last->x;
    first_dot_cell->northwest->last->y;

    first_dot_cell->west->first->x;
    first_dot_cell->west->first->y;
    first_dot_cell->west->last->x;
    first_dot_cell->west->last->y;

    first_dot_cell->southwest->first->x;
    first_dot_cell->southwest->first->y;
    first_dot_cell->southwest->last->x;
    first_dot_cell->southwest->last->y;

    for(unsigned long long i = 0; i < number_of_elements; i++)
    {
        dot_cell actual_cell;

        line* southeast;
        line* east;
        line* northeast;
        line* northwest;
        line* west;
        line* southwest;
    }
}
*/

int main()
{
dot_cell tail;


}

It'll be some sort of linked list when I'm done, but I'm wondering if this is the right syntax for using a node that has the same template parameter as the list AND to be able to declare list<type> myList;... is there some scope operator to be used when declaring templates?

Also, can you declare template<struct T> instead?

Thanks a lot!!
AeonFlux