1. Si creas un elemento nuevo no tiene sentido que, este elemento cree otro nuevo, porque este a su vez creará otro nuevo y así hasta el infinito:

   LinkList(int t =0) :dat(t)
   {
         nxt = new LinkList(0);
   }

Lo suyo es que, en este caso, "nxt" no apunte a ningún sitio:

   LinkList(int t =0) :dat(t), nxt(0)
   {
   }

2. También tienes un fallo en el método "add":

   void add(LinkList *ll,int d){
      nxt = ll;
      dat =d;
   }
 

Si añades un elemento no debes modificar el valor del elemento actual, sino añadir un elemento nuevo. ¿Qué sucede si nxt ya apuntaba a un elemento válido? crearás lagunas de memoria y perderás información.

Lo suyo sería que add recibese únicamente uno de los dos parámetros que recibe actualmente, ya que un objeto de tipo LinkList ya tiene el valor que facilitas en 'd':

* Si pasas un objeto de tipo LinkList, la idea es buscar el lugar correcto para insertar el elemento. En este caso 'd' te sobra

* Si pasas el valor de 'd', creas un objeto de tipo LinkList y lo insertas donde mejor te convenga.

3.Y, para terminar, comando "Print":

   void Print(){
      while(nxt != NULL)
      {
          cout <<"Dat Value : "<< dat<<std::endl;
          nxt = nxt->nxt;
 
      }    
   }
 

Si modificas la variable interna "nxt", vuelves a perder información. Si tienes X elementos en la lista y llamas a "Print", después de la llamada "nxt" va a valer 0... has perdido la lista!!!

4.Y, bueno, esto así a bote pronto. Si analizas un poco más en detalle tu código te darás cuenta de que es un poco bizarro. Resulta que LinkList no es realmente una lista enlazada, sino que además representa a cada nodo de la lista.... un poco raro.

Si tu idea es que LinkList represente una lista enlazada de enteros lo suyo sería, bien tener dos objetos diferentes (uno representa la lista y otro los nodos), bien hacer que los diferentes LinkList que van a estar en la lista aprendan a delegar unos de otros:

Opción 1: dos objetos:

#include <cstdlib>
#include <cstdlib>
#include <iostream>
 
using namespace std;
 
struct Node
{
    int value;
    Node* next;
 
    Node( int val )
      : value( val ),
        next( 0 )
    {
    }
 
    ~Node( )
    {
      delete next;
    }
};
 
class LinkList
{
   Node* _first;
 
  public:
 
  ~LinkList( )
  {
    delete _first;
  }
 
  LinkList( )
    : _first( 0 )
  {
  }
 
  void add( int d)
  {
    Node* newNode = new Node( d );
 
    if ( _first == 0 )
      _first = newNode;
    else
    {
      Node* last = _first;
 
      while( last->next )
        last = last->next;
 
      last->next = newNode;
    }
  }
 
  void Print( )
  {
    Node* node = _first;
    while( node != 0 )
    {
      cout <<"Dat Value : " << node->value << std::endl;
      node = node->next;
    }
  }
};
 
int main(int, char **)
{
   LinkList f;
   f.add(7);
   f.add(6);
   f.Print();
 
   system("PAUSE");
   return EXIT_SUCCESS;
}

Opción 2: Objetos enlazados:

#include <cstdlib>
#include <cstdlib>
#include <iostream>
 
using namespace std;
 
class LinkList
{
   LinkList* _next;
   int _value;
 
  public:
 
  ~LinkList( )
  {
    delete _next;
  }
 
  LinkList( int d )
    : _next( 0 ),
      _value( d )
  {
  }
 
  void add( int d )
  {
    if ( _next == 0 )
      _next = new LinkList( d );
    else
      _next->add( d );
  }
 
  void Print( )
  {
    std::cout << "Dat Value : " << _value << std::endl;
 
    if ( _next )
      _next->Print( );
  }
};
 
int main(int, char **)
{
   LinkList f(0);
   f.add(7);
   f.add(6);
   f.Print();
 
   system("PAUSE");
   return EXIT_SUCCESS;
}

Un saludo.

En este caso se supone que vas a crear una lista de elementos tal que (el número entre paréntesis es el valor de ese nodo):

LinkList(0) -> LinkList(10) -> LinkList(34) -> null

Entonces, si tu al primer elemento de la lista le dices que quieres añadir un nuevo valor, éste se ha de añadir al final de la lista. Lo que hace ese código es verificar si el elemento actual es el último de la lista, si es así añade el nuevo elemento a continuación, en caso contrario le pasa el valor al siguiente elemento de la lista... en algún momento un elemento será el final de la lista y el nuevo valor se insertará a continuación.

Es decir, suponiendo la lista que te he puesto antes, y yo llamo a LinkList(0)->add(2) se ejecutarán las siguientes acciones:

* LinkList(0)->_next, que es LinkList(10), no es nulo, por lo que realizo la llamada LinkList(0)->_next->add(10), es decir LinkList(10)->add(10)
* LinkList(10)->_next, que es LinkList(34), no es nulo, ejecuto por tanto LinkList(10)->_next->add(10), es decir, LinkList(34)->add(10)
* LinkList(34)->_next es nulo, por lo que voy a crear un nuevo elemento con valor 2 y hago que _next apunte a dicho elemento: LinkList(34)->_next = LinkList(2)


Como te he comentado, tienes una colección de objetos LinkList, de tal forma que el primero sabe llegar al segundo, el segundo al tercero y así. Si yo llamo al método "Print" de cualquiera de esos elementos puedo hacer dos cosas:

* Un bucle que recorra todos los elementos desde el actual hasta el final
* Presentar el valor actual y llamar al método "Print" del siguiente elemento (si existe)

En cualquiera de los dos casos se imprimirá la lista al completo. Intenta seguir el código haciéndote un esquema en papel. Te ayudará a entenderlo mejor.