Mensajes

Ya nada, cerrad el tema.

Hola? Alguien me ayuda?

Hola, estoy haciendo una práctica final para la asigntaura Programación III de la uni y tengo un problema en una clase (AccionMostrarListaClientes)

Al ejecutar el programa, aparece el menú primario  (Operaciones clientes), el submenú  (por ahora estoy probando con la opción 1.1) Alta ), introduzco los datos y se crea el archivo  (aunque su contenido no es texto, son numeros (supongo que porque es binario no?). Luego vuelvo a ejecutar la opcion 1 y luego la subopción 1.4) Listar clientes. Aquí es cuando me peta . Me da error a la hora de leer el archivo ya creado y mostrarlo.

Os paso el proyecto entero (sé que hay clases de sobra, pero así son todas mas o menos las que hacemos en clase) y me decís por qué falla esa parte. 

https://www.sugarsync.com/pf/D790980_61560035_852649

Saludos y gracias.   

[es falso]

Te falto considerar que pasa cuando indice->num>=maximo es falso, el bucle se vuelve infinito ya que no cambias de nodo

Ostras es verdad, se me olvidaba pasar de nodos. Creo que tras tantos cambios que hice dejé sin ponerlo.

Y gracias, porque ya funciona. Usaba la función sin dobles punteros porque en un ejercicio muy parecido que ya tengo hecho (en vez de eliminar los mayores al nº introducido, tengo que eliminar ese nº todas las veces que aparezca) lo hice sin dobles punteros y como funcionó, pues pensé "digo yo que si funiona así, simplemente cambio el interior de la función un poco para que elimine los mayores y ya". Pero nanai jajaja

Finalmente, no se suponía que yo pasaba por referencia la lista? porque usaba un puntero *lst al principio de ella y luego la iba recorriendo. Y cuándo debería usar una función que llame a **lst y no *lst? Según lo que veo, la única que hace uso de **lst es InsertarNodoFinal(NODO **lst, int num) y es porque modifica la lista en sí, insertando nodos. Las de MostrarLista(NODO *lst) y NumeroNodos(NODO *lst) como solo la recorren no necesitan modificar los nodos y sólo necesitan un puntero simple no?

Qué lio xD Pero menos mal que sois unos máquinas.

PD:

Un numero racional se caracteriza por estar expresado con un denominador y un numerador.

Saludos

Lol wut? Creo que has mirado una respuesta antigua y no la última XD

Otra dudilla. Esta vez estoy con listas simplemente enlazadas.

Tengo que hacer un programa que cree una lista enlazada, que en su interior tenga un num. aleatorio >0 y que la muestre, junto con el nº de nodos. (hasta aquí todo bien)

El problema es que también tengo que pedir un nº por teclado y eliminar todos los nodos que contengan un nº igual o mayor al introducido, y me falla esta última función.

Os pongo sólo la función para ahorrar espacio. Si fuera necesario, luego pondría el programa completo.

Código (c) [Seleccionar] Expandir

void EliminarNodos(NODO *lst, int maximo){
    NODO *indice=NULL, *anterior=NULL;

    if(lst!=NULL){
        indice=lst;


        while((indice->sig)!=NULL){
            if((indice->num)>=maximo){
                if(anterior==NULL){
                    lst=(indice->sig);
                    free(indice);
                    indice=lst;
                }else{
                    (anterior->sig)=(indice->sig);
                    free(indice);
                    indice=anterior->sig;
                }
            }
        }
    }
}

A ver si véis en qué me falla. Porque también tengo que hacer otro prog. muy parecido al anterior, pero en vez de eliminar nodos con el nº mayor, tengo que ordenar la lista y quitar los repetidos. Pero eso ya para luego, que si me sale este a lo mejor entendiendo lo que tenía mal puede que me salga el otro.

Saludos y gracias.

Gracias por responder. He estado haciendo mientras tanto otros ejercicios, y para todos ellos he utilizado lo siguiente (siempre tras los #include y los #define, y fuera del main o de cualquier otra función):

Código (c) [Seleccionar] Expandir

typedef struct tipo_jugador{
   tipo1 miembro1;
   tipo2 miembro2;
   ...
   tipoN miembroN;
}tipo_jugador;


Y luego en el main:

Código (c) [Seleccionar] Expandir

tipo_jugador equipo[MAX_JUG];

Y me funciona bien. Lo que quiero saber es si es muy redundante o no, y qué diferencia hay enter los dos tipo_jugador, el de antes y después de las llaves.

De todas formas, me he dado cuenta de que una función puede devolver una estructura por valor, ya que creía que como esa un tipo de dato compuesto pues se tenía que hacer sí o sí por referencia. Probaré a empezar de 0 con el programa anterior, ya que aunque me compilaba, no se guardaban bien los valores en las variables (y obviamente se imprimían cosas aleatorias).

Nuevo programa: se supone que tiene que leer una ficha de un alumno creada mediante estructuras, y luego imprimirla. No me acaba de salir Qué lío de punteros, estructuras, typedef y la madre que lo trajo...

Código (c) [Seleccionar] Expandir

#include <stdio.h>
#include <stdlib.h>

#define MAXN 10 /* Número máximo de notas del alumno */

typedef struct{
   int dia;
   int mes;
   int anno;
}tipo_fecha;

typedef struct{
   char nombre[51];
   int curso;
   tipo_fecha fechaNacimiento;
   char direccion[61];
   float notas[MAXN];
}tipo_alumno;

/* PROTOTIPOS */

void leerAlumno(tipo_alumno *);
void imprimiralumno(tipo_alumno *);

/* FUNCIONES */

void leerAlumno(tipo_alumno * pa){
   int i;

   printf("Introduzca el nombre y apellidos del alumno (max. 50 caracteres): ");
   gets(pa->nombre);
   printf("Curso: ");
   scanf("%d", &pa->curso);
   printf("Fecha de Nacimiento (dd/mm/aaaa): ");
   scanf("%2d/%2d/%4d", &pa->fechaNacimiento.dia, &pa->fechaNacimiento.mes, &pa->fechaNacimiento.anno);
   puts("Direccion: ");
   fflush(stdin);
   gets(pa->direccion);
   for(i=0; i<MAXN; i++){
       printf("Nota[%d]: ", i+1);
       scanf("%f", &pa->notas[i]);
   }
}

void imprimirAlumno(tipo_alumno * pa){
   int i;

   fflush(stdin);
   printf("Nombre: %s", pa->nombre);
   fflush(stdin);
   printf("Curso: %d", pa->curso);
   fflush(stdin);
   printf("Fecha de Nacimiento: %2d/%2d/%4d\n", pa->fechaNacimiento.dia, pa->fechaNacimiento.mes, pa->fechaNacimiento.anno),
   fflush(stdin);
   printf("Direccion: %s\n", pa->direccion);
   for(i=0; i<MAXN; i++){
       printf("Nota[%d]: %2.1f\n", i+1, pa->notas[i]);
   }
}

int main (void){

   tipo_alumno alumno;
   tipo_alumno * ptalumno;
   ptalumno=&alumno;

   leerAlumno(ptalumno);

   imprimirAlumno(ptalumno);


printf("\n\n");
system("pause");
return 0;
}


Por cierto, a ver si me aclaro con las estructuras. En mi libro vienen varias formas de declarar tipos y crear variables mediante el typedef

Código (c) [Seleccionar] Expandir

typedef struct tipo_alumno{
   tipo1 miembro1;
   tipo2 miembro2;
   ...
   tipoN miembroN;
} var1, var2,...;


El tipo_alumno es opcional si no quieres ponerle una etiqueta al tipo no? Pero si no se la pones no puedes crear por ejemplo una var3 después, o sí porque está puesto el typedef? Qué forma me recomendáis para definir un tipo de dato fuera del main?  

Gracias, ya funciona perfectamente

A ver si he entendido bien, al llamar a la función, como en el prototipo ya sabe que recibirá un puntero, sólo tengo que poner el nombre del puntero, no la dirección, porque si no sería la direccion de un puntero, que a su vez sería la dirección de una direccíon, no?

Y lo de usar dobles punteros pues como que no, que además los prototipos me los da el profesor y nosotros sólo tenermos que rellenar el "esqueleto".

[EDIT: Para evitar abrir más hilos, pongo en este todas mis dudas personales. Nuevo programa añadido el 22/06/2012.]

Hola, estoy intentando hacer un ejercicio sobre aritmética racional (sumar, restar, multiplicar y dividir fracciones). Al mostrar los resultados hay que simplificarlos, pero según veo en el depurador, no se pasan correctamente los valores a simplificar a la función. Qué debo cambiar? Seguramente sea muy obvio, pero soy malísimo con punteros y estructuras xD

Gracias.

Código (c) [Seleccionar] Expandir

/* Fuente: RACIONAL.C
  Programa: ARITMETICA BASICA CON NUMEROS RACIONALES
  Descripción: Este programa permite operar con números racionales. Un número racional
  se caracteriza por estar expresado con un denominador y un denominador.
  Las operaciones que contempla son:
    - suma
    - resta
    - producto
    - división
  Además utiliza una función para proporcionar siempre la expresión irreducible del número
  racional
*/

#include <stdio.h>
#include <math.h>
#include <ctype.h>

/* ---------------------------------------------------------- */
/* Definiciones globales                                      */
/* ---------------------------------------------------------- */
typedef struct {
  int num;   /* Numerador   */
  int denom; /* Denominador */
} Racional;

/* ---------------------------------------------------------- */
/* Prototipos                                                 */
/* ---------------------------------------------------------- */
  void Modulo_Principal (void);
  void Presentacion (void);
  void LeerRacional (Racional *);
  void MostrarRacional (Racional);
  void SumaRacional (Racional, Racional, Racional *);
  void RestaRacional (Racional, Racional, Racional *);
  void MultiplicaRacional (Racional, Racional, Racional *);
  void DivideRacional (Racional, Racional, Racional *);
  void SimplificaRacional (Racional *);
  int mcd (int, int);

/* ---------------------------------------------------------- */
  int main (void) {
/* ---------------------------------------------------------- */
    char respuesta;

    system ("cls");
    Presentacion();
    do
      { printf("\n");
        Modulo_Principal();
    printf("\n");
    do
      { printf("¿Otra ejecución (S/N)?: ");
        fflush(stdin); /* Limpia el buffer de teclado */
        respuesta = toupper(getchar());
      }
    while (respuesta != 'S' && respuesta != 'N');

      }
    while (respuesta != 'N');

    printf("\n");
    return 0;

} /* Fin del main */


/* ---------------------------------------------------------- */
  void Modulo_Principal (void) {
/* ---------------------------------------------------------- */
    Racional rac1, rac2, rsum, rres, rprod, rdiv;

    printf("Introduzca el primer número racional:\n");
    LeerRacional(&rac1);
    printf("Introduzca el segundo número racional:\n");
    LeerRacional(&rac2);

    printf("\n");
    SumaRacional (rac1, rac2, &rsum);
    printf("Suma.......: ");
    MostrarRacional(rsum);
    printf("\n");

    RestaRacional (rac1, rac2, &rres);
    printf("Resta......: ");
    MostrarRacional(rres);
    printf("\n");

    MultiplicaRacional (rac1, rac2, &rprod);
    printf("Producto...: ");
    MostrarRacional(rprod);
    printf("\n");

    DivideRacional (rac1, rac2, &rdiv);
    printf("División...: ");
    MostrarRacional(rdiv);
    printf("\n");
}

/* ---------------------------------------------------------- */
  void Presentacion (void) {
/* ---------------------------------------------------------- */
    puts("ARITMETICA BASICA CON NUMEROS RACIONALES");
    puts("========================================");
    puts("");
    puts("Realiza la suma de números racionales");
    puts("Siempre presenta la expresión irreducible del número racional");
    puts("");
}

/* ---------------------------------------------------------- */
  void LeerRacional (Racional *r) {
/* ---------------------------------------------------------- */
      scanf("%d/%d", &(r->num), &(r->denom));
}

/* ---------------------------------------------------------- */
  void SumaRacional (Racional a, Racional b, Racional *r) {
/* ---------------------------------------------------------- */

      if(a.denom == b.denom){
       (r->num)=(a.num + b.num);
       (r->denom)=(a.denom);
      }else{
       (r->denom)=(a.denom * b.denom);
       (r->num)=(((r->denom/a.denom)*a.num) + ((r->denom/b.denom)*b.num));
      }

      SimplificaRacional(&r);
}


/* ---------------------------------------------------------- */
  void RestaRacional (Racional a, Racional b, Racional *r) {
/* ---------------------------------------------------------- */

      if(a.denom == b.denom){
       (r->denom)=(a.denom);
       (r->num) = (a.num - b.num);
      }else{
       (r->denom)=(a.denom * b.denom);
       (r->num)=(((r->denom/a.denom)*a.num) - ((r->denom/b.denom)*b.num));
      }

   SimplificaRacional(&r);
}



/* ---------------------------------------------------------- */
  void MultiplicaRacional (Racional a, Racional b, Racional *r) {
/* ---------------------------------------------------------- */

      (r->num)=(a.num*b.num);
      (r->denom)=(a.denom*b.denom);
      SimplificaRacional(&r);
}


/* ---------------------------------------------------------- */
  void DivideRacional (Racional a, Racional b, Racional *r) {
/* ---------------------------------------------------------- */

      (r->num)=(a.num*b.denom);
      (r->denom=a.denom*b.num);
      SimplificaRacional(&r);
}


/* ---------------------------------------------------------- */
  void MostrarRacional (Racional r) {
/* ---------------------------------------------------------- */
    printf("%3d", r.num);
    if (r.denom != 1)
      printf(" /%3d", r.denom);
}


/* ---------------------------------------------------------- */
  void SimplificaRacional (Racional *r) {
/* ---------------------------------------------------------- */
// Calcula el mcd del numerador y del denominador
// Divide numerador y denominador por su mcd
// Si la fraccion debe llevar segno negativo (num*dem <0)
//    entonces el signo se coloca al numerador
   int min;

      min=mcd(r->num, r->denom);
      r->num = (r->num)/min;
      r->denom =(r->denom)/min;
      if((r->num * r->denom)<0){
       r->num = - r->num;
      }
}



/* ---------------------------------------------------------- */
  int mcd (int n, int d) {
/* ---------------------------------------------------------- */
/* Calcula el máximo común dividor de n y d */
/* Precisa que d sea distinto de cero       */
/* Precisa que n > d                        */
   int c;

      if(n!=0 && d!=0 && n>d){
       do{
           c=n%d;
           if(c!=0){
               n=d;
               d=c;
           }
       }while(c!=0);
      }else{
       return;
      }

return d;
}

EDIT: Para evitar abrir más hilos, pongo en este todas mis dudas personales. Nuevo programa añadido el 22/06/2012.