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

 

 


Tema destacado: Recuerda que debes registrarte en el foro para poder participar (preguntar y responder)


  Mostrar Temas
Páginas: [1]
1  Programación / Programación C/C++ / Ficheros/Archivos en c++ en: 1 Julio 2015, 04:32 am
Hola, estoy creando un programa que me de el promedio de agua gastada
semanalmente
ya cree el archivo .cvs y así
pero lo que no se es como ingresar los datos
ya intente de mil y un formas pero no se ponen los datos
si alguien supiera decirme que estoy haciendo mal,
o si hay algun comando para poder hacerlo,
gracias
Código
  1. #include<iostream>
  2. #include<fstream>
  3. using namespace std;
  4. #include<stdlib.h>
  5. #include<conio.h>
  6. int main()
  7. {
  8.     int l ,m ,mi, j, v,s,d;
  9. char cad[100];
  10. ofstream sal("libro.csv");
  11. sal<<" _,lunes, martes, miercoles,jueves, viernes, sabado, domingo"<<endl;
  12. sal<<"Litros de agua diarios, 3 , 3 , 3 , 3 , 3 , 3 , 3 "<<endl;
  13. sal<<"horas de baño: ";
  14. cin>>l>>m>>mi>>j>>v>>s>>d;
  15. sal<<, l, m, mi, j, v, s, d<<endl<<endl;
  16.  
  17. sal<<"Promedio:"<<endl;
  18. sal<<",,,,,,,promedio semanal";
  19.  
  20. sal.close();
  21. ifstream ent("libros.txt");
  22. while(ent.getline(cad,100))
  23. {cout<<cad<<endl;
  24. }
  25.  
  26. ent.close();
  27. cin.get();
  28. return 0;
  29. }
  30.  
2  Programación / Programación C/C++ / Pilas y colas en: 19 Junio 2015, 01:06 am
Hola, hice este programa donde se tiene que usar colas y pilas para poder balancear una ecuacion, es decir, si pongo mas parentesis de lo debido me debe aparecer que le faltan parentesis
si no pues solo poner que esta correcto.
pero me marca error, y la verdad no se porque
si alguien me pudiera ayudar y/o asesorar porfavor, gracias

Código
  1.  #include <iostream>
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <conio.h>
  5. #include <string.h>
  6. using namespace std;
  7.  
  8. class nodo{
  9.     private:
  10.         nodo *siguiente;
  11.         char parentesis;
  12.     public:
  13.         nodo(char p, nodo *s=NULL){parentesis=p; siguiente=s;}
  14.         nodo* regresaSiguiente(void); //{return siguiente;}
  15.         char regresaParentesis(void);
  16.         void modificaParentesis(char);
  17.         void modificaSiguiente(nodo*);
  18.  
  19. };
  20.  
  21.  
  22. nodo* nodo::regresaSiguiente(void)
  23. {
  24.     return siguiente;
  25. }
  26.  
  27. char nodo::regresaParentesis(void)
  28. {
  29.     return parentesis;
  30. }
  31.  
  32. void nodo::modificaParentesis(char p)
  33. {
  34.     parentesis=p;
  35. }
  36.  
  37. void nodo::modificaSiguiente(nodo* s){
  38.     siguiente=s;
  39. }
  40. ////////////////////////////////////FIN DE LA CLASE NODO///////////////////////////////////////
  41.  
  42. class Pila
  43. {
  44. private:
  45.     nodo*tope;
  46. public:
  47.     Pila(){tope=NULL;}
  48.     void Push(char);
  49.     char Pop(void);
  50.     char Tope(void)
  51.     {return tope-> regresaParentesis();}
  52.     char PilaVacia()
  53.     {return tope == NULL;}
  54.  
  55. };
  56.  
  57. void Pila::Push(char p)
  58. {
  59.     tope=new nodo(p, tope);
  60. }
  61.  
  62. char Pila::Pop(void)
  63. {
  64.     char p;
  65.     nodo*aux;
  66.     delete(aux);
  67.     return p;
  68.     if(!PilaVacia());
  69. }
  70.  
  71.  
  72. class Cola
  73. {
  74. private:
  75.     nodo*cabeza;
  76.     nodo*extremo;
  77.  
  78. public:
  79.     Cola(){cabeza=extremo=NULL;}
  80.     void Suma(char);
  81.     char Elimina(void);
  82.     int colaVacia(void){return cabeza==NULL;}
  83.     //~ Cola();
  84.  
  85. };
  86.  
  87. void Cola::Suma(char p)
  88. {
  89.     if(!extremo)
  90.     {
  91.  
  92.         extremo=cabeza=new nodo(p,NULL);
  93.         //extremo=cabeza;
  94.     }
  95.     else{
  96.         nodo*aux;
  97.         aux=new nodo(p);
  98.         extremo-> modificaSiguiente(aux);
  99.         extremo=extremo -> regresaSiguiente();
  100.  
  101.     }
  102.  
  103. }
  104.  
  105. char Cola::Elimina(void)
  106. {
  107.     char p=-1;
  108.     if(!colaVacia())
  109.     {
  110.     nodo*aux=cabeza;
  111.     cabeza=cabeza->regresaSiguiente();
  112.     p=aux->regresaParentesis();
  113.     delete(aux);
  114.     }
  115.  
  116.     return p;
  117. }
  118.  
  119.  
  120.  
  121. int main()
  122. {
  123.     char caracter[10];
  124.     int i;
  125.     char c;
  126.     Cola obj;
  127.     Pila p;
  128.  
  129.     cout<<"escribe la funcion: "<< endl;
  130.     cin.getline(caracter,10);
  131.  
  132.   while( caracter[i] != '\0')
  133.     {
  134.         obj.Suma(caracter[i]);
  135.     }
  136.  
  137.     while(!obj.colaVacia())
  138.     {
  139.         c=obj.Elimina();
  140.         if(c=='(')
  141.            {
  142.             p.Push(c);
  143.            }
  144.         else if(c==')')
  145.             {
  146.             p.Pop(c);
  147.             }
  148.     }
  149.     if(!p.PilaVacia())
  150.     {
  151.  
  152.         cout<<"Falta un parentesis "<<endl;
  153.     }
  154. if(p.PilaVacia())
  155. {
  156. cout<<"Todo esta bien"<<endl;
  157. }
  158.  
  159.     return 0;
  160.  
  161.  
  162. }
3  Programación / Programación C/C++ / Listas enlazadas C++, struct a clases en: 5 Mayo 2015, 22:37 pm
Hola, buenas tardes, quisiera saber si alguien me podría ayudar,
hice un programa de listas enlazadas, pero use struct, ya que se me hacia mas facil crear un programa así, pero mi maestra me dijo que no tenia que ser con struct, sino con CLASES, y no se como hacer mi mismo programa pero con clases,
alguien que me pueda orientar o ayudar porfavor?
MUCHAS GRACIAS
_________________________________________________
Este es mi programa


Código
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4. #include<conio.h>
  5. #include <iostream>
  6. using namespace std;
  7.  
  8. typedef struct dato nodo;
  9.  
  10. nodo* crear_lista(nodo* lista);
  11. nodo* ingresar_dato(char* nombre, int boleta, nodo* lista);
  12.  
  13. void mostrar_lista(nodo* lista);
  14. void mostrar_nodo(nodo* elemento);
  15. void menu(void);
  16.  
  17. void borrar_lista(nodo* lista);
  18. nodo* borrar_nodoxnombre(char *nombre, nodo* lista);
  19. nodo* borrar_nodoxnota(int boleta, nodo* lista);
  20.  
  21. nodo* buscar_nodo(nodo* lista, char *caracter);
  22. void ordenar_lista(nodo* lista);
  23.  
  24.  
  25.  
  26. struct dato
  27.     {
  28.     char nombre[80];
  29.     int nota;
  30.     struct dato *sig;
  31.     };
  32.  
  33. nodo* crear_lista(nodo* lista)
  34.     {
  35.     return (lista = NULL);
  36.     }
  37.  
  38. nodo* ingresar_dato(char* nombre, int boleta, nodo* lista)
  39.     {
  40.     nodo *nuevo_dato;
  41.     nodo *auxiliar = NULL;
  42.  
  43.     nuevo_dato = (nodo*)malloc(sizeof(nodo));
  44.  
  45.     if(nuevo_dato != NULL)
  46.         {
  47.         strcpy((nuevo_dato->nombre), nombre);
  48.         nuevo_dato->nota = boleta;
  49.         nuevo_dato->sig = NULL;
  50.  
  51.         if(lista == NULL)
  52.             lista = nuevo_dato;
  53.         else
  54.             {
  55.             auxiliar = lista;
  56.             while(auxiliar->sig != NULL)
  57.                 auxiliar = auxiliar->sig;
  58.             auxiliar->sig = nuevo_dato;
  59.             }
  60.         }
  61.     else
  62.          cout<<"\n\nNo se pudo reservar memoria\n\n";
  63.     return lista;
  64.     }
  65.  
  66. void mostrar_lista(nodo* lista)
  67.     {
  68.     nodo *auxiliar;
  69.     int contador = 0;
  70.  
  71.     if(lista == NULL)
  72.         cout<<"\n\nLa lista esta vacia\n\n";
  73.  
  74.     auxiliar = lista;
  75.     while(auxiliar != NULL)
  76.         {
  77.          cout<<"\n\nPersona"<<(contador+1);
  78.          cout<<"\nNombre y Apellido: "<<auxiliar->nombre;
  79.          cout<<"\n\nBoleta:      "<< auxiliar->nota;
  80.         contador++;
  81.  
  82.         auxiliar = auxiliar->sig;
  83.         }
  84.    cout<<"\nFin de lista\n\n";
  85.     }
  86.  
  87. void borrar_lista(nodo* lista)
  88.     {
  89.     nodo *borra;
  90.  
  91.     borra = lista;
  92.     while(borra)
  93.         {
  94.         lista = lista->sig;
  95.         free(borra);
  96.         borra = lista;
  97.         }
  98.     }
  99.  
  100. void menu(void)
  101.     {
  102.  
  103.      cout<<"\n\nLista_Practica_3             3CM7:\n\n";
  104.      cout<<"1) Ingresar dato\n";
  105.     cout<<"2) Mostrar lista\n";
  106.    cout<<"3) Borrar lista\n";
  107.     cout<<"4) Borrar por nombre\n";
  108.      cout<<"5) Borrar por boleta\n";
  109.      cout<<"6) Buscar en lista\n";
  110.      cout<<"7) Ordenar lista\n";
  111.     cout<<"0)SALIR\n\n";
  112.  
  113.  
  114.     }
  115.  
  116. nodo* borrar_nodoxnombre(char *nombre, nodo* lista)
  117.      {
  118.     if(lista != NULL)
  119.         {
  120.         nodo *ptraux;
  121.         nodo *ptranterior = NULL;
  122.         int cont;
  123.  
  124.         ptraux = lista;
  125.         while(ptraux != NULL && (strcmp(ptraux->nombre, nombre) != 0))
  126.             {
  127.             ptranterior = ptraux;
  128.             ptraux = ptraux->sig;
  129.             cont++;
  130.             }
  131.         if(cont == 1 && ptraux->sig == NULL)
  132.             {
  133.             free(ptraux);
  134.             lista = NULL;
  135.             }
  136.         if(ptraux == NULL)
  137.             cout<<"\n\nNo se encontro una persona con ese nombre\n\n";
  138.         else if(ptranterior == NULL)
  139.             {
  140.             lista = lista->sig;
  141.             free(ptraux);
  142.             }
  143.         else
  144.             {
  145.             ptranterior->sig = ptraux->sig;
  146.             free(ptraux);
  147.             }
  148.         }
  149.  
  150.     return lista;
  151.     }
  152.  
  153. nodo* borrar_nodoxnota(int boleta, nodo* lista)
  154.         {
  155.     if(lista != NULL)
  156.         {
  157.         nodo *ptraux;
  158.         nodo *ptranterior = NULL;
  159.         int cont = 0;
  160.  
  161.         ptraux = lista;
  162.         while(ptraux != NULL && ptraux->nota != boleta)
  163.             {
  164.             ptranterior = ptraux;
  165.             ptraux = ptraux->sig;
  166.             cont++;
  167.             }
  168.         if(cont == 1 && ptraux->sig == NULL)
  169.             {
  170.             free(ptraux);
  171.             lista = NULL;
  172.             }
  173.         if(ptraux == NULL)
  174.             cout<<"\n\nNo se encontro una persona con ese numero de boleta\n\n";
  175.         else if(ptranterior == NULL)
  176.             {
  177.             lista = lista->sig;
  178.             free(ptraux);
  179.             }
  180.         else
  181.             {
  182.             ptranterior->sig = ptraux->sig;
  183.             free(ptraux);
  184.             }
  185.         }
  186.  
  187.     return lista;
  188.     }
  189.  
  190. nodo* buscar_nodo(nodo* lista, char *caracter)
  191.     {
  192.     nodo *aux;
  193.     char noabuscar[20];
  194.     char a[] = "a";
  195.     char b[] = "b";
  196.     int nabuscar;
  197.     if(lista != NULL)
  198.         {
  199.         if(strcmp(caracter,a) == 0)
  200.             {
  201.             cout<<"\n\nIngrese el nombre a buscar: ";
  202.             fflush(stdin);
  203.             fgets(noabuscar, 20, stdin);
  204.             aux = lista;
  205.             while(aux != NULL)
  206.                 {
  207.                 if(strcmp(aux->nombre, noabuscar) == 0)
  208.                     return aux;
  209.                 aux = aux->sig;
  210.                 }
  211.             return aux;
  212.             }
  213.         else if(strcmp(caracter,b) == 0)
  214.             {
  215.             cout<<"\n\nIngrese la nota a buscar: ";
  216.             fflush(stdin);
  217.             cout<<nabuscar;
  218.             aux = lista;
  219.             while(aux != NULL)
  220.                 {
  221.                 if(aux->nota == nabuscar)
  222.                     return aux;
  223.                 aux = aux->sig;
  224.                 }
  225.             return aux;
  226.             }
  227.          else
  228.             {
  229.             cout<<"\n\nOpcion no valida\n\n";
  230.             return 0;
  231.             }
  232.         }
  233.     }
  234.  
  235. void mostrar_nodo(nodo* elemento)
  236.     {
  237.     nodo* nodoencontrado;
  238.     nodoencontrado = elemento;
  239.     if(nodoencontrado == NULL)
  240.        cout<<"\n\nNo se obtuvieron resultados\n\n";
  241.  
  242.  
  243.     else
  244.         {
  245.         cout<<"\n\nNodo encontrado:\n\n";
  246.         cout<<"\nNompre y apellido:"<< nodoencontrado->nombre;
  247.         cout<<"\nBoleta:  "<< nodoencontrado->nota;
  248.  
  249.         }
  250.     }
  251. /*    \n\n\n\n   */
  252.  
  253. void ordenar_lista(nodo* lista)
  254.     {
  255.     nodo *anterior;
  256.     nodo *siguiente;
  257.     nodo temp;
  258.  
  259.     anterior = lista;
  260.  
  261.     while(anterior->sig != NULL)
  262.         {
  263.         siguiente = anterior->sig;
  264.  
  265.         while(siguiente != NULL)
  266.             {
  267.             if(strcmp(anterior->nombre, siguiente->nombre) > 0)
  268.                 {
  269.                 strcpy(temp.nombre, siguiente->nombre);
  270.                 temp.nota = siguiente->nota;
  271.                 strcpy(siguiente->nombre, anterior->nombre);
  272.                 siguiente->nota = anterior->nota;
  273.                 strcpy(anterior->nombre, temp.nombre);
  274.                 anterior->nota = temp.nota;
  275.                 }
  276.             siguiente = siguiente->sig;
  277.             }
  278.         anterior = anterior->sig;
  279.         siguiente = anterior->sig;
  280.         }
  281. cout<<"\n\nLista ordenada\n\n";
  282.  
  283.  
  284.     }
  285.  
  286.     int main(int argc, char** argv)
  287.     {
  288.     nodo *inicio;
  289.     nodo *nodobuscado;
  290.     char nom[20];
  291.     char nomaborrar[20];
  292.     int nborrar;
  293.     int nota, i, cant, op;
  294.     char s[2];
  295.  
  296.     inicio = crear_lista(inicio);
  297.  
  298.     menu();
  299.     cin>>op;
  300.     while(op != 0)
  301.         {
  302.         switch(op)
  303.             {
  304.             case 1: cout<<"\n\nQue cantidad de datos ingresara: ";
  305.                     cin>>cant;
  306.                     cout<<"\n\n";
  307.  
  308.                     cout<<"Ingreso de datos:\n\n";
  309.                     for(i=0 ; i < cant ; i++)
  310.                         {
  311.                         cout<<"Nombre y apellido: ";
  312.                         fflush(stdin);
  313.                         fgets(nom, 80, stdin);
  314.                        cout<<"\nBoleta:      ";
  315.                         fflush(stdin);
  316.                         cin>>nota;
  317.                         cout<<"\n\n";
  318.                         inicio = ingresar_dato(nom, nota, inicio);
  319.                         }
  320.                     break;
  321.  
  322.             case 2: mostrar_lista(inicio);
  323.                     break;
  324.  
  325.             case 3: borrar_lista(inicio);
  326.                     free(inicio);
  327.                     cout<<"\n\nLista Borrada\n\n";
  328.                     inicio = NULL;
  329.                     break;
  330.  
  331.             case 4: cout<<"\n\nIngrese el nombre a borrar\n\n";
  332.                     fflush(stdin);
  333.                     fgets(nomaborrar, 80, stdin);
  334.                     inicio = borrar_nodoxnombre(nomaborrar, inicio);
  335.                     break;
  336.  
  337.             case 5: cout<<"\n\nIngrese la nota a borrar\n\n";
  338.                     fflush(stdin);
  339.                     cin>>nborrar;
  340.                     inicio = borrar_nodoxnota(nborrar, inicio);
  341.                     break;
  342.  
  343.             case 6: cout<<"\n\n('a') para buscar por nombre || ('b') para buscar por nota\n\n";
  344.                     fflush(stdin);
  345.                     fgets(s, 2, stdin);
  346.                     nodobuscado = buscar_nodo(inicio, s);
  347.                     mostrar_nodo(nodobuscado);
  348.                     break;
  349.  
  350.             case 7: ordenar_lista(inicio);
  351.                     break;
  352.  
  353.  
  354.  
  355.             default: cout<<"\n\n Este no es una opcion, intentelo nuevamente// \n\n";
  356.             }
  357.              getch();
  358.             system("cls");
  359.         menu();
  360.         cin>>op;
  361.         }
  362.  
  363.  
  364.     return (EXIT_SUCCESS);
  365.     }
Páginas: [1]
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines