Mensajes

Buenas.

Estoy intentando guardar y leer de/a un archivo en forma binaria, no tengo problemas guardando, el problema va leyendo el archivo:

Código (cpp) [Seleccionar] Expandir



Ifstream fromFile;
fromFile.open("Archivo.bin", iOS::binary);

if (fromFile.good()){

     UnaClase uc;
   
     fromFile.read((char*)&uc, sizeof(UnaClase));

     //La siguiente linea me da el error:
     std::cout << uc.LeerNumero() << std::endl;


}


Pareciera que no se está escribiendo la información en la memoria que le corresponde a la variable "uc".

Que podrá ser=?

gracias.

Si bien se puede leer directamente en una estructura en C++ igual que en C, hay que tener cuidado de no tener campos que sean clases dentro, y que no haya punteros tampoco.
¿Qué tiene "UnaClase"? Si tuviera por ejemplo una string, podría ser un problema.

Hay montones de compañías con términos del estilo.
No es nada de lo que tener miedo. Big Data, es parte del futuro.
No se queja tanto la gente cuando Google les muestra lo que están buscando. Anda, en tu idioma además.

La pena es que el mundo avance y la gente se siga quedando atrás porque "Dios mio, me están espiando". Aunque es una frase muy típica, no es menos cierta: A nadie le importa lo que hagas por internet.

Vamos que quieren poner a prueba como de efectivo es, para cuando lleguen sus elecciones, poder ahcerlo con absoluta certeza y así evitar intrusiones como las que  ellos ejercieron contra EE.UU. (que se sepa).
Como dice el refrán: "cree el ladrón, que todos son de su condición."

Siempre sacándole punta a todo e.e

@ivancea96 con clases Atómicas no basta para que un recurso compartido sea actualizado correctamente por múltiples hilos a la misma ves, tampoco basta con volatile se necesita un lock, para asegurar la correcta sincronización.

Las clases del paquete atomic son precisamente thread-safe y lock-free. Son una optimización al uso de locks, y su uso es precisamente este.

No sé que pretendías ver en tu ejemplo, pero el resultado es el esperado: La variable ha sido incrementada 10 veces, por tanto, es 10, punto.

Puedes verificarlo si quieres:

Código (cpp) [Seleccionar] Expandir

import java.util.Objects;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.logging.Logger;
import java.util.stream.IntStream;

public class UsoSynchronized {

    private static final Logger LOGGER = Logger.getLogger(UsoSynchronized.class.getSimpleName());
    private ExecutorService executors = null;
    private AtomicInteger atomicInteger = new AtomicInteger(0);

    public UsoSynchronized() {
        try {
            executors = Executors.newFixedThreadPool(20);
            IntStream.rangeClosed(1,10)
                    .forEach(e -> {
                        executors.submit(()-> withAtomicInteger());
                    });

        } finally {
            if(Objects.nonNull(executors)) {
                executors.shutdown();
               
                try {
                    executors.awaitTermination(1, TimeUnit.DAYS);
                } catch (InterruptedException exc) {
                }
            }
        }
       
        LOGGER.info("Final: "+ atomicInteger.get());
    }

    public void withAtomicInteger() {
        LOGGER.info(""+ atomicInteger.incrementAndGet());
    }

    public static void main(String... haga) {
        new UsoSynchronized();
    }
}

Verás un 10 en Final, es lo esperado, y verás los números del 1 al 10 antes que él.

Si tú te refieres al orden, evidentemente el orden no es una necesidad en este caso, y como tal, no se mantiene.

La razón de que actualmente no te funcione es que los tipos primitivos como int se copian cuando los pasas como parámetro. Al copiarse, es otro objeto diferente, y aunque lo modifiques, el original se queda igual. Para pasar objetos, tendrías que utilizar clases en vez de tipos primitivos.

Tendrías que meter la variable dentro de una clase y compartir un objeto de esa clase con las 2 que lo van a modificar. Otra opción es tenerlo como variable static y que accedan directamente a ella.

Dado que el acceso concurrente te acabaría dando problemas, puedes usar la clase AtomicInteger que sirve precisamente para eso: Modificar un int desde varios hilos. Podrías crearla en el main, y pasárselo al constructor de los otros 2 como haces ahora.

[int**]

Código (cpp) [Seleccionar] Expandir

refuncion(&pnum);

Con eso estás pasando como parámetro la dirección del puntero, es decir, un int** (dirección de una dirección).
Sin embargo, en la función esperas un int&. El uso de "&" antes de una variable es diferente a su utilidad después de un tipo. Para que esto compilase, deberías pasarle a la función "*pnum" (es decir, un int). "int&" es una referencia a un int, es decir, lo que le hagas al parámetro "ref" será como hacérselo a "*pnum".

Aunque este código compile, habrá un error, y es que al hacer "*pnum = 5" estás diciendo que "la variable a la que apunta "pnum" se establecerá a 5. El problema, es que "pnum" no apunta a ninguna variable.

Puedes hacer este cambio:

Código (cpp) [Seleccionar] Expandir

int num = 5;
int* pnum = #
// ...

Lo que estás viendo probablemente sea que el proceso padre ha terminado (ha llegado al return), pero el proceso hijo aun no ha mostrado por pantalla su linea.

Cuando el proceso padre termina, la consola lo detecta, y te vuelve a mostrar la línea para escribir comandos.
Luego, el proceso hijo muestra por consola su mensaje.

Al trabajar con procesos, es importante controlar el orden en el que terminan los hilos. Rara vez querrás que el proceso padre termine antes que los procesos hijos, con lo cual habría que esperar en el proceso padre a que los hijos terminen.

Para ello, entre las varias opciones que hay: http://man7.org/linux/man-pages/man2/wait.2.html

Puedes. Puedes declarar un arreglo de cualquier tipo (incluyendo un "puntero a X" como un tipo).

Código (cpp) [Seleccionar] Expandir

int* integers; // Array de enteros
int** integerPointers; // Array de punteros a enteros (o array de arrays, según como lo inicialices)

No sé si responde la duda; hablo muy por encima... Si tienes alguna caso más particular, se puede mirar

Ya casi no se me ve el pelo por aquí pero...
Feliz navidad a todos

Puedes probar Minidosis: http://www.minidosis.org/
De ese profesor solo viera sus vídeos, pero ahora tiene bastante más material en la web.