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

 

 


Tema destacado: (TUTORIAL) Aprende a emular Sentinel Dongle By Yapis


+  Foro de elhacker.net
|-+  Programación
| |-+  Programación C/C++ (Moderadores: Eternal Idol, Littlehorse, K-YreX)
| | |-+  Ayudaa a pasar este codigo en c a c++ :(
0 Usuarios y 1 Visitante están viendo este tema.
Páginas: [1] Ir Abajo Respuesta Imprimir
Autor Tema: Ayudaa a pasar este codigo en c a c++ :(  (Leído 2,134 veces)
jklm

Desconectado Desconectado

Mensajes: 1


Ver Perfil
Ayudaa a pasar este codigo en c a c++ :(
« en: 4 Julio 2019, 03:01 am »

Código
  1. #include <stdio.h>    /* print, scanf */
  2. #include <string.h>
  3. #include <stdlib.h>    /* system */
  4. #include <locale.h> /* setlocale */
  5.  
  6. #define MAX 80
  7. #define VALOR_CENTINELA -1
  8.  
  9. /* Estructuras */
  10. struct producto {
  11.    int codigo;
  12.    char nombre[MAX];
  13.    float costo;
  14.    float precio;
  15.    int cantidad;
  16. };
  17.  
  18. typedef struct producto Producto;
  19.  
  20. /* Opciones del Menú */
  21. void menuPrincipal();
  22. void menuInsertar();
  23. void menuBuscar();
  24. void menuEliminar();
  25. void menuMostrar();
  26. void menuModificar();
  27. void menuEliminarFisica();
  28.  
  29. /* Funciones para manejar el archivo directamente */
  30. Producto *obtenerProductos(int *n); /* Obtiene un vector dinámico de productos */
  31. char existeProducto(int codigoProducto, Producto *producto); /* Busca si existe el producto en el archivo de productos */
  32. char insertarProducto(Producto producto); /* Inserta el producto al final del archivo */
  33. char eliminarProducto(int codigoProducto); /* Eliminar el producto de código codigoProducto del archivo */
  34. char eliminacionFisica(); /* Realiza la eliminación física de registros inválidos del archivo de productos */
  35. char modificarProducto(Producto producto); /* Modifica el producto en el archivo */
  36. char guardarReporte(); /* Genera un archivo TXT con el reporte de los productos */
  37.  
  38. /* Función de lectura de cadenas */
  39. int leecad(char *cad, int n);
  40.  
  41. /* Titular del programa */
  42. void tituloPrincipal();
  43.  
  44. char linea[MAX];
  45.  
  46. int main()
  47. {
  48.    setlocale(LC_ALL, "spanish"); /* Permite imprimir caracteres con tilde */
  49.    menuPrincipal();
  50.  
  51.    return 0;
  52. }
  53.  
  54. void menuPrincipal()
  55. {
  56.    char repite = 1;
  57.    int opcion = -1;
  58.    /* Cuando el usuario ingresa texto en lugar de ingresar una opción. El programa no modifica
  59.     el valor de opcion. En ese caso, no se debe de ingresar a ninguno de los case, por eso se está
  60.     inicializando la variable opcion con un valor que no permita ejecutar ningún case. Simplemente,
  61.     volver a interar y pedir nuevamente la opción. */
  62.  
  63.    do {
  64.        system("cls");
  65.  
  66.        tituloPrincipal();
  67.  
  68.        printf("\n\t\t\t\tMENU PRINCIPAL\n");
  69.        printf("\n\t\t[1]. Insertar nuevo producto\n");
  70.        printf("\t\t[2]. Mostrar listado de productos\n");
  71.        printf("\t\t[3]. Eliminar un producto\n");
  72.        printf("\t\t[4]. Buscar producto por clave\n");
  73.        printf("\t\t[5]. Modificar un producto\n");
  74.        printf("\t\t[6]. Eliminación física de registros\n");
  75.        printf("\t\t[7]. Salir\n");
  76.        printf("\n\t\tIngrese su opción: [ ]\b\b");
  77.  
  78.        /* Lectura segura de un entero */
  79.        leecad(linea, MAX);
  80.        sscanf(linea, "%d", &opcion);
  81.  
  82.        switch (opcion) {
  83.  
  84.            case 1:
  85.                menuInsertar();
  86.                break;
  87.  
  88.            case 2:
  89.                menuMostrar();
  90.                break;
  91.  
  92.            case 3:
  93.                menuEliminar();
  94.                break;
  95.  
  96.            case 4:
  97.                menuBuscar();
  98.                break;
  99.  
  100.            case 5:
  101.                menuModificar();
  102.                break;
  103.  
  104.            case 6:
  105.                menuEliminarFisica();
  106.                break;
  107.  
  108.            case 7:
  109.                repite = 0;
  110.                break;
  111.        }
  112.  
  113.    } while (repite);
  114. }
  115.  
  116. void menuInsertar()
  117. {
  118.    Producto producto;
  119.    int codigoProducto = 0;
  120.    char repite = 1;
  121.    char respuesta[MAX];
  122.  
  123.    do {
  124.        system("cls");
  125.        tituloPrincipal();
  126.        printf("\n\t\t\t==> INSERTAR PRODUCTO <==\n");
  127.  
  128.        /* Se pide el código del producto a insertar */
  129.        printf("\n\tCódigo de producto: ");
  130.        leecad(linea, MAX);
  131.        sscanf(linea, "%d", &codigoProducto);
  132.  
  133.        /* Se verifica que el producto no haya sido almacenado anteriormente */
  134.        if (!existeProducto(codigoProducto, &producto)) {
  135.  
  136.            producto.codigo = codigoProducto;
  137.  
  138.            /* Se piden los demás datos del producto a insertar */
  139.            printf("\tNombre del producto: ");
  140.            leecad(producto.nombre, MAX);
  141.  
  142.            printf("\tCosto del producto ($): ");
  143.            leecad(linea, MAX);
  144.            sscanf(linea, "%f", &producto.costo);
  145.  
  146.            printf("\tPrecio del producto ($): ");
  147.            leecad(linea, MAX);
  148.            sscanf(linea, "%f", &producto.precio);
  149.  
  150.            printf("\tCantidad: ");
  151.            leecad(linea, MAX);
  152.            sscanf(linea, "%d", &producto.cantidad);
  153.  
  154.            /* Se inserta el producto en el archivo */
  155.            if (insertarProducto(producto)) {
  156.                printf("\n\tEl producto fue insertado correctamente\n");
  157.  
  158.            } else {
  159.                printf("\n\tOcurrió un error al intentar insertar el producto\n");
  160.                printf("\tInténtelo mas tarde\n");
  161.            }
  162.        } else {
  163.            /* El producto ya existe, no puede ser insertado. */
  164.            printf("\n\tEl producto de código %d ya existe.\n", codigoProducto);
  165.            printf("\tNo puede ingresar dos productos distintos con el mismo código.\n");
  166.        }
  167.  
  168.        printf("\n\tDesea seguir ingresando productos? [S/N]: ");
  169.        leecad(respuesta, MAX);
  170.  
  171.        if (!(strcmp(respuesta, "S") == 0 || strcmp(respuesta, "s") == 0)) {
  172.            repite = 0;
  173.        }
  174.  
  175.    } while (repite);
  176. }
  177.  
  178. void menuBuscar()
  179. {
  180.    Producto producto;
  181.    int codigoProducto;
  182.    char repite = 1;
  183.    char respuesta[MAX];
  184.  
  185.    do {
  186.        system("cls");
  187.        tituloPrincipal();
  188.        printf("\n\t\t\t==> BUSCAR PRODUCTO POR CÓDIGO <==\n");
  189.  
  190.        /* Se pide el código del producto a buscar */
  191.        printf("\n\tCódigo de producto: ");
  192.        leecad(linea, MAX);
  193.        sscanf(linea, "%d", &codigoProducto);
  194.  
  195.        /* Se verifica que el producto a buscar, exista */
  196.        if (existeProducto(codigoProducto, &producto)) {
  197.  
  198.            /* Se muestran los datos del producto */
  199.            printf("\n\tCódigo del producto: %d\n", producto.codigo);
  200.            printf("\tNombre del producto: %s\n", producto.nombre);            
  201.            printf("\tCosto del producto: %.1f $\n", producto.costo);
  202.            printf("\tPrecio del producto: %.1f $\n", producto.precio);
  203.            printf("\tCantidad: %d\n", producto.cantidad);
  204.  
  205.        } else {
  206.            /* El producto no existe */
  207.            printf("\n\tEl producto de código %d no existe.\n", codigoProducto);
  208.        }
  209.  
  210.        printf("\n\tDesea seguir buscando algún producto? [S/N]: ");
  211.        leecad(respuesta, MAX);
  212.  
  213.        if (!(strcmp(respuesta, "S") == 0 || strcmp(respuesta, "s") == 0)) {
  214.            repite = 0;
  215.        }
  216.  
  217.    } while (repite);
  218. }
  219.  
  220. void menuEliminar()
  221. {
  222.    Producto producto;
  223.    int codigoProducto;
  224.    char repite = 1;
  225.    char respuesta[MAX];
  226.  
  227.    do {
  228.        system("cls");
  229.        tituloPrincipal();
  230.        printf("\n\t\t\t==> ELIMINAR PRODUCTO POR CÓDIGO <==\n");
  231.  
  232.        /* Se pide el código del producto a eliminar */
  233.        printf("\n\tCódigo de producto: ");
  234.        leecad(linea, MAX);
  235.        sscanf(linea, "%d", &codigoProducto);
  236.  
  237.        /* Se verifica que el producto a buscar, exista */
  238.        if (existeProducto(codigoProducto, &producto)) {
  239.  
  240.            /* Se muestran los datos del producto */
  241.            printf("\n\tCódigo del producto: %d\n", producto.codigo);
  242.            printf("\tNombre del producto: %s\n", producto.nombre);            
  243.            printf("\tCosto del producto: %.1f $\n", producto.costo);
  244.            printf("\tPrecio del producto: %.1f $\n", producto.precio);
  245.            printf("\tCantidad: %d\n", producto.cantidad);
  246.  
  247.            printf("\n\tSeguro que desea eliminar el producto? [S/N]: ");
  248.            leecad(respuesta, MAX);
  249.            if (strcmp(respuesta, "S") == 0 || strcmp(respuesta, "s") == 0) {
  250.                if (eliminarProducto(codigoProducto)) {
  251.                    printf("\n\tProducto eliminado satisfactoriamente.\n");
  252.                } else {
  253.                    printf("\n\tEl producto no pudo ser eliminado\n");
  254.                }
  255.            }
  256.  
  257.        } else {
  258.            /* El producto no existe */
  259.            printf("\n\tEl producto de código %d no existe.\n", codigoProducto);
  260.        }
  261.  
  262.        printf("\n\tDesea eliminar otro producto? [S/N]: ");
  263.        leecad(respuesta, MAX);
  264.  
  265.        if (!(strcmp(respuesta, "S") == 0 || strcmp(respuesta, "s") == 0)) {
  266.            repite = 0;
  267.        }
  268.  
  269.    } while (repite);
  270. }
  271.  
  272. void menuMostrar()
  273. {
  274.    Producto *productos;
  275.    int numeroProductos;
  276.    int i;
  277.    float costoTotal;
  278.    float precioTotal;
  279.    int cantidadTotal;
  280.    char respuesta[MAX];
  281.  
  282.    system("cls");
  283.    tituloPrincipal();
  284.    productos = obtenerProductos(&numeroProductos); /* Retorna un vector dinámico de productos */
  285.  
  286.    if (numeroProductos == 0) {
  287.        printf("\n\tEl archivo está vacío!!\n");
  288.        system("pause>nul");
  289.  
  290.    } else {
  291.        printf("\n\t\t    ==> LISTADO DE PRODUCTOS REGISTRADOS <==\n");
  292.        printf(" ------------------------------------------------------------------------------\n");
  293.        printf("%8s\t%-20s%15s%15s%10s\n", "CODIGO", "NOMBRE", "COSTO $", "PRECIO $", "CANTIDAD");
  294.        printf(" ------------------------------------------------------------------------------\n");
  295.  
  296.        /* Se recorre el vector dinámico de productos */
  297.        costoTotal = 0;
  298.        precioTotal = 0;
  299.        cantidadTotal = 0;
  300.        for (i = 0; i < numeroProductos; i++) {
  301.            if (productos[i].codigo != VALOR_CENTINELA) {
  302.                printf("%7d \t%-20.20s%15.1f%15.1f%8d\n", productos[i].codigo, productos[i].nombre, productos[i].costo, productos[i].precio, productos[i].cantidad);
  303.                costoTotal += productos[i].costo;
  304.                precioTotal += productos[i].precio;
  305.                cantidadTotal += productos[i].cantidad;
  306.            }
  307.        }
  308.        printf(" ------------------------------------------------------------------------------\n");
  309.        printf("\t\t\t      TOTAL: %15.1f%15.1f%8d\n", costoTotal, precioTotal, cantidadTotal);
  310.  
  311.        printf("\n\tDesea guardar el reporte en un archivo de texto? [S/N]: ");
  312.        leecad(respuesta, MAX);
  313.  
  314.        if (strcmp(respuesta, "S") == 0 || strcmp(respuesta, "s") == 0) {
  315.            if (guardarReporte()) {
  316.                printf("\n\tEl reporte fue guardado con éxito\n");
  317.            } else {
  318.                printf("\n\tOcurrió un error al guardar el reporte\n");
  319.            }
  320.  
  321.            system("pause>nul");
  322.        }
  323.    }
  324. }
  325.  
  326. void menuModificar()
  327. {
  328.    Producto producto;
  329.    int codigoProducto;
  330.    char repite = 1;
  331.    char respuesta[MAX];
  332.  
  333.    do {
  334.        system("cls");
  335.        tituloPrincipal();
  336.        printf("\n\t\t\t==> MODIFICAR PRODUCTO POR CÓDIGO <==\n");
  337.  
  338.        /* Se pide el código del producto a modificar */
  339.        printf("\n\tCódigo de producto: ");
  340.        leecad(linea, MAX);
  341.        sscanf(linea, "%d", &codigoProducto);
  342.  
  343.        /* Se verifica que el producto a buscar exista */
  344.        if (existeProducto(codigoProducto, &producto)) {
  345.  
  346.            /* Se muestran los datos del producto */
  347.            printf("\n\tNombre del producto: %s\n", producto.nombre);
  348.            printf("\tCosto del producto ($): %.1f\n", producto.costo);
  349.            printf("\tPrecio del producto ($): %.1f\n", producto.precio);
  350.            printf("\tCantidad: %d\n", producto.cantidad);
  351.  
  352.            printf("\n\tElija los datos a modificar\n");
  353.  
  354.            /* Modificación del nombre del producto */
  355.            printf("\n\tNombre del producto actual: %s\n", producto.nombre);
  356.            printf("\tDesea modificar el nombre del producto? [S/N]: ");
  357.            leecad(respuesta, MAX);
  358.            if (strcmp(respuesta, "S") == 0 || strcmp(respuesta, "s") == 0) {
  359.                printf("\tNuevo nombre del producto: ");
  360.                leecad(producto.nombre, MAX);
  361.            }
  362.  
  363.            /* Modificación del costo del producto */
  364.            printf("\n\tCosto del producto actual: %.1f\n", producto.costo);
  365.            printf("\tDesea modificar el costo del producto? [S/N]: ");
  366.            leecad(respuesta, MAX);
  367.            if (strcmp(respuesta, "S") == 0 || strcmp(respuesta, "s") == 0) {
  368.                printf("\tNuevo costo del producto: ");
  369.                leecad(linea, MAX);
  370.                sscanf(linea, "%f", &producto.costo);
  371.            }
  372.  
  373.            /* Modificación del precio del producto */
  374.            printf("\n\tPrecio del producto actual: %.1f\n", producto.precio);
  375.            printf("\tDesea modificar el precio del producto? [S/N]: ");
  376.            leecad(respuesta, MAX);
  377.            if (strcmp(respuesta, "S") == 0 || strcmp(respuesta, "s") == 0) {
  378.                printf("\tNuevo precio del producto: ");
  379.                leecad(linea, MAX);
  380.                sscanf(linea, "%f", &producto.precio);
  381.            }
  382.  
  383.            /* Modificación de la cantidad del producto */
  384.            printf("\n\tCantidad del producto actual: %d\n", producto.cantidad);
  385.            printf("\tDesea modificar la cantidad del producto? [S/N]: ");
  386.            leecad(respuesta, MAX);
  387.            if (strcmp(respuesta, "S") == 0 || strcmp(respuesta, "s") == 0) {
  388.                printf("\tNueva cantidad del producto: ");
  389.                leecad(linea, MAX);
  390.                sscanf(linea, "%d", &producto.cantidad);
  391.            }
  392.  
  393.            printf("\n\tEstá seguro que desea modificar los datos del producto? [S/N]: ");
  394.            leecad(respuesta, MAX);
  395.  
  396.            if (strcmp(respuesta, "S") == 0 || strcmp(respuesta, "s") == 0) {
  397.                /* Se modifica el producto en el archivo */
  398.                if (modificarProducto(producto)) {
  399.                    printf("\n\tEl producto fue modificado correctamente\n");
  400.  
  401.                } else {
  402.                    printf("\n\tOcurrió un error al intentar modificar el producto\n");
  403.                    printf("\tInténtelo mas tarde\n");
  404.                }
  405.            }
  406.        } else {
  407.            /* El producto no existe */
  408.            printf("\n\tEl producto de código %d no existe.\n", codigoProducto);
  409.        }
  410.  
  411.        printf("\n\tDesea modificar algún otro producto? [S/N]: ");
  412.        leecad(respuesta, MAX);
  413.  
  414.        if (!(strcmp(respuesta, "S") == 0 || strcmp(respuesta, "s") == 0)) {
  415.            repite = 0;
  416.        }
  417.  
  418.    } while (repite);
  419. }
  420.  
  421. void menuEliminarFisica()
  422. {
  423.    char respuesta[MAX];
  424.  
  425.  
  426.    system("cls");
  427.    tituloPrincipal();
  428.    printf("\n\t\t==> ELIMINAR FÍSICAMENTE REGISTROS DEL ARCHIVO <==\n");
  429.  
  430.    /* Se pide el código del producto a eliminar */
  431.    printf("\n\tSeguro que desea proceder con la eliminación física? [S/N]: ");
  432.    leecad(respuesta, MAX);
  433.  
  434.    if (strcmp(respuesta, "S") == 0 || strcmp(respuesta, "s") == 0) {
  435.        if (eliminacionFisica()) {
  436.            printf("\n\tLa eliminación física se realizó con éxito.\n");
  437.        } else {
  438.            printf("\n\tOcurrió algún error en la eliminación física.\n");
  439.        }
  440.  
  441.        system("pause>nul");
  442.    }
  443. }
  444.  
  445. Producto *obtenerProductos(int *n)
  446. {
  447.    FILE *archivo;
  448.    Producto producto;
  449.    Producto *productos; /* Vector dinámico de productos */
  450.    int i;
  451.  
  452.    /* Abre el archivo en modo lectura */
  453.    archivo = fopen("productos.dat", "rb");
  454.  
  455.    if (archivo == NULL) { /* Si no se pudo abrir el archivo, el valor de archivo es NULL */
  456.        *n = 0; /* No se pudo abrir. Se considera n  */
  457.        productos = NULL;
  458.  
  459.    } else {
  460.  
  461.        fseek(archivo, 0, SEEK_END); /* Posiciona el cursor al final del archivo */
  462.        *n = ftell(archivo) / sizeof(Producto); /* # de productos almacenados en el archivo. (# de registros) */
  463.        productos = (Producto *)malloc((*n) * sizeof(Producto)); /* Se reserva memoria para todos los productos almacenados en el archivo */
  464.  
  465.        /* Se recorre el archivo secuencialmente */
  466.        fseek(archivo, 0, SEEK_SET); /* Posiciona el cursor al principio del archivo */
  467.        fread(&producto, sizeof(producto), 1, archivo);
  468.        i = 0;
  469.        while (!feof(archivo)) {
  470.            productos[i++] = producto;
  471.            fread(&producto, sizeof(producto), 1, archivo);
  472.        }
  473.  
  474.        /* Cierra el archivo */
  475.        fclose(archivo);
  476.    }
  477.  
  478.    return productos;
  479. }
  480.  
  481. char existeProducto(int codigoProducto, Producto *producto)
  482. {
  483.    FILE *archivo;
  484.    char existe;
  485.  
  486.    /* Abre el archivo en modo lectura */
  487.    archivo = fopen("productos.dat", "rb");
  488.  
  489.    if (archivo == NULL) { /* Si no se pudo abrir el archivo, el valor de archivo es NULL */
  490.        existe = 0;
  491.  
  492.    } else {
  493.        existe = 0;
  494.  
  495.        /* Se busca el producto cuyo código coincida con codigoProducto */
  496.        fread(&(*producto), sizeof(*producto), 1, archivo);
  497.        while (!feof(archivo)) {
  498.            if ((*producto).codigo == codigoProducto) {
  499.                existe = 1;
  500.                break;
  501.            }
  502.            fread(&(*producto), sizeof(*producto), 1, archivo);
  503.        }
  504.  
  505.        /* Cierra el archivo */
  506.        fclose(archivo);
  507.    }
  508.  
  509.    return existe;
  510. }
  511.  
  512. char insertarProducto(Producto producto)
  513. {
  514.    FILE *archivo;
  515.    char insercion;
  516.  
  517.    /* Abre el archivo para agregar datos al final */
  518.    archivo = fopen("productos.dat", "ab");    /* Añade datos al final. Si el archivo no existe, es creado */
  519.  
  520.    if (archivo == NULL) { /* Si no se pudo abrir el archivo, el valor de archivo es NULL */
  521.        insercion = 0;
  522.  
  523.    } else {
  524.        fwrite(&producto, sizeof(producto), 1, archivo);
  525.        insercion = 1;
  526.  
  527.        /* Cierra el archivo */
  528.        fclose(archivo);
  529.    }
  530.  
  531.    return insercion;
  532. }
  533.  
  534. /* ELiminación lógica de un registro */
  535. char eliminarProducto(int codigoProducto)
  536. {
  537.    FILE *archivo;
  538.    FILE *auxiliar;
  539.    Producto producto;
  540.    char elimina;
  541.  
  542.    /* Abre el archivo para leer */
  543.    archivo = fopen("productos.dat", "r+b");    /* Modo lectura/escritura. Si el archivo no existe, es creado */
  544.  
  545.    if (archivo == NULL) { /* Si no se pudo abrir el archivo, el valor de archivo es NULL */
  546.        elimina = 0;
  547.  
  548.    } else {
  549.        /* Se busca el registro que se quiere borrar. Cuando se encuentra, se sitúa en esa posición mediante la
  550.         función fseek y luego se modifica el campo clave de ese registro mediante algún valor centinela, eso se logra
  551.         con fwrite. Hasta allí se ha logrado una eliminación LÓGICA. Porque el registro sigue ocupando espacio en el archivo físico */
  552.  
  553.        elimina = 0;
  554.        fread(&producto, sizeof(producto), 1, archivo);
  555.        while (!feof(archivo)) {
  556.            if (producto.codigo == codigoProducto) {
  557.                fseek(archivo, ftell(archivo) - sizeof(producto), SEEK_SET);
  558.                producto.codigo = VALOR_CENTINELA;
  559.                fwrite(&producto, sizeof(producto), 1, archivo);
  560.                elimina = 1;
  561.                break;
  562.            }
  563.            fread(&producto, sizeof(producto), 1, archivo);
  564.        }
  565.  
  566.        /* Cierra el archivo */
  567.        fclose(archivo);
  568.    }
  569.  
  570.    return elimina;
  571. }
  572.  
  573. char eliminacionFisica()
  574. {
  575.    FILE *archivo;
  576.    FILE *temporal;
  577.    Producto producto;
  578.    char elimina = 0;
  579.  
  580.    archivo = fopen("productos.dat", "rb");
  581.    temporal = fopen("temporal.dat", "wb");
  582.  
  583.    if (archivo == NULL || temporal == NULL) {
  584.        elimina = 0;
  585.    } else {
  586.        /* Se copia en el archivo temporal los registros válidos */
  587.        fread(&producto, sizeof(producto), 1, archivo);
  588.        while (!feof(archivo)) {
  589.            if (producto.codigo != VALOR_CENTINELA) {
  590.                fwrite(&producto, sizeof(producto), 1, temporal);
  591.            }
  592.            fread(&producto, sizeof(producto), 1, archivo);
  593.        }
  594.        /* Se cierran los archivos antes de borrar y renombrar */
  595.        fclose(archivo);
  596.        fclose(temporal);
  597.  
  598.        remove("productos.dat");
  599.        rename("temporal.dat", "productos.dat");
  600.  
  601.        elimina = 1;
  602.    }
  603.  
  604.    return elimina;
  605. }
  606.  
  607. char modificarProducto(Producto producto)
  608. {
  609.    FILE *archivo;
  610.    char modifica;
  611.    Producto producto2;
  612.  
  613.    /* Abre el archivo para lectura/escritura */
  614.    archivo = fopen("productos.dat", "rb+");
  615.  
  616.    if (archivo == NULL) { /* Si no se pudo abrir el archivo, el valor de archivo es NULL */
  617.        modifica = 0;
  618.  
  619.    } else {
  620.        modifica = 0;
  621.        fread(&producto2, sizeof(producto2), 1, archivo);
  622.        while (!feof(archivo)) {
  623.            if (producto2.codigo == producto.codigo) {
  624.                fseek(archivo, ftell(archivo) - sizeof(producto), SEEK_SET);
  625.                fwrite(&producto, sizeof(producto), 1, archivo);
  626.                modifica = 1;
  627.                break;
  628.            }
  629.            fread(&producto2, sizeof(producto2), 1, archivo);
  630.        }
  631.  
  632.        fclose(archivo);
  633.    }
  634.  
  635.    /* Cierra el archivo */
  636.    return modifica;
  637. }
  638.  
  639. char guardarReporte()
  640. {
  641.    FILE *archivo;
  642.    char guardado;
  643.    Producto *productos;
  644.    int numeroProductos;
  645.    int i;
  646.    float costoTotal;
  647.    float precioTotal;
  648.    int cantidadTotal;
  649.  
  650.    productos = obtenerProductos(&numeroProductos); /* Retorna un vector dinámico de productos */
  651.  
  652.    if (numeroProductos == 0) {
  653.        guardado = 0;
  654.  
  655.    } else {
  656.        /* Abre el archivo en modo texto para escritura */
  657.        archivo = fopen("reporte.txt", "w");
  658.  
  659.        if (archivo == NULL) { /* Si no se pudo abrir el archivo, el valor de archivo es NULL */
  660.            guardado = 0;
  661.  
  662.        } else {
  663.            fprintf(archivo, "\n\t\t    ==> LISTADO DE PRODUCTOS REGISTRADOS <==\n");
  664.            fprintf(archivo, " ------------------------------------------------------------------------------\n");
  665.            fprintf(archivo, "%8s\t%-20s%15s%15s%10s\n", "CODIGO", "NOMBRE", "COSTO $", "PRECIO $", "CANTIDAD");
  666.            fprintf(archivo, " ------------------------------------------------------------------------------\n");
  667.  
  668.            /* Se recorre el vector dinámico de productos */
  669.            costoTotal = 0;
  670.            precioTotal = 0;
  671.            cantidadTotal = 0;
  672.            for (i = 0; i < numeroProductos; i++) {
  673.                if (productos[i].codigo != VALOR_CENTINELA) {
  674.                    fprintf(archivo, "%7d \t%-20.20s%15.1f%15.1f%8d\n", productos[i].codigo, productos[i].nombre, productos[i].costo, productos[i].precio, productos[i].cantidad);
  675.                    costoTotal += productos[i].costo;
  676.                    precioTotal += productos[i].precio;
  677.                    cantidadTotal += productos[i].cantidad;
  678.                }
  679.            }
  680.            fprintf(archivo, " ------------------------------------------------------------------------------\n");
  681.            fprintf(archivo, "\t\t\t      TOTAL: %15.1f%15.1f%8d", costoTotal, precioTotal, cantidadTotal);
  682.  
  683.            guardado = 1;
  684.  
  685.            /* Cierra el archivo */
  686.            fclose(archivo);
  687.        }
  688.    }
  689.  
  690.    return guardado;
  691. }
  692.  
  693. int leecad(char *cad, int n)
  694. {
  695.    int i, c;
  696.  
  697.    /* Hay que verificar si el buffer está limpio o si hay un '\n'
  698.       dejado por scanf y, en ese caso, limpiarlo:
  699.     */
  700.  
  701.    /* 1 COMPROBACIÓN DE DATOS INICIALES EN EL BUFFER */
  702.  
  703.    /* Empezamos leyendo el primer caracter que haya en la entrada. Si es
  704.       EOF, significa que no hay nada por leer, así que cerramos la cadena,
  705.       dejándola "vacía" y salimos de la función retornando un valor de 0
  706.       o falso, para indicar que hubo un error */
  707.    c = getchar();
  708.    if (c == EOF) {
  709.        cad[0] = '\0';
  710.        return 0;
  711.    }
  712.  
  713.    /* Si el valor leído es '\n', significa que había un caracter de nueva línea
  714.     dejado por un scanf o función similar. Simplemente inicializamos i a 0,
  715.     para indicar que los siguientes caracteres que leamos iremos asignando a
  716.     partir del primer caracter de la cadena. */
  717.    if (c == '\n') {
  718.        i = 0;
  719.    } else {
  720.    /* Si no había un '\n', significa que el caracter que leímos es el primer
  721.       caracter de la cadena introducida. En este caso, lo guardamos en la
  722.       posición 0 de cad, e inicializamos i a 1, porque en este caso, como ya
  723.       tenemos el primer caracter de la cadena, continuaremos agregando
  724.       caracteres a partir del segundo.
  725.  
  726.     */
  727.        cad[0] = c;
  728.        i = 1;
  729.    }
  730.  
  731.    /* 2. LECTURA DE LA CADENA */
  732.  
  733.    /* El for empieza con un ; porque estamos omitiendo la inicialización del contador,
  734.     ya que fue inicializado en el punto anterior.
  735.     Este código lee un caracter a la vez,lo agrega a cad, y se repite hasta que
  736.     se encuentre un fin de línea, fin de archivo, o haya leído la cantidad máxima
  737.     de caracteres que se le indicó. Luego, cierra la cadena agregando un '\0'
  738.     al final. Todo esto es muy similar a la forma en que los compiladores suelen
  739.     implementar la función fgets, sólo que en lugar de getchar usan getc o fgetc
  740.     */
  741.    for (; i < n - 1 && (c = getchar()) != EOF && c != '\n'; i++) {
  742.        cad[i] = c;
  743.    }
  744.    cad[i] = '\0';
  745.  
  746.    /*3. LIMPIEZA DEL BUFFER */
  747.  
  748.    /* Finalmente limpiamos el buffer si es necesario */
  749.    if (c != '\n' && c != EOF) /* es un caracter */
  750.        while ((c = getchar()) != '\n' && c != EOF);
  751.  
  752.    /* La variable c contiene el último caracter leído. Recordemos que había 3 formas
  753.     de salir del for: que hayamos encontrando un '\n', un EOF, o que hayamos llegado
  754.     al máximo de caracteres que debemos leer. Si se da cualquiera de los dos
  755.     primeros casos, significa que leímos todo lo que había en el buffer, por lo que
  756.     no hay nada que limpiar. En el tercer caso, el usuario escribió más caracteres
  757.     de los debidos, que aún están en el buffer, por lo que hay que quitarlos, para
  758.     lo cual usamos el método que vimos poco más arriba
  759.     */
  760.  
  761.    return 1;
  762. }
  763.  
  764. void tituloPrincipal()
  765. {
  766.    int i;
  767.    printf("\n     ======================================================================\n");
  768.    printf("\t\t\t     OPERACIONES CON ARCHIVOS\n");
  769.    printf("\t   Creación, reportes, eliminación, búsqueda y actualización\n");
  770.    printf("\t\t    Copyright 2016 | Algoritmos y Algo más\n");
  771.    printf("     ======================================================================\n");
  772.  
  773.    i = 0;
  774.    putchar('\n');
  775.    for (; i < 80; i++) {
  776.        putchar('_');
  777.    }
  778. }

MOD: Etiquetas GeSHi.


« Última modificación: 4 Julio 2019, 20:14 pm por MCKSys Argentina » En línea

K-YreX
Moderador
***
Desconectado Desconectado

Mensajes: 1.008



Ver Perfil
Re: Ayudaa a pasar este codigo en c a c++ :(
« Respuesta #1 en: 4 Julio 2019, 16:01 pm »

Ayudarte podemos ayudarte, en cambio; hacerte el trabajo, no.
Si tienes problemas con una parte en concreto especifica esa parte y coloca lo que llevas traducido para poder ayudarte de la forma más similar posible.
Y los códigos entre etiquetas de Código GeSHi... :rolleyes: :rolleyes:


En línea

Código
  1. cout << "Todos tenemos un defecto, un error en nuestro código" << endl;
Páginas: [1] Ir Arriba Respuesta Imprimir 

Ir a:  

Mensajes similares
Asunto Iniciado por Respuestas Vistas Último mensaje
quien me puede ayudar a pasar este codigo con punteros y memoria dinamica
Programación C/C++
attackers 3 2,727 Último mensaje 23 Noviembre 2011, 13:04 pm
por attackers
Pasar este código de VB a Java
Programación General
Baal_30 1 2,173 Último mensaje 17 Marzo 2016, 16:22 pm
por ivancea96
Ayuda para pasar este código de c a c++ :(
Programación C/C++
Tamaraxxx 1 3,907 Último mensaje 4 Junio 2018, 18:49 pm
por SrMcLister
Ayuda para pasar ESTE código hecho en JAVA A C++
Programación C/C++
Blazjker 5 2,697 Último mensaje 1 Marzo 2019, 03:00 am
por K-YreX
Pasar este código Java a C
Programación C/C++
Deivid_Math 3 5,057 Último mensaje 1 Mayo 2020, 22:21 pm
por Deivid_Math
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines