Mensajes

Cuando tu estás escribiendo en un archivo, por defecto, el sistema lo trata igual que si fuese un buffer de memoria.

Cuando tu escribes en un buffer de memoria, el sistema crea un puntero que apunta a una posición concreta del buffer, de tal forma que cuando inicias operaciones de lectura o escritura, éstas se realizan a partir de esa posición.

Bueno, también puede darse el caso de que se utilicen dos punteros independientes, uno para la lectura y otro para la escritura.

La posición de éstos punteros, normalmente, se determina de forma relativa con respecto al inicio del buffer.

Con esta información, lo que podrías hacer es lo siguiente:

Lee la posición del puntero para saber si has llegado al final del archivo.

Cuando hayas llegado al final posiciona el puntero de nuevo en el principio del archivo y continúa con tu escritura.

Código (c) [Seleccionar] Expandir


// Posiciona el puntero al inicio del archivo
fseek( &file, 0, SEEK_SET );

// Obtiene la posición del puntero
long pos = ftell( &file );

La explicación al por qué de las 4 instrucciones es la siguiente:

Dependiendo de la arquitectura del procesador, no todas las instrucciones pueden acceder a la memoria.

un ejemplo es el caso de las instrucciones de suma, resta, ... Estas instrucciones únicamente pueden operar con los registros del procesador y con valores constantes. Es necesario, por tanto, mover las dos variables a registros del procesador para poder realizar la suma.

La instrucción de suma almacena en ax el resultado de la suma, por lo que después es necesario mover dicho resultado a la variable donde queremos almacenarlo.

pues más o menos sería así

Código (c) [Seleccionar] Expandir


int result = num1 + num2;

Código (asm) [Seleccionar] Expandir


mov ax, num1
mov bx, num2
add ax, bx
mov result, ax

A ver, con la estructura agenda vas a tener una lista enlazada, si lo representamos gráficamente, después de tener varios contactos la estructura sería la siguiente:

agenda ( sig -> ) agenda ( sig -> ) agenda ...

Si lo representamos con números para poder explicarlo mejor quedaría así:

agenda0 ( sig -> ) agenda1 ( sig -> ) agenda2 ...

Esto básicamente quiere decir que tienes un elemento agenda0 cuyo puntero sig apunta al elemento agenda1 y así.

Si quieres eliminar agenda1 tendrías que conseguir que el sig de agenda0 apunte a agenda2 en vez de a agenda1. Y después, como buena práctica, hay que eliminar agenda1 para que no deje lagunas de memoria.

Los pasos serían más o menos estos:

Código (c) [Seleccionar] Expandir


struct agenda* anterior = 0;
struct agenda* actual = princ;

while ( actual != 0 )
{
    if ( [actual es el elemento a eliminar] )
    {
      struct agenda* siguiente = actual->sig;
      free( actual );

      if ( anterior != 0 )
        anterior->sig = siguiente;
      else
        princ = siguiente; // Estamos borrando el primer elemento de la agenda

      if ( siguiente == 0 )
        fin = anterior; // Estamos borrando el último elemento de la agenda.
    }

    anterior = actual;
    actual = actual->sig;
}

te acabas de explicar como un libro cerrado

es que getchar solo lee un caracter... si tu introduces 1234.56 por teclado, el buffer de entrada va a contener una cadena de caracteres tal que "1234.56"... luego ya es responsabilidad tuya, mediante una función de la librería estándar o mediante una función propia, convertir esa cadena de texto en un número.

Con lo comentado, si tu introduces 1234.56 y sólo pones un getchar, el getchar va a leer un único carácter, el primero que le llegue más concretamente, que será el "1" ( ojo, no un uno numérico, sino el carácter que representa al número 1 ), y dejará en el buffer de entrada el resto, "234.56".

Y cual es la diferencia entre hacerlo con paréntesis y sin paréntesis ?
Por lo qué pude ver los qué tienen paréntesis son punteros qué no apuntan hacía ningún otro objeto si no hacía los datos miembros de la clase.

Pues a ver, si tu tienes

Código (cpp) [Seleccionar] Expandir


class poo
{
  public:

    // ...

     std::string* Cadena( )
     { return _string; }

    // ...

  private:

    std::string* _string;
}

Y deseas recuperar el puntero a la cadena forzosamente tienes que llamar a la función Cadena. Hacer esa llamada te va a retornar un puntero que puedes usar inmediatamente dentro de la misma instrucción.

Código [Seleccionar] Expandir


int main( ... )
{
  poo clase;

// ...

  // Esto ...
  int length = clase.Cadena( )->length( );

  // ... es equivalente a ...
  std::string* cadena = clase.Cadena( );
  int length = cadena->length( );

  // ...
}

Sería más conveniente que en vez de crear un hilo con cada versión modificases uno de los que ya tienes creado y si eso, para ponerlo delante... añadas un mensaje de respuesta.

No merece la pena llenar el foro de ***** de forma gratuíta ( no por tu mensaje actual, sino por los que quedan obsoletos ).

Es una función propia del lenguaje. Tu piensa que al final el código fuente que tu escribes se acaba transformando en instrucciones máquina... y cualquier procesador de ordenador tiene instrucciones para ( por ejemplo ) sumar y restar números con signo y sin signo.

Esto quiere decir que no se requiere implementar una función para que sume dos números enteros porque es una funcionalidad que ya viene implementada a más bajo nivel.

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

Te pongo el enlace directamente porque coincido con lo que pone.