• Viernes 29 de Marzo de 2024, 11:33

Mostrar Mensajes

Esta sección te permite ver todos los posts escritos por este usuario. Ten en cuenta que sólo puedes ver los posts escritos en zonas a las que tienes acceso en este momento.


Mensajes - Checho360

Páginas: [1] 2 3 4
1
Visual C++ / Re:Codigo con vectores problema
« en: Lunes 22 de Agosto de 2011, 22:47 »
El error es que haces comparaciones entre un puntero y un entero. Si haces edad > 5 o edad == 5 o cualquier comparacion de este tipo te dará error. edad es un array con lo cual edad almacenará la dirección del primer elemento, para que te funcione bien modifica edad por
Código: C++
  1. edad[i]

Un saludo!

2
Java / Clases y objetos
« en: Sábado 20 de Agosto de 2011, 15:47 »
Hola, un par de preguntillas tontas (estoy empezando con java). Veamos en primer lugar, todas los nuevos objetos que quieres crear (que no sean de tipos primitivos) a partir de una clase se tienen que crear con el operador new ? es decir:

MiClase nuevoObjeto = new Miclase;

si esto es asi, como es que para utilizar un metodo de JOptionPane no hay que crear un objeto de esta clase? es decir sin falta de crear ningun objeto puedes hacer:

JOptionPane.showMessageDialog (null, "Hola");

o tambien:

system.out.println("Hola");

son objetos que se crean (como cout en el namespace std de c++) o como va el tema?

Un saludo y gracias !!

3
C/C++ / Re:Problema al hacer una Agenda Telefonica en C++
« en: Viernes 19 de Agosto de 2011, 17:35 »
No he mirao el alogritmo, pero a simple vista se ve que creas un vector de 10 elementos de la estructura Dato. Si quieres referirte a un elemento del vector en concreo tienes que hacer persona
  • .* , es decir el primer nombre del vector sería persona[0].nombre. Prueba a cambiar eso aver si tienes algun error mas jeje

4
C/C++ / Re:Sobrecarga de << con template
« en: Domingo 14 de Agosto de 2011, 13:17 »
Si, ya lo hice jeje. Lo resolvi sobrecargando tambien el operador << en PILA_DATOS, asi cuando recibia el operador << con un elemento de PILA este hace

cout << *ptrPila;

y asi llama al de PILA_DATOS y este ya puede acceder. Mira:

Código: C++
  1. #include <iostream>
  2. #include <new>
  3. using namespace std;
  4.  
  5. template< class T >
  6. class PILA_DATOS{
  7.       template< class t > friend class PILA;
  8.      
  9.       public:
  10.              template< class U > friend ostream& operator<< ( ostream &,
  11.              const PILA_DATOS< U > & );
  12.              PILA_DATOS< T > &operator= ( PILA_DATOS< T > & );
  13.       private:
  14.               T nodo;
  15.               PILA_DATOS< T > *ptrPilaSiguiente;
  16.              
  17. };
  18.  
  19. template< class U > ostream& operator<< ( ostream &salida,
  20. const PILA_DATOS< U > &a ){
  21.      
  22.       salida << a.nodo << "->";
  23.       PILA_DATOS< U > *b = a.ptrPilaSiguiente;
  24.       while ( b != NULL ){
  25.             salida << b->nodo << "->";
  26.             b = b->ptrPilaSiguiente;
  27.       }
  28.       salida << "NULL" << endl;
  29.       return salida;
  30.      
  31. }
  32. template< class T >
  33. PILA_DATOS< T >& PILA_DATOS< T >::operator= ( PILA_DATOS< T > &a ){
  34.            
  35.             nodo = a.nodo;
  36.             ptrPilaSiguiente = a.ptrPilaSiguiente;
  37.             return *this;
  38.            
  39. }      
  40.  
  41. template< class T >
  42. class PILA{
  43.       public:
  44.              PILA ();
  45.              ~PILA ();
  46.              PILA< T > &empujarPila ( const T& );
  47.              PILA< T > &sacarPila ();
  48.              PILA< T > &mostrarPila ();
  49.              template< class U > friend ostream& operator<< ( ostream &,
  50.              const PILA< U > & );
  51.       private:
  52.               PILA_DATOS< T > *ptrPila;
  53.               bool estaVacia ();
  54.              
  55. };
  56.  
  57. template< class T >
  58. PILA< T >::PILA (){
  59.      
  60.       ptrPila = NULL;
  61.      
  62. }
  63.  
  64. template< class T >
  65. PILA< T >::~PILA (){
  66.      
  67.       while ( ptrPila != NULL ){
  68.             PILA_DATOS< T > *temp = ptrPila;
  69.             ptrPila = ptrPila->ptrPilaSiguiente;
  70.             delete temp;
  71.       }
  72.      
  73. }
  74.  
  75. template< class T >
  76. bool PILA< T >::estaVacia (){
  77.      
  78.      return ( ptrPila == NULL ? true : false );
  79.      
  80. }
  81.  
  82. template< class T >
  83. PILA< T > &PILA< T >::empujarPila ( const T &a ){
  84.        
  85.         if ( estaVacia () ){
  86.              
  87.              ptrPila = new PILA_DATOS< T >;
  88.              ptrPila->nodo = a;
  89.              ptrPila->ptrPilaSiguiente = NULL;
  90.              
  91.         }
  92.        
  93.         else{
  94.              
  95.              PILA_DATOS< T > *nuevaPila;
  96.              nuevaPila= new PILA_DATOS< T >;
  97.              nuevaPila->nodo = a;
  98.              nuevaPila->ptrPilaSiguiente = ptrPila;
  99.              ptrPila = nuevaPila;
  100.              
  101.         }
  102.        
  103.         return *this;
  104.        
  105. }
  106.  
  107. template< class T >
  108. PILA< T > &PILA< T >::sacarPila (){
  109.      
  110.       PILA_DATOS< T > *temp;
  111.       temp = ptrPila;
  112.       ptrPila = ptrPila->ptrPilaSiguiente;
  113.       delete temp;
  114.       return *this;
  115.      
  116. }
  117.  
  118. template< class T >
  119. PILA< T > &PILA< T >::mostrarPila (){
  120.      
  121.       PILA_DATOS< T > *a = ptrPila;
  122.       while ( a != NULL ){
  123.             cout << a->nodo << "->";
  124.             a = a->ptrPilaSiguiente;
  125.       }
  126.       cout << "NULL" << endl;
  127.       return *this;
  128.      
  129. }
  130.  
  131. template< class U > ostream& operator<< ( ostream &salida,
  132. const PILA< U > &a ){
  133.      
  134.       salida << *( a.ptrPila );
  135.       return salida;
  136.      
  137. }
  138.  
  139. int main (){
  140.    
  141.     PILA< float > *a = new PILA< float >;
  142.     cout << *a;
  143.    
  144.     getchar();
  145.     return 0;
  146.    
  147. }
  148.  

Agradeceria cualquier recomendación de hacer algo mejor, sugerencias para hacer la clase más grande y ese tipo de cosas :P también le he añadido un destructor para reclamar el espacio asignado dinámicamente. Por cierto, es mucho más fácil hacerlo con estructuras no? yo había hecho estos ejercicios en C y me resultaron bastante más fácil xd

Un saludo y gracias por responder!!

5
Se me ocurrio esto, igual lo hice muy dificil y se puede hacer más fácil jaja

Código: C++
  1. #include <iostream>
  2. using namespace std;
  3.  
  4. int main (){
  5.    
  6.     char *cadena = ( char* ) calloc ( 30, sizeof ( char ) );
  7.    
  8.     printf ( "%s", "Introduce una cadena MAX. 30 : " );
  9.     scanf ( "%s", cadena );
  10.     getchar ();
  11.    
  12.     int tam = strlen ( cadena );
  13.     int a;
  14.    
  15.     if ( tam % 3 == 0 )
  16.         a = tam + tam / 3 - 1;
  17.     else
  18.         a = tam + tam / 3;
  19.    
  20.     realloc ( cadena, a * sizeof ( char ) );
  21.     char *cadena1 = ( char* ) calloc ( a, sizeof ( char ) );
  22.    
  23.     for ( int i = tam, j = 0, k = a; i >= 0; i--, j++, k-- ){
  24.        
  25.         if ( j % 3 == 0 && j != 0 ){
  26.            
  27.            cadena1[k] = cadena[i];
  28.            k--;
  29.            cadena1[k] = '.';
  30.            
  31.         }
  32.        
  33.         else{
  34.              
  35.              cadena1[k] = cadena[i];
  36.              
  37.         }
  38.        
  39.     }
  40.    
  41.     memcpy ( cadena, cadena1, a );
  42.     free ( cadena1 );
  43.    
  44.     printf ( "%s", cadena );
  45.        
  46.     getchar();
  47.     return 0;
  48.    
  49. }
  50.  

Utilizo algunas funciones de la librería esta estándar... se pueden hacer manualmente facilmente, si no entiendes algo te intento explicar...

Un saludo!

6
C/C++ / Sobrecarga de << con template
« en: Viernes 12 de Agosto de 2011, 16:19 »
Hola, estoy creando una clase pila y de momento iba todo bien, pero cuando me he puesto a sobrecargar el operador <<... no encuentro solución. Estuve mirando un rato por google y hay algo de información pero no entiendo muy bien... Aver si alguien me puede ayudar. Dejo el código para que se vean bien los errores al compilar:

Código: C++
  1. #include <iostream>
  2. #include <new>
  3. using namespace std;
  4.  
  5. template< class T >
  6. class PILA_DATOS{
  7.       template< class t > friend class PILA;
  8.       private:
  9.               T nodo;
  10.               PILA_DATOS< T > *ptrPilaSiguiente;
  11.              
  12. };
  13.  
  14. template< class T >
  15. class PILA{
  16.       friend ostream &operator<< <T>( ostream &, const PILA< T > & );
  17.       public:
  18.              PILA();
  19.              PILA< T > &empujarPila ( const T& );
  20.              PILA< T > &sacarPila ();
  21.       private:
  22.               PILA_DATOS< T > *ptrPila;
  23.               bool estaVacia ();
  24.              
  25. };
  26.  
  27. template< class T >
  28. PILA< T >::PILA (){
  29.      
  30.       ptrPila = NULL;
  31.      
  32. }
  33.  
  34. template< class T >
  35. bool PILA< T >::estaVacia (){
  36.      
  37.      return ( ptrPila == NULL ? true : false );
  38.      
  39. }
  40.  
  41. template< class T >
  42. PILA< T > &PILA< T >::empujarPila ( const T &a ){
  43.        
  44.         if ( estaVacia () ){
  45.              
  46.              ptrPila = new PILA_DATOS< T >;
  47.              ptrPila->nodo = a;
  48.              ptrPila->ptrPilaSiguiente = NULL;
  49.              
  50.         }
  51.        
  52.         else{
  53.              
  54.              PILA_DATOS< T > *nuevaPila;
  55.              nuevaPila= new PILA_DATOS< T >;
  56.              nuevaPila->nodo = a;
  57.              nuevaPila->ptrPilaSiguiente = ptrPila;
  58.              ptrPila = nuevaPila;
  59.              
  60.         }
  61.        
  62.         return *this;
  63.        
  64. }
  65.  
  66. template< class T >
  67. PILA< T > &PILA< T >::sacarPila (){
  68.      
  69.       PILA_DATOS< T > *temp;
  70.       temp = ptrPila;
  71.       ptrPila = ptrPila->ptrPilaSiguiente;
  72.       delete temp;
  73.       return *this;
  74.      
  75. }
  76.  
  77. template< class T >
  78. ostream &operator<<( ostream &salida, const PILA< T > &pila ){
  79.        
  80.         PILA_DATOS< T > *a = pila.ptrPila;
  81.         while ( a != NULL ){
  82.              
  83.               salida << a->nodo << "->";
  84.               a = a->ptrPilaSiguiente;
  85.              
  86.         }
  87.         salida << "NULL\n";
  88.         return salida;
  89.        
  90. }
  91.  
  92. int main (){
  93.    
  94.     PILA< int > a;
  95.     a.empujarPila (2).empujarPila (3).empujarPila(23).empujarPila (25);
  96.     cout << a;
  97.     a.sacarPila().sacarPila();
  98.     cout << a;
  99.    
  100.     getchar();
  101.    
  102.     return 0;
  103.    
  104. }
  105.  

Muchas gracias!

7
C/C++ / Re:Referncias &
« en: Miércoles 3 de Agosto de 2011, 12:41 »
Nah, ya me lo han explicao en otro foros. que parao esta esto no ? xd

8
C/C++ / Referncias &
« en: Martes 2 de Agosto de 2011, 23:15 »
Hola, me gustaría saber que diferencia hay entre:

int &maximo (int a, int b) {return ( a>b a : b )}

int maximo (int a, int b){return ( a>b a : b )}

La diferencia que yo veo es que con el primero puedo hacer:

int & c = maximo (a, b);

pero no entiendo muy bien por que. Alguien que me pueda instruir un poco del tema??

Un saludo!!

9
C/C++ / Re:numeros capicua
« en: Viernes 29 de Julio de 2011, 00:50 »
En la función utilizas auxi como si fuera una cadena y es un apuntador a char. Tendrías que usar calloc para hacer eso.

10
C/C++ / Re:Infijo a postfijo
« en: Martes 26 de Julio de 2011, 03:39 »
Ya está resuelto, no hace falta que nadie responda

11
C/C++ / Infijo a postfijo
« en: Lunes 25 de Julio de 2011, 16:39 »
Hola, estoy haciendo un programa que me convierta una expresion infijo a postfijo. El programa funcionar funciona, pero añade caracteres extraños al final de la cadena a veces o imprime un intro o cosas asi.

Código: C
  1. //##############################################################################
  2.  
  3. //Encabezados necesarios para el programa:
  4.  
  5. #include <stdio.h>
  6.  
  7. #include <stdlib.h>
  8.  
  9. #include <E:\C\encabezados\estructuras.h>
  10.  
  11. //##############################################################################
  12.  
  13. //Este programa recibe una expresion "infijo" y la devuelve en formato
  14. //"postfijo"
  15.  
  16. //##############################################################################
  17.  
  18. //#############################PROTOTIPOS#######################################
  19.  
  20. int tam_infijo (char * array);
  21.  
  22. char * scan_infijo ();
  23.  
  24. int esOperador (char c);
  25.  
  26. int esParentesis (char c);
  27.  
  28. int precedencia (char operador1, char operador2);
  29.  
  30. void inFijo2postFijo (char inFijo[], char postFijo[]);
  31.  
  32. //##############################################################################
  33.  
  34. //##############################FUNCIONES#######################################
  35.  
  36. int tam_infijo (char * array){
  37.    
  38.     int cont = 0;
  39.    
  40.     while ( *( array + cont ) != '\0' ){
  41.          
  42.           cont++;
  43.          
  44.     }
  45.    
  46.     return cont - 1;
  47.    
  48. }
  49.  
  50. char * scan_infijo (){
  51.    
  52.     char * expresion;
  53.    
  54.     expresion = (char*) calloc (200, sizeof (char));
  55.    
  56.     scanf("%s", expresion);
  57.    
  58.     getchar();
  59.    
  60.     expresion = (char*) realloc (expresion, sizeof(char) *
  61.    
  62.     ( tam_infijo (expresion) + 1) );
  63.    
  64. }
  65.  
  66. int esOperador (char c){
  67.    
  68.     return c == '+' || c == '-' || c == '*' || c == '/';
  69.    
  70. }
  71.  
  72. int esParentesis (char c){
  73.    
  74.     if ( c == '(' ){
  75.          
  76.          return 1;
  77.    
  78.     }
  79.    
  80.     else if ( c == ')' ){
  81.          
  82.          return -1;
  83.          
  84.     }
  85.    
  86.     else return 0;
  87.    
  88. }
  89.  
  90. int precedencia (char operador1, char operador2){
  91.    
  92.     if ( ( operador1 == '*' || operador1 == '/' ) && ( operador2 == '+'
  93.    
  94.     || operador2 == '-' ) ) return 1; //Precedencia del operador 1 mayor
  95.    
  96.     else if ( ( operador1 == '+' || operador1 == '-' ) && ( operador2 == '*'
  97.    
  98.     || operador2 == '/' ) ) return 0; //Precedencia del operador 1 menor
  99.    
  100.     else return -1; //Precedencia del operador 1 igual que la del operador 2
  101.  
  102. }
  103.  
  104. void inFijo2postFijo (char inFijo[], char postFijo[]){
  105.      
  106.      ptrNuevaPila pila = NULL;
  107.      
  108.      int i = 0, j = 0;
  109.      
  110.      empujar_pila ( &pila, '(' );
  111.      
  112.      inFijo = (char*)
  113.      
  114.      realloc (inFijo, ( ( ( tam_infijo (inFijo) ) + 2 ) * sizeof (char) ) );
  115.      
  116.      inFijo [tam_infijo (inFijo)] = ')';
  117.      
  118.      inFijo [tam_infijo (inFijo) + 1] = '\0';
  119.      
  120.      while ( pila != NULL ){
  121.            
  122.            if ( esOperador ( inFijo [i] ) ){
  123.                
  124.                 while ( ( esOperador ( pila->dato ) ) && (
  125.                
  126.                 precedencia (inFijo [i], pila->dato ) == 0 ||
  127.                
  128.                 precedencia (inFijo [i], pila->dato ) == -1 ) ) {
  129.                            
  130.                             postFijo [j] = pila->dato;
  131.                            
  132.                             j++;
  133.                            
  134.                             sacar_pila( &pila );
  135.                            
  136.                 }
  137.                
  138.                 empujar_pila ( &pila, inFijo [i] );
  139.                
  140.            }
  141.            
  142.            else if ( esParentesis ( inFijo [i] ) ){
  143.                
  144.                 if ( esParentesis ( inFijo [i] ) == 1 ){
  145.                      
  146.                      empujar_pila ( &pila, inFijo [i] );
  147.                      
  148.                 }
  149.                
  150.                 else{
  151.                      
  152.                      while ( pila->dato != '(' && esOperador ( pila->dato ) ){
  153.                            
  154.                            postFijo [j] = pila->dato;
  155.                            
  156.                            j++;
  157.                            
  158.                            sacar_pila ( &pila );
  159.                            
  160.                      }
  161.                      
  162.                      sacar_pila ( &pila );
  163.                      
  164.                 }
  165.                
  166.            }
  167.            
  168.            else{
  169.  
  170.                 postFijo [j] = inFijo [i];
  171.                
  172.                 j++;
  173.                
  174.            }
  175.            
  176.            i++;
  177.            
  178.      }
  179.      
  180.      postFijo [j] == '\0';
  181.      
  182. }
  183.  
  184. //##############################################################################
  185.  
  186. //##############################MAIN############################################
  187.  
  188. int main (){
  189.    
  190.     char * infijo = scan_infijo ();
  191.    
  192.     char postFijo [tam_infijo(infijo)+1];
  193.    
  194.     inFijo2postFijo(infijo, postFijo);
  195.    
  196.     printf ("%s", postFijo);
  197.    
  198.     getchar();
  199.    
  200.     return 0;
  201.    
  202. }
  203.  
  204. //##############################################################################
  205.  

Enlace de estructuras.h :

http://www.megaupload.com/?d=N31B614Z

Un saludo!!

12
C/C++ / Problema con realloc
« en: Domingo 24 de Julio de 2011, 18:24 »
Hola. Tengo las siguientes funciones:

Código: C
  1. int tam_infijo (char * array){
  2.    
  3.     int cont = 0;
  4.    
  5.     while ( *( array + cont ) != '\0' ){
  6.          
  7.           cont++;
  8.          
  9.     }
  10.    
  11.     return cont - 1;
  12.    
  13. }
  14.  
  15. char * scan_infijo (){
  16.    
  17.     char * expresion;
  18.    
  19.     expresion = (char*) calloc (200, sizeof (char));
  20.    
  21.     fgets (expresion, 200, stdin);
  22.    
  23.     realloc (expresion, sizeof(char) * (tam_infijo (expresion) + 1) );
  24.    
  25.     puts (expresion);
  26.    
  27. }

Alguien me podría decir que estoy haciendo mal a la hora de llamar a realloc? esque al programa le da igual que escriba:

(tam_infijo (expresion) + 1) que (tam_infijo (expresion) - 2), hace lo mismo...

Un saludo!

13
C/C++ / Re:Hallar el tamaño de un vector
« en: Miércoles 20 de Julio de 2011, 19:32 »
Muchas gracias por la respuesta.

14
C/C++ / Hallar el tamaño de un vector
« en: Miércoles 20 de Julio de 2011, 01:28 »
Hola, me gustaría saber por qué funciones del tipo:

Código: C
  1. int f (int v []){
  2.        
  3.         return (sizeof (v)/sizeof(int));
  4.        
  5. }

o definiciones del tipo:

Código: C
  1. #define length_int(x) (sizeof(x)/sizeof(int))

en un archivo ".h" aparte no funcionan y también como sacar el tamaño de un vector en un archivo aparte.

Un saludo!

15
Visual C++ / Re:triangulo numerico duda
« en: Martes 19 de Julio de 2011, 23:08 »
Código: C++
  1. #include <iostream>
  2. using namespace std;
  3.  
  4. int main(){
  5.  
  6.    int filas = 9;
  7.    int i;
  8.    int j;
  9.    
  10.       for (i = 1; i <= filas; ++i){
  11.        
  12.       if ( i != 1 )     cout << i;
  13.      
  14.          for (j = i+1; j <= (2 * i - 1); ++j){
  15.          
  16.             cout << j;
  17.            
  18.          }
  19.            
  20.          for (j = (2 * i - 2); j >= i+1 ; --j){
  21.          
  22.             cout << j;
  23.          
  24.          }
  25.      
  26.         cout << i << endl;
  27.  
  28.          }
  29.          
  30. }

Tienes un cacao curioso con os " ; " y con las llaves. Deberías de mirar algo antes de ponerte a programar.

16
C/C++ / Re:Lista ligada
« en: Lunes 18 de Julio de 2011, 17:26 »
Hola ProfesorX. Muchas gracias por contestar y por hacerlo de forma precisa y clara. Me ha servido de mucha ayuda!!

17
C/C++ / Lista ligada
« en: Lunes 18 de Julio de 2011, 02:20 »
Buenas, estoy haciendo un programilla de una lista ligada que propone un libro pero no funciona. No sé si será un error muy tonto o tengo echo algo muy mal pero el caso es que no localizo el error.

Código: C
  1. #include <stdio.h>
  2.  
  3. #include <stdlib.h>
  4.  
  5. struct nodo{
  6.        
  7.         char letra;
  8.        
  9.         struct nodo *siguiente;
  10.        
  11. };
  12.  
  13. typedef struct nodo nuevoNodo;
  14.  
  15. typedef nuevoNodo *ptrnuevoNodo;
  16.  
  17. void menu ();
  18.  
  19. void imprimir_lista (ptrnuevoNodo lista);
  20.  
  21. int esta_vacia (ptrnuevoNodo lista);
  22.  
  23. void insertar_letra (ptrnuevoNodo * lista, char valor);
  24.  
  25. int eliminar_letra (ptrnuevoNodo * lista, char valor);
  26.  
  27. int main (){
  28.        
  29.         int opt = 1;
  30.        
  31.         char valor;
  32.        
  33.         ptrnuevoNodo lista = NULL;
  34.        
  35.         menu ();
  36.        
  37.         while ( opt != 4 ){
  38.                
  39.                 printf ("? ");
  40.                
  41.                 scanf ("%d", &opt);
  42.                
  43.                 switch ( opt ){
  44.                        
  45.                         case 1:
  46.                                
  47.                                 imprimir_lista (lista);
  48.                                
  49.                                 break;
  50.                                
  51.                         case 2:
  52.                                
  53.                                 printf ("Introduce un caracter\n");
  54.                                
  55.                                 scanf ("%c", &valor);
  56.                                
  57.                                 insertar_letra (&lista, valor);
  58.                                
  59.                                 imprimir_lista (lista);
  60.                                
  61.                                 break;
  62.                                
  63.                         case 3:
  64.                                
  65.                                 printf ("Introduce un caracter\n");
  66.  
  67.                                 scanf ("%c", &valor);
  68.                                
  69.                                 eliminar_letra (&lista, valor);
  70.                                
  71.                                 imprimir_lista (lista);
  72.                                
  73.                                 break;
  74.                                
  75.                         case 4:
  76.                                
  77.                                 break;
  78.                        
  79.                         default:
  80.                                
  81.                                 printf ("Opcion incorrecta\n");
  82.                                
  83.                                 menu ();
  84.                                
  85.                 }
  86.                        
  87.         }
  88.                
  89. }
  90.  
  91. void imprimir_lista (ptrnuevoNodo lista){
  92.        
  93.         if ( esta_vacia (lista) ){
  94.                
  95.                 printf ("La lista esta vacia \n");
  96.                
  97.         }
  98.        
  99.         else{
  100.        
  101.                 printf ("La lista es : \n");
  102.                
  103.                 while ( lista != NULL ){
  104.                        
  105.                         printf ("%c -> ", lista -> letra);
  106.                        
  107.                         lista = lista->siguiente;
  108.                        
  109.                 }
  110.                
  111.                 printf ("NULL\n");
  112.                
  113.         }
  114.        
  115. }
  116.  
  117. int esta_vacia (ptrnuevoNodo lista){
  118.        
  119.         return lista == NULL;
  120.        
  121. }
  122.  
  123. void insertar_letra (ptrnuevoNodo * lista, char valor){
  124.        
  125.         ptrnuevoNodo ptrNuevo = NULL;
  126.        
  127.         ptrNuevo = malloc ( sizeof ( struct nodo ) );
  128.        
  129.         if ( ptrNuevo == NULL ){
  130.                
  131.                 printf ("No hay memoria disponible \n");
  132.                
  133.         }
  134.        
  135.         else {
  136.                
  137.                 ptrNuevo->letra = valor;
  138.                
  139.                 ptrNuevo->siguiente = NULL;
  140.                
  141.                 ptrnuevoNodo ptrAnterior = NULL;
  142.                
  143.                 ptrnuevoNodo ptrActual;
  144.                
  145.                 ptrActual = *lista;
  146.                
  147.                 while ( ptrActual->letra < valor && ptrActual != NULL ){
  148.                        
  149.                         ptrAnterior = ptrActual;
  150.                        
  151.                         ptrActual = ptrActual -> siguiente;
  152.                        
  153.                 }
  154.                
  155.                 if ( ptrAnterior == NULL ){
  156.                        
  157.                         ptrNuevo->siguiente = ptrActual;
  158.                        
  159.                         *lista = ptrNuevo;
  160.                        
  161.                 }
  162.                
  163.                 else{
  164.                        
  165.                         ptrAnterior->siguiente = ptrNuevo;
  166.                        
  167.                         ptrNuevo->siguiente = ptrActual;
  168.                        
  169.                 }
  170.                
  171.         }
  172.        
  173. }
  174.  
  175. int eliminar_letra (ptrnuevoNodo * lista, char valor){
  176.        
  177.         ptrnuevoNodo ptrActual = *lista;
  178.        
  179.         ptrnuevoNodo temp = NULL;
  180.        
  181.         if ( ptrActual->letra == valor ){
  182.                
  183.                 temp = *lista;
  184.                
  185.                 *lista = (*lista) -> siguiente;
  186.                
  187.                 free (temp);
  188.                
  189.                 return 1;
  190.                
  191.         }
  192.        
  193.         else{
  194.                
  195.                 ptrnuevoNodo ptrAnterior = ptrActual;
  196.                
  197.                 ptrActual = (*lista)->siguiente;
  198.                
  199.                 while ( ptrActual->letra < valor && ptrActual != NULL ){
  200.                        
  201.                         ptrAnterior = ptrActual;
  202.                        
  203.                         ptrActual = ptrActual -> siguiente;
  204.                        
  205.                 }
  206.                
  207.                 ptrAnterior = ptrActual;
  208.                        
  209.                 ptrActual = ptrActual->siguiente;
  210.                
  211.                 ptrActual = ptrActual->siguiente;
  212.                
  213.                 ptrAnterior->siguiente= ptrActual;
  214.                
  215.         }
  216.        
  217. }
  218.  
  219. void menu (){
  220.        
  221.         printf ( "%s%s%s%s", "Introduce 1 para ver la lista \n",
  222.        
  223.         "Introduce 2 para añadir un elmento \n",
  224.        
  225.         "Introduce 3 para eliminar un elemento \n",
  226.        
  227.         "Introduce 4 para salir del programa \n");
  228.        
  229. }

Un saludo y muchas gracias de antemano.

18
C/C++ / Re: Alguien que me de una mano?
« en: Lunes 11 de Julio de 2011, 02:22 »
Cita de: "ProfesorX"
3. Ademas, publicas el codigo incompleto, el codigo que pones no es suficiente para averiguar cual es el problema, no digo que publiques todo, pero si un trozo mas completo, que incluya la definicion de tus variables, ademas no nos marcas la linea exacta en donde te marca error. Todavia no tenemos dones de adivino para magicamente saber cual es el problema de tu codigo

Estoy totalmente de acuerdo, concretamente en esto!! en cuanto a lo del comportamiento, me parece que no hay remedio... jaja

19
C/C++ / Re: Finalizar programa
« en: Sábado 9 de Julio de 2011, 13:03 »
Podrías añadir
Código: C++
  1. system ("PAUSE")
  2.  

20
C/C++ / Re: programa C++
« en: Sábado 25 de Junio de 2011, 04:07 »
Cita de: "nayez"
cheque el código y tiene algunos errores, porque no hace los cálculos y solo muestra el numero de horas ingresadas.

Agradezco mucho tu aportación e interés!! ;)

Yo sólo modifiqué tu código para que no diera errores. De todas formas los cálculos sí los hace y lo que muestra es el salario de cada empleado. Las horas ingresadas no las muestra en ningún lado y los cálculos que hace son los que tenías expresados en tu comentario principal. ¿Te estoy entendiendo mal?

21
C/C++ / Re: programa C++
« en: Sábado 25 de Junio de 2011, 00:52 »
Utiliza
Código: ASM
  1. [code=cpp]
[/code] para que sea más fácil leer lo que escribes. Una solución a tu problema podría ser esto:

Código: C++
  1. #include <iostream>
  2.  
  3. using namespace std;
  4.  
  5. int main () {
  6.  
  7.     int empleados [5], horas;
  8.    
  9.     for (int c=0; c<5; c++){
  10.  
  11.         cout <<" nt Empleado " << c+1;
  12.        
  13.         cout <<" nn Horas laboradas: ";
  14.        
  15.         cin >> horas;
  16.        
  17.         if (horas <=40){
  18.        
  19.             empleados [c] = horas*50;
  20.         }
  21.         else{
  22.  
  23.             empleados [c] = (40*50) + ((horas-40)*30);
  24.         }
  25.     }
  26.        
  27.         for (int c=0; c<5; c++){
  28.        
  29.             cout <<" n Salario semanal empleado " << c+1 << " = "<< empleados [c];
  30.         }
  31.  
  32. return 0;
  33.  
  34. }
  35.  

22
C/C++ / Re: Ayudenme con este proyecto :D porfa
« en: Jueves 23 de Junio de 2011, 19:29 »
Podrías hacer un switch y en cada caso la tabla de multiplicar, y dentro de cada caso un for anidado. Luego añades un while para el error y está. Algo asi podría funcionar:

Código: C++
  1. #include <iostream>
  2. using namespace std;
  3.  
  4. int main () {
  5.    
  6.     cout<<"Introduzca el nº de tabla : n";
  7.    
  8.     int tabla;
  9.    
  10.     cin>>tabla;
  11.    
  12.     cout<<"n";
  13.    
  14.     int interacion;
  15.    
  16.     switch (tabla){
  17.        
  18.         case 1:
  19.            
  20.             for (int i = 1; i<=10; i++){
  21.            
  22.                 cout<<"Introduzca el resultado de "<<tabla<<"X"<<i<<" : ";
  23.                
  24.                 cin>>interacion;
  25.                
  26.                 while (tabla*i != interacion){
  27.                
  28.                     cout<<"Resultado incorrecto, vuelva a intentarlo :"<<endl;
  29.                    
  30.                     cout<<tabla<<"X"<<i<<" : ";
  31.                    
  32.                     cin>>interacion;
  33.                 }
  34.             }
  35.         break;
  36.     }
  37. }
  38.  

Faltaría hacerlo para el resto de números. Si quieres que se salga en el segundo intento, en lugar de un while podrías poner un if y añades un contador de errores.

23
C/C++ / Re: funcion de taylor
« en: Miércoles 22 de Junio de 2011, 22:07 »
Es fácil. El código solucionado, si no me equivoco, es este:

Código: C++
  1. #include <stdio.h>
  2. #include<string.h>
  3. #include<stdlib.h>
  4. #include <math.h>
  5. #define pi 3.141592654
  6. int factorial(int n)
  7. {
  8.     int i;
  9.     int fac=1;
  10.     for (i=1;i<=n;i++)
  11.     {
  12.         fac=fac*i;
  13.     }
  14.     return  fac;
  15. }
  16. int main()
  17. {
  18.     float x=90,a=45,suma=1;
  19.     float z=(x-a)/180*pi;
  20.     int i;
  21.     int iteraciones=15;
  22.     float e,r,t;
  23.     e=(float)1/90;
  24.     float param=90,resul;
  25.     resul=sin(param*pi/180);
  26.     for (i=1;i<iteraciones;i++)
  27.     {
  28.        
  29.     if(i%4==1 || i%4==0)
  30.        
  31.             suma=suma+pow(z,i)/factorial(i);
  32.        
  33.         if(i%4==3|| i%4==2)
  34.            
  35.         suma=suma+(-1)*(pow(z,i)/factorial(i));
  36.        
  37.         }
  38.         e=sin(a*pi/180);
  39.    
  40.     printf(" %.15fn",suma*e);
  41.  
  42.     return 0;
  43. }
  44.  

El problema estaba en que si divides el número de la "iteración" entre 4 (utilizando ambos como enteros), y analizas el resto, se dan las cuatro opciones que tenías expresadas: 0, 1, 2, 3, pero sólo obtienes como resto 0 y 1 cuando la derivada enésima de la función es positiva (para el punto que escogiste), y, con lo cual, los restos 2 y 3 coinciden cuando el signo es negativo. Si intercambias eso la solución es: 0.999999940395355 que es una tolerancia bastante pequeña al menos para utilizar la serie de Maclaurin.

Un saludo!

24
C/C++ / Re: Tabla de verdad
« en: Sábado 9 de Abril de 2011, 22:37 »
Tambien tienes razon ... jajaja

25
C/C++ / Re: Tabla de verdad
« en: Sábado 9 de Abril de 2011, 12:40 »
Lo que te pone m0skit0 es que crees dos valores de tipo booleanos (sólo toman valores entre true y false, es decir 1 o 0) y luego la operación lógica (esta tomará los valores de negación, disyunción...). Le haces un switch para cada uno de los valores que le asignes a la operación lógica y después en los "case" vas poniendo según sea disyunción, negación.. hacer esto;  y así continuamente. Por ejemplo, con una disyunción. p sería por ejemplo estar cansado y q es de noche, estos tomarán los valores 1 o 0. Le tendrías que decir; case 1 (disyunción){ si p==1 y q ==1 --> devolver 1; si p==0 y q ==0 -->devolver 0;...; } y así para los 4 posibles valores entre 0 y 1 y para los tipos de operaciones que quieras realizar. Te doy un ejemplo (aunque ya está casi hecho xdd)

Código: C++
  1. #include <iostream>
  2. using namespace std;
  3. int main(){
  4.     bool p, q;
  5.  
  6.     cout<<"Introduce el valor (0 | 1) del primer valor de verdadn";
  7.  
  8.     cin>>p; cout<<"n";
  9.  
  10.     cout<<"Introduce el valor (0 | 1) del segundo valor de verdadn";
  11.  
  12.     cin>>q; cout<<"n";
  13.  
  14.     cout<<"Introduce la operación lógican";
  15.  
  16.     cout<<"1->DISYUNCIONn"<<"2->CONJUNCIONn"; //etc....
  17.  
  18.     int unsigned operacion_logica;
  19.  
  20.     cin>>operacion_logica;cout<<"n";
  21.    
  22.     switch (operacion_logica){
  23.  
  24.         case (1):{
  25.  
  26.             if(p==1||q==1){
  27.  
  28.                 cout<<"1n";
  29.  
  30.             }
  31.  
  32.             else{
  33.  
  34.                 cout<<"0n";
  35.  
  36.             }
  37.  
  38.         break;
  39.         }
  40.         case (2):{
  41.  
  42.             if (p==1 && q==1){
  43.  
  44.                 cout<<"1n";
  45.  
  46.             }
  47.             else{
  48.  
  49.                 cout<<"0n";
  50.  
  51.             }
  52.  
  53.         }
  54.     break;
  55.     }
  56.  
  57. }
  58.  

Páginas: [1] 2 3 4