Mensajes

El código por sí solo no hace nada... necesita ser convertido en código ejecutable para que la máquina sepa interpretar las órdenes (una excepción son los lenguajes interpretados como PERL, javascript o PHP, en este caso necesitas un intérprete que reconozca ese lenguaje y lo sepa procesar).

En cualquier caso, ese "using" me da a entender que el código que tienes entre manos no es C++, sino C#. C# pertenece a la plataforma .NET y no es directamente portable a C++ nativo, ya que las librerías son diferentes y en C# hay multitud de utilidades inexistentes en C++.

Entiendo que el archivo que tienes que abrir con Matlab es el binario que contiene la captura de kinect.

['d']

por que este codigo por ejemplo :

Código (cpp) [Seleccionar] Expandir


void add( int d )
  {
    if ( _next == 0 )
      _next = new LinkList( d );
    else
      _next->add( d );
  }


por que  add si agrega 'd' cuando _next != 0 ?

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)

y lo mismo con 

Código (cpp) [Seleccionar] Expandir


void Print( )
  {
    std::cout << "Dat Value : " << _value << std::endl;

    if ( _next )
      _next->Print( );
  }


por que transversa las lista ? o por que los imprime todos ?

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.

Código (c) [Seleccionar] Expandir

//         (*nuevo) = (Primero)malloc(sizeof(struct Array));

Debería ser

Código (c) [Seleccionar] Expandir

         nuevo = (Primero)malloc(sizeof(struct Array));

Si tienes esa línea comentada no se va a reservar memoria para los elementos que siguen al primero y eso solo puede resultar desastroso para tu programa.

Por otro lado, "Primero" no parece un nombre demasiado apropiado para un alias de "puntero a estructura".

Código complicado sin necesidad:

Código (c) [Seleccionar] Expandir

struct Array {
   int valor;
   int tam;
   Primero* sig;
};

"Primero", como hemos dicho, es un puntero. Dado que no es necesario que "sig" sea un puntero doble, se puede dejar únicamente como "Primero sig". Lo de "Primero" lo voy a respestar, aunque insisto que no es un nombre del que debas estar orgulloso

Código (c) [Seleccionar] Expandir

Primero *ant = primero;
    int i;
    for(i=1; i<n; i++) {
        Primero nuevo;
         (*nuevo) = (Primero)malloc(sizeof(struct Array));
        nuevo->valor=0;
        nuevo->tam = (*primero)->tam;
        nuevo->sig = NULL;
        (*ant)->sig = &nuevo;
        ant = (*ant)->sig;
    }

Otro puntero doble "ant" innecesario. Si le quitamos ese doble puntero el código queda más legible:

Código (c) [Seleccionar] Expandir

Primero ant = *primero;
    int i;
    for(i=1; i<n; i++) {
        Primero nuevo = (Primero)malloc(sizeof(struct Array));
        nuevo->valor=0;
        nuevo->tam = (*primero)->tam;
        nuevo->sig = NULL;
        ant->sig = nuevo;
        ant = ant->sig; // o ant = nuevo, como prefieras
    }

El mejor diccionario en estos casos es la propia experiencia. Dudo que haya un diccionario específico para traducir este tipo de términos.

Un saludo.

Ordenar paquetes quizás no tenga sentido en el caso que comentas. Lo que puedes hacer es poner un contador incremental en cada paquete. Entonces, lo que tienes que hacer es almacenar el id del último paquete recibido... si recibes un paquete con un identificador anterior, lo descartas sin miedo.

También puedes, para evitar desbordamientos del contador, usar una ventana de descartes. Por ejemplo, si recibo el identificador X se que he de descartar automáticamente los 10.000 mensajes anteriores, si recibo un mensaje con cualquier otro id entonces lo tomo como válido.

Otra opción para evitar el desbordamiento es usar la fecha y la hora en lugar de un contador, pero esta solución implica algo más de código.

Por otro lado, si no pasa nada porque se pierda algún paquete es preferible usar UDP, ya que es mucho más versátil y lo puedes adaptar a cualquier necesidad. Además, piensa que, en general, un paquete se perderá únicamente si hay sobrecarga en la red, lo cual no suele ser algo tan extremadamente común.

Un saludo.

Los protocolos con conexión, por ejemplo tcp, tampoco garantizan nada de eso, sería un caos si cada vez que tu creas una conexión tuvieses poder sobre los protocolos de enrutamiento,  sobre los recursos, etc,  del resto de Internet...

Con TCP los paquetes no se "pierden" porque entonces eso significa que la conexión se ha cortado. Así mismo, TCP garantiza el orden en el que llegan los paquetes porque crea una conexión persistente y única por la que van a viajar todos los mensajes que se transmitan por esa conexión. Es por este motivo que una conexión TCP es, por definición, mucho más pesada y lenta que una conexión UDP.

Al menos así es como lo recordaba.

[1.]

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:

Código (cpp) [Seleccionar] Expandir


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

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

Código (cpp) [Seleccionar] Expandir


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

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

Código (cpp) [Seleccionar] Expandir

  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":

Código (cpp) [Seleccionar] Expandir

  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:

Código (cpp) [Seleccionar] Expandir


#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:

Código (cpp) [Seleccionar] Expandir


#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.

http://en.wikipedia.org/wiki/HipHop_for_PHP

Es un proyecto que aparcaron hace un par de años.

Tengo algo asi como una aplicacion de consola, un cliente y un server, la idea es establecer una conexion UDP y poder testear la velocidad de la conexion

UDP no garantiza ni la entrega ni el orden de los paquetes. Si bien esto permite que éste protocolo sea, de base, más ligero que TCP, estas características traen problemas con los que no hay que lidiar en el caso de TCP. Por ejemplo, dado que no se mantiene una conexión persistente, cada paquete puede viajar por un camino diferente y, en consecuencia, el tiempo que tardan en llegar dos paquetes diferentes puede ser radicalmente diferente. Salvo que estés en una red local y el camino para comunicar ambos equipos sea único, es posible que la medida de tiempos no sea especialmente útil.

La pregunta seria: ¿como? Como hago para saber el tiempo exacto que demoro en llegar un dato de un pc al otro?

Aún así, si quieres testear el tiempo tienes que tener en cuenta lo siguiente:

* Si el tiempo a medir es únicamente en una dirección, es decir, únicamente te interesa el tiempo que tarda el paquete en ir de A a B, necesitas que ambos equipos tengan la hora perfectamente sincronizada. Si no es así, dado que estamos hablando de plazos de, normalmente, una centésima o menos, los cálculos de tiempo que realices tendrán un margen de error bastante amplio. Para contar el tiempo en este caso necesitas enviar en el mensaje la hora exacta del equipo A en el momento de enviar el mensaje; el equipo B recibe la hora, la compara con su hora interna y calcula la diferencia.

* Si el tiempo a medir es el de una petición y una respuesta, has de tener en cuenta que hay mensajes que se pueden perder y, los que no se pierdan, pueden tener tiempos de respuesta bastante dispares. El cálculo de tiempo en este caso es similar al anterior: el equipo A empaqueta la hora en el mensaje y lo envía, el equipo B recibe el mensaje, recupera la hora y se la envía de vuelta al equipo A. Ahora el equipo A calcula la diferencia entre la hora recibida y la hora actual y con eso obtienes el tiempo de respuesta.

Lo suyo sería hacer un envío de varios mensajes diferentes para intentar calcular un tiempo medio, pero imagino que ya has pensado en eso.

Un saludo.

Yo pensaba que el día de los inocentes era en diciembre.

¿En serio pretendes que nos estudiemos ese código para dártelo mascado?