Temas

Imaginemos que tenemos una estructura tal que:

Código (c) [Seleccionar] Expandir


struct estructura{
// miembros
};

struct estructura *variable;

y ahora

Código (c) [Seleccionar] Expandir


variable = malloc(5 * sizeof(*variable));

Quería saber si liberar la memoria así:

Código (c) [Seleccionar] Expandir


for(i = 0; i < 5; i++){
free( (variable + i) );
(variable + i) = NULL;
}

es correcto.

Un saludo.

Hola de nuevo. Resulta que estoy haciendo un programa que involucra archivos y hay un segmento en el que me resulta útil saber la línea más larga del archivo.

Para ello tengo este código:

Código (c) [Seleccionar] Expandir


int main(void)
{
int N;
// codigo
FILE *archivo;
archivo = fopen(nombreArchivo.txt, "r");
N = mayorLinea(archivo);
// codigo
fclose(archivo);

return EXIT_SUCCESS;
}

int mayorLinea(FILE *arch)
{
char c;
int contador = 0;
int aux = 0;

while(c != EOF){
c = fgetc(arch);

if(c != '\n' && c != EOF){
contador++;
}
else{
if(contador > aux){
aux = contador;
}
contador == 0;
}
}

return aux;
}

La duda es que si imprimo N en el main() me sale siempre 0. Me parece que la forma en la que llamo a la función es errónea, pero no encuentro tal error.
Un saludo y gracias

Hola. La cuestión es que tengo un programa en el que hay una serie de funciones que son llamadas bastantes veces durante la ejecución de este(más de 20 cada una).
Lo que quería saber es si existe algún método para mejorar la velocidad del programa cuando se hacen muchas llamadas a una función.

Un saludo.

Al igual que en un puntero a puntero para acceder a casa uno de los elementos se puede usar:

Código [Seleccionar] Expandir

nombre[x][y]
Tanto como

Código [Seleccionar] Expandir

*(*(nombre + y) + x)

Si tengo por ejemplo un puntero a una estructura  tal que

Código [Seleccionar] Expandir

struct estructura *nombre;
nombre = malloc(n * sizeof(*nombre));
Y un miembro de esa estructura es por ejemplo

Código [Seleccionar] Expandir

char **cadena;

Para acceder a un elemento j de ese miembro en una estructura i uso

Código [Seleccionar] Expandir

(jugador + i) -> cadena[j];

Mi pregunta es, ¿Cómo represento lo anterior como notación completa de punteros? Es decir sin usar los corchetes que uso en cadena[j] como en

Código [Seleccionar] Expandir

*(*(nombre + y) + x)

Un saludo

Por ejemplo si tengo:

Código (c) [Seleccionar] Expandir


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

int main(void)
{
char **nombre;
nombre = (char **)malloc(10 * sizeof(char *));
nombre[0] = (char *)malloc(10 * sizeof(char));
gets(nombre[0]);   // ya se que no se debe usar

return EXIT_SUCCESS;
}
Pongamos ahora que introduzco por teclado "HOLA", ¿cómo hago para acceder por ejemplo a la 'H' o a cualquier otro caracter de nombre[0]

Un saludo

Este es el código:

Código (c) [Seleccionar] Expandir


#include<stdio.h>

void situarPosiciones(int *posicion);

int main(void)
{

static int situarPosiciones[5] = {0,1,2,3,4};


funcion(situarPosiciones);


return 0;
}

void situarPosiciones(int *posicion)
{
int i;

for(i = 0; i < 5; i++){
if(*(posicion + i) != 0){
*(posicion + i)--;
}
else{
*(posicion + i) = 4;
}
}

return;
}

Lo que pretende es que cada vez que llame a la función me salga algo como:
|0|1|2|3|4| 1º llamada
|4|0|1|2|3| 2º llamada
|3|4|0|1|2| 3º llamada
--------------------------

Pero no sé que puede estar fallando

Un saludo

Hola, supongo que les sonará muy básico, pero no sé que hace el poner return en una sentencia como un if (por ejemplo):

Es decir, he visto códigos que ponen cosa como:

Código [Seleccionar] Expandir

if (...){
   return ... ;
}

Mi duda principal es, ¿a dónde devuelven el valor? (suponiendo claro que esté fuera de cualquier función distinta de main. También lo he visto en sentencias globales a cualquier función)

Un saludo

Si por ejemplo tengo la siguiente estructura de datos:

Código [Seleccionar] Expandir


struct nombre{
   // código
};

struct nombre array[N];   // siendo N un entero cualquiera

Esto lo entiendo; creo un array que contiene N estructuras.

Ahora lo que quiero es hacer lo equivalente a lo anterior pero con un puntero.
Yo he intentado esto, pero seguro que es erróneo:

Código [Seleccionar] Expandir


struct nombre{
   // código
};

struct nombre *puntero;
puntero = (struct nombre*)malloc(N * sizeof(nombre));

Espero que me puedan ayudar. Un saludo.

Estaba el otro día programando cuando de repente oigo un pequeño chispazo proveniente de mi cargador de portátil. En ese momento se fue la luz. Despues, tras volver a poner los fusibles bien miré y comprobé que no cargaba el portátil.
Quería saber si podía haber dañado mi portátil. Aparentemente funciona, pero quiero descartar cualquier tipo de daño. Como dato el cargador es el que venía con el portátil.

Un saludo.

Muy buenas de nuevo. Estoy haciendo un programa ( muy básico ) en el que se debe introducir un número de alumnos, luego pedir una calificación a cada uno en el intervalo [0, 10], y por último clasificar el número de aprobados, notables, etc. TODO CON ENTEROS.
De momento llevo lo siguiente:

Código [Seleccionar] Expandir


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

#define TAMANIO 10

int verificarEntrada(const char *ptrX);

int verificarEntrada(const char *ptrX)
{
for(; *ptrX != '\0'; ptrX++){
if(isdigit(*ptrX) == 0){
puts("->Entrada no permitida.");
return 0;
}
}

return 1;
}

int main(void)
{
char nAlumnos[TAMANIO];
int alumnos;
int longitud;
int x;   // valor que devuelve la función verificarEntrada()
int i;
char *notas[alumnos];
int notasEnteras[alumnos];


do{
printf("Numero de alumnos: ");

fgets(nAlumnos, TAMANIO, stdin);   // si introducimos 9 o más caracteres se produce OVERFLOW en el buffer

longitud = strlen(nAlumnos);

if(nAlumnos[longitud-1] == '\n'){   // si la cadena tiene una longitud menor a TAMANIO-1 evitamos la "impresión de '\n'
nAlumnos[longitud-1] = '\0';
}

x = verificarEntrada(nAlumnos);

puts("");

if(x == 1){
alumnos = atoi(nAlumnos);
}

} while(x == 0);

for (i = 0; i < alumnos; i++){
do{
notas[i] = malloc (TAMANIO * sizeof (char));

      printf("Nota alumno %d : ", i + 1);
      scanf("%[^\n]", notas[i]);
      while(getchar() != '\n');
     
      x = verificarEntrada(notas[i]);

if(x == 1){
int n = atoi(notas[i]);

if(n < 0 || n > 10){   // cada nota debe estar comprendida en el intervalor [0, 10]
x = 0;
}
else{
notasEnteras[i] = atoi(notas[i]);
}
}

} while(x == 0);
  }


return EXIT_SUCCESS;
}


El problema es que compila pero en cuanto se abre la consola se termina el proceso.
No encuentro que puede estar mal.
Agradecería mucho indicaciones de cómo mejorar un poco el código (ya que lo veo un poco desastroso, sobre todo en la declaración de variables   )

Gracias.

Tengo que hacer un programa que verifique si una cadena se encuentra dentro de otra ( sin usar la función strstr() ). Este es el código:

Código [Seleccionar] Expandir


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

short int fBuscar(char *ptrX, char *ptrY, short int longitud);   // prototipo función fBuscar

short int fBuscar(char *ptrX, char *ptrY, short int longitud)
{
short int contador1 = 0;
short int contador2 = 0;
char *ptrZ = ptrY;   // usamos ptrZ como una variable auxiliar que almacena la dirección en memoria de cadenaABuscar[0]

for(; *ptrX != '\0'; ptrX++){

if(*ptrX == *ptrY){
contador1++;
contador2++;
ptrY++;   // ptrY apunta a la siguiente posición de memoria

if(contador1 == longitud){
return (contador2 - longitud);
}
}
else{
ptrY = ptrZ;
contador1 = 0;
contador2++;
}
}

return (-1);   // si se llega hasta aquí no se ha encontrado la cadenaABuscar en cademaOriginal
}

int main(void)
{
const short int tamanio;
int c;
printf("Definir tama%co aproximado de la cadena: ", 164);
scanf("%d", &tamanio);

while((c = getchar()) != '\n');   // limpieza del buffer

char cadenaOriginal[tamanio];   // cadena donde vamos a buscar
char cadenaABuscar[tamanio];   // cadena de caracteres que queremos ver si se encuentra en cadenaOriginal
short int longitud;
short int x;   // el valor de x verifica si la cadenaABuscar se encuentra en cadenaOriginal

puts("\nIntroducir cadena donde se quiere buscar:");
fgets(cadenaOriginal, tamanio, stdin);

puts("\nIntroducir cadena que queremos buscar:");
fgets(cadenaABuscar, tamanio, stdin);

longitud = strlen(cadenaABuscar) - 1;   // evitamos contar el caracter '\n' que almacena fgets()

x = fBuscar(cadenaOriginal, cadenaABuscar, longitud);

if(x == -1){
puts("Cadena no contenida");
}
else{
puts("Cadena no contenida");
printf("Encontrada en la posicion %d", x+1);
}

return EXIT_SUCCESS;
}



El problema es que al introducir por ejemplo hhola y después hola me da error porque de las h los punteros ptrX y ptrY saltan a la h y la o respectivamente.
No sé como arreglarlo. (SEGURAMENTE HAYA MÁS FALLOS)

Gracias

Hola, tengo el siguiente fragmento de programa:

Código [Seleccionar] Expandir


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

void baraja( int wMazo[][13] );
// código

int main (void)
{
   //código
   int mazo[4][13] = {0};
   srand(time(0));
   baraja(mazo);
   //código
   return EXIT_SUCCESS;
}

void baraja( int wMazo[][13] )
{
   int fila;
   int columna;
   int carta;

   for(carta=1; carta<=52; carta++){
      do{
         fila = rand() % 4;
         columna = rand() % 13;
      } while(wMazo[fila][columna] != 0);
      wMazo[fila][columna] = carta;
   }
}


No entiendo porqué se pasa wMazo[][13], es decir, porque se deja el primer corchete sin datos, ¿no debería ser wMazo[4][13] ?

Gracias.

Pues eso, quería saber cual es la ventaja de usar una función con una llamada normal, por ejemplo funcion(10) a hacerlo con un puntero a una función, por ejemplo ( siendo la decalaración void (*ptrF) (int x); )  x=ptrF(10)

Código [Seleccionar] Expandir


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


struct carta{
const char *cara;
const char *palo;
};

typedef struct carta Carta;

void llenaMazo(Carta * const wMazo, const char * wCara[], const char * wPalo[]);

int main(void)
{
Carta mazo[52];

const char *cara[] = {"As", "Dos", "Tres", "Cuatro", "Cinco", "Seis", "Siete", "Ocho", "Nueve", "Diez", "Jota", "Reina", "Rey"};
const char *palo[] = {"Corazones", "Diamantes", "Treboles", "Picas"};

srand(time(NULL));

llenaMazo(mazo, cara, palo);


return EXIT_SUCCESS;
}

void llenaMazo(Carta * const wMazo, const char * wCara[], const char * wPalo[])
{
int i;

for(i=0; i<=51; i++){
wMazo[i].cara = wCara[i%13];
wMazo[i].palo = wPalo[i/13];
}

}




No entiendo lo que quiere hacer. Sé algo de punteros pero me armo un lío enorme.


Muchas gracias

Imaginemos que tenemos un un array como:

   char cadena[10];

Entonces usamos la función fgets para leer una cadena de caracteres como:

   fgets(cadena, 10, stdin);

E introducimos menos de 9 caracteres por lo que automáticamente se nos pone un '\n' al final del array, en la posición cadena[9] en el ejemplo.
Entonces si usamos:

   if(cadena[strlen(cadena)-1] == '\n'{
      cadena[strlen(cadena)-1] = '\0'
   }

obtenemos la cadena sin la impresión de una nueva línea (es decir que el cursor se situa justo después del último caracter.

Lo que no entiendo de todo es es que si introducimos por ejemplo HOLA el array quedaría como:

   H O L A  \0 _ _ _ _ \n

y al usar la anterior instrucción para quitar el '\n' tendríamos:
   
   H O L A  \0 _ _ _ _ \0

¿Cómo es posible tener dos '\0'?

Muchas gracias.

¿Cómo se podría hacer para que en un programa que solo pida números enteros si se introduce un float, double o char el programa pueda capturar el error.

Es decir que si yo tengo por ejemplo scanf("%d", &x); e introducimos en 5.5 es claro que si lo imprimimos con printf("%d", x); el programa mostrará 5. Lo que yo quiero es algún fragmento de código que me permita imprimir que se ha introducido un tipo diferente de int.

Gracias