elhacker.net cabecera Bienvenido(a), Visitante. Por favor Ingresar o Registrarse
¿Perdiste tu email de activación?.

 

 


Tema destacado: Recopilación Tutoriales y Manuales Hacking, Seguridad, Privacidad, Hardware, etc


  Mostrar Mensajes
Páginas: 1 [2] 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 ... 161
11  Programación / Programación C/C++ / Re: Numeros capicu del 100 al 999, en: 26 Octubre 2023, 19:35 pm
¿Cómo lo hiciste?
12  Programación / Programación C/C++ / Re: Numeros capicu del 100 al 999, en: 24 Octubre 2023, 22:13 pm
Sigue la secuencia.

Del 1 al 10 hay 9.
Del 11 al 100 hay 9.
Del 101 al 1000 hay 90.
Del 1001 al 10000 hay 90.
Del 10001 al 100000 hay 900.
Del 100001 al 1000000 hay 900.
Del 1000001 al 10000000 hay 9000.
Del 10000001 al 100000000 hay 9000.
13  Programación / Programación C/C++ / Re: campos de bits + punteros + macros en: 24 Octubre 2023, 14:12 pm
Te iría bien tener una función que tomando como argumentos msB y lsB (301 y 300 respectivamente), rellenara una estructura del tipo

Código:
typedef struct {
    unsigned char robot;
    unsigned short tiempo;
} robot_data;

Date cuenta que s no lo necesitas pues deberías descartar el dato entero al no ser una lectura valida (con s = 0). Es de suponer que haces una lectura tipo poll a dichos registros.
14  Programación / Programación C/C++ / Re: campos de bits en: 4 Octubre 2023, 12:27 pm
Es correcto todo lo que dices. Aunque también es cierto que si usas volatile te quitas de encima esas molestas optimizaciones del compilador. Y oye, que para eso está la volatile.

Y sí, lo he probado con el código que pasaste de ejemplo con -O2, con volatile y te muestra los resultados.
15  Programación / Programación C/C++ / Re: cómo hacer una función en C que devuelva una matriz de cadenas en: 2 Octubre 2023, 16:41 pm
Especifica más eso de poder cambiar la matriz.
16  Programación / Programación C/C++ / Re: navegar por una web enviando parametreos por c++ en: 29 Septiembre 2023, 12:37 pm
Podrías mirarte la librería libcurl.

O por sockets, directamente, construyendo las las peticiones y las cabeceras a mano.



Arreglado link. Agradecimientos a Daniel por el aviso
17  Programación / Programación C/C++ / Re: campos de bits en: 29 Septiembre 2023, 12:23 pm
Motivado por la respuesta de RayR decidí encontrar los bits que había perdido.

Aquí están

Código
  1. #include <stdio.h>
  2.  
  3. typedef struct {
  4.    unsigned char codigo : 4;
  5.    unsigned short cantidad: 9;
  6.    unsigned char procedencia: 1;
  7.    unsigned char basura: 2;
  8. } producto_t;
  9.  
  10. int main() {
  11.    unsigned base[2] = { 0 };
  12.  
  13.    producto_t *prod = (producto_t *) &base;
  14.  
  15.    printf("tamanno del mapa de bits: %lu bytes\n\n", sizeof(producto_t));
  16.  
  17.    prod->codigo = 0xF;
  18.    printf("codigo     : %08x %08x\n", base[1], base[0]);
  19.  
  20.    prod->procedencia = 0x1;
  21.    printf("procedencia: %08x %08x\n", base[1], base[0]);
  22.  
  23.    prod->cantidad = 0X1FF;
  24.    printf("cantidad   : %08x %08x\n", base[1], base[0]);
  25.  
  26.    prod->basura = 3;
  27.    printf("basura     : %08x %08x\n", base[1], base[0]);
  28. }

Y la respuesta es:
Código:
tamanno del mapa de bits: 6 bytes

codigo     : 00000000 0000000f
procedencia: 00000001 0000000f
cantidad   : 00000001 01ff000f
basura     : 00000007 01ff000f
18  Programación / Programación C/C++ / Re: campos de bits en: 28 Septiembre 2023, 04:50 am
¿Qué ha pasado?
Le has dado unas directrices a C en tu construcción del mapa de bits y ha intentado acomodarlo como ha podido.
¿Cómo lo ha acomodado?
Vamos a reducir el programa a la mínima expresión:

Código
  1. #include <stdio.h>
  2.  
  3. struct s_producto {
  4.    unsigned char codigo : 4;
  5.    unsigned short cantidad: 9;
  6.    unsigned char procedencia: 1;
  7.    unsigned char bas: 2;
  8. };
  9.  
  10. union u_producto {
  11.    struct s_producto producto;
  12.    unsigned short int empaquetado;
  13. };
  14.  
  15. int main() {
  16.    union u_producto vec = {0};
  17.  
  18.    printf("tamanno del mapa de bits: %lu bytes\n\n", sizeof(vec.producto));
  19.  
  20.    vec.producto.codigo = 0xF;
  21.    printf("codigo     : %08X\n", vec.empaquetado);
  22.  
  23.    vec.producto.procedencia = 0x1;
  24.    printf("procedencia: %08X\n", vec.empaquetado);
  25.  
  26.    vec.producto.cantidad = 0X1FF;
  27.    printf("cantidad   : %08X\n", vec.empaquetado);
  28.  
  29.    vec.producto.bas = 0x3;
  30.    printf("basura     : %08X\n", vec.empaquetado);
  31. }

Resultado:

Código:
tamanno del mapa de bits: 6 bytes

codigo     : 0000000F
procedencia: 0000000F
cantidad   : 0000000F
basura     : 0000000F
Sólo veo código. Vamos a abrir el rango.
En vez de
Código
  1. union u_producto {
  2.    struct s_producto producto;
  3.    unsigned short int empaquetado;
  4. };

ponemos

Código
  1. union u_producto {
  2.    struct s_producto producto;
  3.    unsigned int empaquetado;
  4. };

y resulta en

Código:
tamanno del mapa de bits: 6 bytes

codigo     : 0000000F
procedencia: 0000000F
cantidad   : 01FF000F
basura     : 01FF000F

Podemos ver que alineó codigo en 2 bytes (aunque solo tuviera 4 bits) y cantidad también la ha alineado en otros dos bytes. Ya te digo también que he estado buscando procedencia y basura y no los he encontrado, pero están ahí. En el mejor de los casos está usando un byte en otro sitio para guardar esa información.

Por otra parte ocurre una cosa muy interesante. Si juntamos todos los unsigned char dentro del mapa de bits la cosa cambia:

Código
  1. struct s_producto {
  2.    unsigned short cantidad: 9;
  3.    unsigned char codigo : 4;
  4.    unsigned char procedencia: 1;
  5.    unsigned char bas: 2;
  6. };

El resultado es el siguiente:

Código:
tamanno del mapa de bits: 4 bytes

codigo     : 000F0000
procedencia: 001F0000
cantidad   : 001F01FF
basura     : 007F01FF

Vamos a exprimir un poco más el mapa de bits. ¿Qué pasaría si hubieras usado unsigned short en todos los tipos de datos dentro del mapa?

Código
  1. struct s_producto {
  2.    unsigned short cantidad: 9;
  3.    unsigned short codigo : 4;
  4.    unsigned short procedencia: 1;
  5.    unsigned short bas: 2;
  6. };

Esto da como resultado:

Código:
tamanno del mapa de bits: 2 bytes

codigo     : 00001E00
procedencia: 00003E00
cantidad   : 00003FFF
basura     : 0000FFFF

De hecho te recomiendo quitar bas, porque no se usa.

En estructuras más complicadas sí que se usan bits para alinear la estructura interna, y solo tienen ese propósito, y estos son anónimos, no tienen nombre. Por ejemplo:

Código
  1. struct mapa_bits {
  2.    unsigned dato: 3;
  3.    unsigned: 4; // hueco de 4 bits sin nombre
  4.    unsigned dato_2: 7;
  5. }

Como dato curioso también existen los anónimos de 0 bits. Estos lo que le indican al compilador es que alinee los campos de bits que le siguen a una potencia de dos. De nuevo todo esto es para facilitar al procesador el movimiento de datos en la memoria.

Por ejemplo:

Código
  1. struct s_producto {
  2.    unsigned short cantidad: 9;
  3.    unsigned short: 0;
  4.    unsigned short codigo : 4;
  5.    unsigned short procedencia: 1;
  6. };

Me devuelve el siguiente resultado:

Código:
tamanno del mapa de bits: 4 bytes

codigo     : 000F0000
procedencia: 001F0000
cantidad   : 001F01FF

¿Qué quiere decir todo esto?
No es buena idea usar union de esta forma, es decir, para empaquetar estructuras. Ya has visto que el compilador hace lo que quiere con ellas.

Más adelante te encontrarás que incluso guardar una estructura entera en disco o mandarla por la red te dará problemas porque al rescatarla leerás basura. Esto es debido, otra vez, a que el compilador hace lo que quiere con las estructuras y si a ti te las ha colocado de una forma en memoria, a otro puede que tenga sus miembros de forma diferente y por lo tanto se colocarán mal los datos. Pero también puede que en las dos máquinas las estructuras esté construidas igual y consigas bien la información.

Esto quiere decir que para serializar y deserializar estructuras manda al stream cada miembro de la estructura, uno a uno, en una secuencia dada. Recupera del stream uno a uno los miembros de la estructura en el mismo orden que los enviaste.

Por último, y como ya te habrás dado cuenta, dar diferentes tipos de datos a los miembros de un mapa de bits hace que el compilador intente agruparlos por tipo. Mezclarlos, como has visto, resulta en un desastre. Te recomendaría que uses unsigned y el compilador te lo va a acomodar todo en 32 bits.

Si necesitas un control muy fino de bits en memoria deberías pensar en operaciones de desplazamiento de bits junto a operaciones lógicas. Los mapas de bits son más para no gastar mucha memoria en números pequeños y caso es buen ejemplo de ellos. Un dato que perfectamente cabe en 4 bits, otro que cabe en 9 y otro que cabe en 1, puedes meterlo todo en 2 bytes en vez de gastar 12, que sería si los hubieras declarado como tres enteros diferentes.

Los campos de bits se ven mucho más en sistemas embebidos y microcontroladores.
19  Programación / Programación C/C++ / Re: campos de bits en: 27 Septiembre 2023, 20:30 pm
Creo que sé lo que intentas hacer y he modificado un poco tu programa.
Por cierto, de procedencia dijiste que solo era nacional o extranjera, para ello basta con solo 1 bit, no 3.
He puesto algunos comentarios explicativos.
Código
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <time.h>
  4.  
  5. #define MAX_PROD 10
  6.  
  7. typedef struct {
  8.    unsigned codigo: 4;
  9.    unsigned procedencia: 1;
  10.    unsigned cantidad: 9;
  11. } producto_t;
  12.  
  13. // un unsigned suele ser de 32 bits, mas que suficiente para guardar todo el mapa de bits.
  14. // De hecho lo más probable es que el compilador la guarde en memoria con ese tamaño.
  15. typedef union {
  16.    producto_t producto;
  17.    unsigned repr_interna;
  18. } producto;
  19.  
  20. int main() {
  21.    producto vec[MAX_PROD] = {0};
  22.  
  23.    srand(time(NULL));
  24.  
  25.    printf("tamanno del mapa de bits: %lu bytes\n\n", sizeof(producto_t));
  26.  
  27.    // dando datos a los productos
  28.    for (size_t i = 0; i < 10; i++) {
  29.        vec[i].producto.codigo = i + 1; // codigo tiene 4 bits: puede guardar desde 0 hasta 15
  30.        vec[i].producto.procedencia = rand() & 1; // procedencia tiene 1 bit: puede guardar desde 0 hasta 1
  31.        vec[i].producto.cantidad = rand() % 501; // cantidad tiene 9 bits: puede guardar desde 0 hasta 511
  32.    }
  33.  
  34.    // es responsabilidad del programador que los datos estén dentro de sus rangos
  35.  
  36.    // visualizando los datos
  37.    for (int  i = 0; i < 10; i++) {
  38.        printf("producto ----------\ncodigo: %u    procedencia: %u    cantidad: %u\n",
  39.            vec[i].producto.codigo, vec[i].producto.procedencia, vec[i].producto.cantidad);
  40.  
  41.        printf("representacion interna: %04X\n", vec[i].repr_interna);
  42.  
  43.        puts("");
  44.    }
  45. }

Lo curioso es que me ha salido un resultado interesante para mostrar que el compilador hace lo que quiere con las estructuras. Adelantándome a tu respuesta sí, hay formas de obligarlo a que haga las estructuras exactamente como le has dicho, pero de normal intenta optimizarlas al máximo.

Uno de los resultados que me ha dado ha sido este:
producto ----------
codigo: 8    procedencia: 0    cantidad: 68
representacion interna: 0888


Me ha gustado mucho ese 888 hexadecimal pues se puede inferir como están los campos dentro. Veamos:
representacion interna:
  0    8    8    8
0000 1000 1000 1000

     codigo: 8  [ 1000 ]
procedencia: 0  [ 0 ]
   cantidad: 68 [ 001000100 ]

-relleno- cantidad   procedencia  codigo
   00     001000100       0        1000


Yo había construido el mapa de bits en el orden codigo -> procedencia -> cantidad y el compilador lo ha construido de forma interna como cantidad -> procedencia -> codigo
20  Programación / Programación C/C++ / Re: campos de bits en: 26 Septiembre 2023, 09:49 am
Te voy a preguntar ¿Qué sabes de los campos de bits? La pregunta tuya es muy abierta.
En el foro nos gusta ir al detalle de lo que no sabes, la duda concreta. No nos gusta hacer el ejercicio.
Páginas: 1 [2] 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 ... 161
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines