muchas rir3760 ya le cambie el malloc por el calloc para que se inicialice sin basura, una última duda, como en el codigo primero le pido el valor de car y despues le hago un "cast" con sprintf para que sea una cadena, no seria mejor si simplemente  quitar el sscanf y el sprintf, me quedo con el fgets y despues se lo concateno a con strcat, porque como tiene que ser tipo cadena creo que el sprintf y el sscanf están de más

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
int main()
{
    int i = 0;
    char *cadena = NULL,buffer[5];
    cadena = calloc(5+1);
    while(i < 5)
    {
        printf("Dame car\n");
        fgets(buffer,5,stdin);
        strcat(cadena,buffer);
        i++;
    }
    printf("%s",cadena);
    return 0;
}

gracias

ya vi que mi error era en que no le habia asignado memoria a la cadena, pero ahora por ejemplo si le ingreso las letras a, b, c, d, e. cuando le pido que imprima ya la cadena completa me imprime con basura #Wqabcde,

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
int main()
{
    int i = 0;
    char *cadena = NULL,buffer[5],car;
    cadena = malloc(5);
    while(i < 5)
    {
        printf("Dame car\n");
        fgets(buffer,5,stdin);
        sscanf(buffer,"%c",&car);
        sprintf(buffer,"%c",car);
        strcat(cadena,buffer);
        i++;
    }
    printf("\n%s",cadena);
    return 0;
}

Saludos, tengo una duda sobre el uso de la función strcat.

si yo tengo una cadena inicializada en NULL, *cadena = NULL, y con un ciclo while quiero ir agregadole caracter por caracter podria hacer esto con el strcat que me vaya concatenando al final de la cadena caracter por caracter??

algo como asi:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
int main()
{
    int i = 0;
    char *cadena = NULL,c[5],car;
    while(i < 5)
    {
        printf("Dame car\n");
        fgets(c,5,stdin);
        sscanf(c,"%c",&car);
        strcat(cadena,car);
        i++;
    }
    return 0;
}

es que el codigo no funciona y creo que es por el strcat

gracias

Saludos, estoy haciendo mi primer programa en Prolog, es un simple árbol genealógico pero me aparece un warning que dice singleton variables[C,D] y no se que significa esto

los hechos del programa son del tipo padre(-,-) y madre(-,-).
hermanos(A,B):-padre(C,A),padre(C,B);madre(D,A),madre(D,B).
abuelo(E,A):-padre(E,padre(C,A)),padre(E,madre(D,A)).

?-abuelo(daniel,maria).

de antemano gracias

jaja cierto no me fije bien, ahora ya estoy empezando a hacer de nuevo el código como me dijiste con la primera opción, pero tengo una duda, por ejemplo si tengo una línea que es un comentario

;comentario numero1

y las instrucciones me dicen:
Las líneas de comentarios tienen las siguientes reglas:
a. empiezan con el caracter ;
b. ese caracter solo se puede encontrar en la primera posicion
c. Después del carácter ; puede seguir cualquier caracter, letras,digitos,etc..

pero si tengo la función de verificación asi:

int esComentario(FILE *fd)
{
    int car,continuar = 1;
    while((car = fgetc(fd))!= '\n')
    {
        if(car == ';')
           return 0;
    }
    return 1;
}

el programa no me va a recorrer todo la línea de código en caso de que se encuentre un ; intermedio y me returne inmediatamente que no es comentario, pero como le puedo hacer para que me lea todaaa la línea y que no solo se regrese con el return en los casos en que no es línea de comentario?? esto lo quiero hacer para que me vaya leyendo línea por línea desde el principio y para esto el while tiene que hacer completo el ciclo hasta que se encuentre el '\n'

gracias de nuevo

muchas gracias amchacon yo creo que si voy a intentar hacerlo de la primera manera, solo que como en las especificaciones del programa venia que tengo que verificar si la línea es comentario, ETIQUETA, CODIGO DE OPERACION Y OPERANDOS. y para cada uno son como 6 especificaciones pense que seria más fácil si lo guardaba en una estructura, de la segunda manera ya vi cual era mi problema y lo corregi solo que me queda una duda:

#include <stdio.h>
#include <stdlib.h>
#define MAX 100
 
void verificarLineas(FILE *fd,int buffer[],int renglon);
 
int main()
{
    FILE *fd;
    int car,tam,renglon = 0,buffer[MAX];
    if((fd = fopen("P1ASM.txt","r"))!= NULL)
    {
        while((car = fgetc(fd))!= EOF)
        {
            tam = 0;
            fseek(fd,-1,SEEK_CUR);
            while((car = fgetc(fd))!= '\n'&&(!feof(fd)))
            {
                tam++;
                printf("%c",car);
            }
            printf("\n");
            buffer[renglon++] = tam;
        }
        verificarLineas(fd,buffer,renglon);
    }
    else
       printf("No se pudo abrir el archivo");
    return 0;
}
 
void verificarLineas(FILE *fd,int buffer[],int renglon)
{
    int i = 0,lon;
    char *linea;
    fseek(fd,0,SEEK_SET);
    printf("\n");
    while(!feof(fd))
    {
        lon = buffer[i]+1;//tamaño de buffer mas el salto de linea
        linea = (char*)malloc((lon+1)*sizeof(char));//lon mas el caracter '\0'
        fgets(linea,lon,fd);
        printf("%s",linea);
        free(linea);
        i++;
    }
}

de esta manera me imprime algunas  lineas con basura pero si esta linea de codigo la cambio y le pongo lon+1, ya me imprime correctamente, por que es esto??

 lon = buffer[i]+1;//tamaño de buffer mas el salto de linea
        linea = (char*)malloc((lon+1)*sizeof(char));//lon mas el caracter '\0'
        fgets(linea,lon+1,fd);
        printf("%s",linea);
        free(linea);
        i++;

  nunca se me hubiera ocurrido hacerlo de esa manera, de hecho no sabía ni que era un stringstream y tampoco había visto las funciones rdbuf()... yo pense que iba a ser más fácil la implementación de la segunda opción, ir leyendo el archivo linea por linea e ir guardando en un buffer el tamaño(num de caracteres) de cada línea del archivo, y despues volver a leer el archivo pero esta vez dando brincos del tamaño de cada línea con el fseek(),para guardalos en otro buffer,pero el problema es que en la segunda función se cicla y no me hace lo que le pido, no entiendo por qué??

#include <stdio.h>
#include <stdlib.h>
#define MAX 100
 
void verificarLineas(FILE *fd,int buffer[],int renglon);
 
int main()
{
    FILE *fd;
    int car,tam,renglon = 0,buffer[MAX];
    if((fd = fopen("P1ASM.txt","r"))!= NULL)
    {
        while((car = fgetc(fd))!= EOF)
        {
            tam = 0;
            fseek(fd,-1,SEEK_CUR);
            while((car = fgetc(fd))!= '\n'&&(!feof(fd)))
            {
                tam++;
                printf("%c",car);
            }
            printf("*%d\n",tam+1);
            buffer[renglon++] = tam;
        }
        verificarLineas(fd,buffer,renglon);
    }
    else
       printf("No se pudo abrir el archivo");
    return 0;
}
 
void verificarLineas(FILE *fd,int buffer[],int renglon)
{
    int i = 0;
    char *linea;
    fseek(fd,0,SEEK_SET);
    while(!feof(fd))
    {
        linea = (char*)malloc(buffer[i]*sizeof(char));
        fgets(linea,buffer[i]+1,fd);
        printf("%s\n",linea);
        fseek(fd,buffer[i]+1,SEEK_CUR);
        free(linea);
        i++;
    }
}
 

gracias

Muchas gracias amchacon por tu respuesta, otra duda:

en la segunda opción me dice que lea todo el archivo en un solo ciclo, y que lo guarde  en una estructura, ¿con esto se refiere a que ya no voy a leer el archivo línea por línea?, o sea voy a tener que almacenar el archivo completo en la estructura y en la primera opción trabajo línea con línea sin almacenar nada?

Es que yo pensé que la mejor opción sería ir guardando línea por línea en un arreglo, y después hacer las validaciones de las palabras que están en los arreglos.

de antemano gracias

Saludos

tengo que crear un programa que identifique las partes de una línea en lenguaje ensamblador, y para esto me dicen que necesito tener un archivo de texto creado previamente y

Leer línea a línea el archivo, pudiendo:
a. Leer cada línea directamente del archivo, de una por una y procesar cada línea que se va leyendo.
b. Leer todo el archivo con un ciclo y conforme se lee el archivo almacenarlo en una estructura de datos temporal, posteriormente leer de esta estructura de datos

Me dice que en ambos casos hay ventajas y desventajas. Deberás elegir la que sea más conveniente, recuerda que el  programa debe de irse completando con las siguientes practicas.

¿cuales son estas ventajas y desventajas?,¿Cuál de estas opciones es la mejor y la más fácil de implementar?, No quiero que me hagan la tarea solo que me den una ligera idea de como seria

gracias

Ya pude hacer que el código me hiciera lo que le pido, sólo que en la función de ingresar dato en vez de ponerle un switch lo hice con if's, no se cuál de los dos será mejor o más eficiente,pero funciona

#include <stdio.h>
#include <stdlib.h>
#define TAM 5
#define ARITMETICA_SIMPLE 1
#define ARITMETICA_BINARIA 2
#define FACTORIAL 3
#define TABLA_MULTIPLICAR 4
#define SALIR 5
 
enum tipo{INT,CHAR};
void ingresarDato(void *dato,int tipo);
 
int main()
{
    //Variables de uso interno del programa
    int continuar = 1,i,factorial = 1;
    //Variables para entrada de datos
    int opcion,numero1,numero2,numero_factorial,multiplicando,multiplicador;
    char operador;
    do
    {
        //Menu principal
        printf("CALCULADORA v1.0\n\n");
        printf("Elige una de las siguientes opciones:\n");
        printf("1. Aritmetica simple con suma de enteros a+b\n");
        printf("2. Aritmetica extendida binaria\n");
        printf("3. Factorial de n (n!)\n");
        printf("4. Detallar una tabla de multiplicar\n");
        printf("5. Salir\n");
        printf("Opcion a elegir? ");
        ingresarDato(&opcion,INT);
        switch(opcion)
        {
            //Aritmetica simple con suma de enteros a+b
            case ARITMETICA_SIMPLE:
               printf("Dame el valor de a = ");
               ingresarDato(&numero1,INT);
               printf("Dame el valor de b = ");
               ingresarDato(&numero2,INT);
               printf("%d + %d = %d",numero1,numero2,numero1+numero2);
               break;
            //Aritmetica extendida binaria (+,-,*,/,%modulo)
            case ARITMETICA_BINARIA:
               printf("Escribe el operador (+,-,*,/,%%): ");
               ingresarDato(&operador,CHAR);
               printf("\nDame el valor de a = ");
               ingresarDato(&numero1,INT);
               printf("Dame el valor de b = ");
               ingresarDato(&numero2,INT);
               switch(operador)
               {
                   case '+':
                      printf("%d %c %d = %d\n",numero1,operador,numero2,numero1+numero2);
                      break;
                   case '-':
                      printf("%d %c %d = %d\n",numero1,operador,numero2,numero1-numero2);
                      break;
                   case '*':
                      printf("%d %c %d = %d\n",numero1,operador,numero2,numero1*numero2);
                      break;
                   case '/':
                      printf("%d %c %d = %d\n",numero1,operador,numero2,numero1/numero2);
                      break;
                   case '%':
                      printf("%d %c %d = %d\n",numero1,operador,numero2,numero1%numero2);
                      break;
                   default:
                      printf("No hay un resultado calculable\n");
                      printf("%d %c %d = 0\n",numero1,operador,numero2);
               }
               break;
            //Factorial de n (n!)
            case FACTORIAL:
               printf("Dame el valor de n = ");
               ingresarDato(&numero_factorial,INT);
               if(numero_factorial < 0)
                  printf("El factorial de %d no esta definido\n",numero_factorial);
               else if(numero_factorial == 0)
                  printf("El factorial de 0 es 1\n");
               else
               {
                   for(i = numero_factorial;i > 0;i--)
                      factorial*=i;
                   printf("El factorial de %d es %d\n",numero_factorial,factorial);
               }
               break;
            //Detallar una tabla de multiplicar
            case TABLA_MULTIPLICAR:
               printf("Dame el multiplicando i = ");
               ingresarDato(&multiplicando,INT);
               printf("Dame hasta cual multiplicador n= ");
               ingresarDato(&multiplicador,INT);
               printf("Tabla de multiplicar del %d\n",multiplicador);
               i = 1;
               while(i <= multiplicador)
               {
                   printf("%d\tX\t%d\t=\t%d\n",multiplicando,i,multiplicando*i);
                   i++;
               }
               break;
            //Salida del programa
            case SALIR:
               continuar = 0;
               break;
            default:
               printf("Opcion no valida!\n");
        }
        if(continuar)
           system("pause");
    }while(continuar);
    return 0;
}
 
void ingresarDato(void *dato,int tipo)
{
    char buffer[TAM];
    fgets(buffer,sizeof(buffer),stdin);
    if(tipo == INT)
       sscanf(buffer,"%d",dato);
    else if(tipo == CHAR)
       sscanf(buffer,"%c",dato);
}
 

gracias