Gracias, ahora usando _Decimal64 lo solucione

Hola, tengo un problema muy sencillo y que aún así me sigue quemando el coco.
Tengo una función que me devuelve un float, un float que es el resultado de 10/3, osea 3,333333...
Quiero recortarle algunos decimales cosa de que me quede como 3,333 o 3,3333.
Lo que hago es sencillo, tomo el float en cuestión, lo multiplico por 10⁴, si quiero tener 4 decimales luego de la coma y lo convierto a entero cosa de que me quede: 33333. Luego lo divido a ese entero, casteado a float por 10⁴, para volver a mover los decimales, cosa de que me quede 3,3333. Sin embargo lo que me ocurre es que cuando lo imprimo formateado como %.100f (cosa de ver todos los decimales posibles), me queda 3,333300000000003454345677. Esto me esta volviendo loco, porque solo me sucede con numeros periódicos y es un razonamiento muy sencillo.

El codigo seria algo como
int decimales = 3;
float miNumero = funcion_que_devuelve_float(10,3);
int miNumero2 = (int)(miNumero * pow(10,decimales));
float miNumero = (float)(miNumero2 / pow(10,decimales));

También intente multiplicar en ambos casos, en uno por la potencia negativa y en otro por la positiva, con el mismo resultado.

Muchas gracias por detenerse a leer y saludos.

Y mientras sean cuotas de 40 euros por mes puedo soportar el gasto, otro tema es que tengo que elegir una cuya tecnología sea compatible con Debian (aunque si no es muy nueva, seguro lo sea). Esas paginas que me mostraste me resultan interesantes, ¿de que país es?

Saludos!

Hola, quería hacer una pequeña consulta, voy a iniciarme en un proyecto y necesito una computadora para estar trabajando lejos de mi casa, como no me dan ganas de llevarme la CPU al hombro todos los días al trabajo, estoy pensando en comprarme una netbook o una notebook. En preferencia me gustaría comprarme algo económico, por eso pensé en una netbook, pero no se si una netbook pueda soportar correr IDEs como Eclipse o Netbeans. ¿Ustedes conocen alguna notebook que sea lo suficientemente potente como para tirar una IDE o acaso me conviene optar por comprarme una notebook?.

Muchas gracias por detenerse a leer y saludos!

Hola, estaba buscando algún manual o alguna fuente para formarme con Java Server Pages, sin embargo en internet solo encuentro tutoriales con muy poco contenido. ¿Alguno conoce un manual de JSP?

Muchas gracias por detenerse a leer, saludos.

Lo de la fragmentación interna ya lo saque, cada entrada en la tabla de paginas tiene un atributo llamado length, bue creo que de ahi en mas todo sale por logica.

Hola tengo dos dudas muy puntuales. El otro día haciendo algunos ejercicios de memoria virtual, me surgió una duda, en un esquema de memoria virtual con paginación, ¿Como detecta el sistema operativo si estoy referenciando a una dirección que esta en la fragmentación interna del espacio de direcciones lógico?. Es decir, se puede detectar por HW si estoy tratando de acceder a una pagina que no esta asignada mediante el bit de validez, sin embargo por un error del programa del proceso una instrucción podría hacer un salto a la fragmentación interna, ¿Como se detecta en ese caso?

Mi otra pregunta es acerca del buffer de cache en System V.
¿Se mantienen las tablas de paginas o paginas individuales en buffer de cache?, ¿Que ocurre con la TLB en ese caso?. Porque me puse a pensarlo y sería como que ambas compiten por el mismo objetivo sin saberlo, pero después lo reconsidere y pensé: La TLB es una cache, se implementa con registros asociativos de alta velocidad, el método de búsqueda ante un page fault, podría ser; Me fijo en la TLB si esta la pagina deseada (La TLB es varios ordenes de tiempo mas rápida que el buffer de cache ya que esta implementada con registros asociativos, mientras que el buffer de cache esta en memoria), si la pagina deseada no esta en la TLB, buscamos en el buffer de cache por un bloque que la contenga, si no esta en el buffer de cache, se busca un buffer disponible en la free list (¿Que ocurre si no hay un buffer disponible?, obviamente tendremos que esperar, ¡Pero se trata de un page fault!, debe atenderse lo mas rápido posible), si se encuentra un bloque disponible se graba en él, si el bloque disponible estaba con delayed write, se descarga a disco antes de escribir el nuevo contenido, una vez escrito se actualiza la TLB, se reinicia la instrucción desde el punto anterior como si el PF nunca hubiera ocurrido, etcétera.

Además algo que leí en el Galvin (Cariñosamente llamado "El de los dinosaurios" por mi xD) que me voló el sombrero, es que en Unix, puede estar el superblock en el buffer de cache. ¿Para que voy a querer tener el superblock en el buffer de cache?, si el superblock solo contiene la información del filesystem, como numero de cilindros, etcétera.


Muchas gracias por detenerse a leer y saludos!

Gracias, había pensado algo parecido, pero no tuve en cuenta el puntero a función, voy a intentarlo y después te digo como salio xD

Saludos!

Hola, tengo una duda acerca de estructuras de datos genéricas, como por ejemplo, una lista. Hacer una lista genérica que contenga diferentes tipos de datos básicos, como int, char, char* o float es sencillo; definimos un puntero a void y luego por ejemplo si queremos imprimir la lista entera bajo diferentes criterios usamos punteros a funciones que casteen el puntero al tipo adecuado de puntero. Sin embargo, si tenemos una lista genérica que adicionalmente, además de los tipos mencionados anteriormente, contiene una estructura, como por ejemplo t_Persona, que contiene los campos nombre y apellido, ambos char*, ¿Como deberíamos proceder para hacer un puntero a función que lo imprima de manera adecuada?.

Osea mi problema es que yo quiero tener una lista genérica de esa forma, tener una función imprimir que reciba la lista y un puntero a función, donde la función a la que apunta es el criterio a usar. Si yo en mi lista tengo 2, 4, a, c, 'Hola mundo!', 3.45, t_Persona(nombre: 'Jorge' apellido:'Ruiz') (Disculpen la notación de este ultimo), entonces si yo llamara a la función imprimir y le pasara la lista y la función que castea a caracteres me imprimiría: (El ASCII de 2), (El ASCII de 4), a, c, H, (Basura), (Mas basura).

Mi punto es: Si quiero imprimir usando el criterio para imprimir una persona, voy a tener que castear los punteros a void a punteros a t_Persona, con un dato que realmente sea de t_Persona no va a haber problema, sin embargo cuando este iterando y me cruce un puntero que en realidad es un puntero a float, y lo castee a tipo persona, y trate de acceder a sus miembros, esto me va a tirar un Segmentation Fault con toda la razón.

Yo pensé, entonces simplemente tendría que exigir que el resto de los elementos, como mínimo, ocupen la misma cantidad de bytes que t_Persona, de esa manera cuando los castee, me devolverán basura, pero no me tirara Segmentation Fault.

Mi duda es simple: ¿Existe una manera mas limpia de lograr mi objetivo?

Les dejo un ejemplo de mi codigo:

#include <stdio.h>
#include <stdlib.h>
 
typedef struct t_Persona {
	char* nombre;
	char* apellido;
} t_Persona;
 
//Decimos que un puntero a void es sinonimo de una direccion.
typedef void* t_Direccion;
 
typedef struct t_Lista {
	t_Direccion* dato;
	//El size NO lo necesitamos simplemente para saber cuantos elementos tenemos, SI lo necesitamos para seguirle la pista
	//A cuanto espacio tenemos que alocar.
	int size; 
} t_Lista;
 
//El tipo iterador contiene la lista y la posicion actual dentro de ella
typedef struct t_Iterador {
	t_Lista* lista;
	//Nodo actual para recorrer
	int actual;
} t_Iterador;
 
t_Iterador tIterador_Crear () {
	t_Iterador nue;
	nue.lista= (t_Lista*) malloc (sizeof(t_Lista));
		(nue.lista)->size=0;
		(nue.lista)->dato=NULL;
	nue.actual=0;
	return nue;
}
 
void tIterador_Iniciar(t_Iterador* iter) {
	iter->actual=0;
}
 
/* Notese la diferencia entre el crear y el iniciar; El crear nos crea una nueva instancia, y el iniciar
 * prepara el iterador para iterar, recibiendo la lista sobre la cual va a trabajar y poniendo su posicion
 * actual a cero. */
 
/*Un simple agregar al final*/
 
void tIterador_Agregar (t_Iterador* iter, t_Direccion i) {
	if (iter->lista->size == 0) {
		iter->lista->dato = (t_Direccion*) malloc (sizeof(t_Direccion)*(++iter->lista->size));
	} else { 
		iter->lista->dato = (t_Direccion*) realloc (iter->lista->dato, sizeof(t_Direccion)*(++iter->lista->size));
	}
	iter->lista->dato[iter->actual++] = i;	
}
 
/*Funciones que imprimen en diferentes formatos, utilizadas para el imprimir*/
 
void imprimirEnteros (t_Direccion x) {
	printf("%i, ",*((int*)(x)));
}
 
void imprimirCaracteres (t_Direccion x) {
	printf("%c, ",*((char*)(x)));
}
 
void imprimirStrings (t_Direccion x) {
	printf("%s, ",((char*)(x)));
}
 
/* No escatimes en el uso del parentesis en estos casos!!! */
/* void imprimirPersonas (t_Direccion x) {
	printf("%s %s, ",((t_Persona*)(x))->nombre, ((t_Persona*)(x))->apellido);
} */
/* En estos casos hay que asegurarse de que todos los elementos tienen el mismo tamaño*/
 
/*El imprimir generico*/
/*Nomenclatura de una funcion pasada como parametro a otra (puntero a funcion)
 *TIPORETORNO (*NOMBRE)(PARAMETROS) Notese que para un puntero a funcion el asterisco se usa a la izquierda*/
void tIterador_Imprimir (t_Iterador* iter, void (*criterio)(t_Direccion)) {
	criterio(iter->lista->dato[iter->actual]); /*Modo de uso de un puntero a funcion*/
}
 
int tIterador_Fin (t_Iterador* iter) {
	return (iter->actual < iter->lista->size)?(1):(0);
}
 
void tIterador_Avanzar (t_Iterador* iter) {
	iter->actual++;
}
 
int main(int argc, char** argv)
{
 
	int a=65, b=66, c='a', d=68, e='c';
	char* f = "Holaaa";
	t_Iterador iter = tIterador_Crear();
 
	tIterador_Iniciar(&iter);
 
	/*Vamos a agregar los numeros del 65 al 70*/
	tIterador_Agregar(&iter, &a);
	tIterador_Agregar(&iter, &b);
	tIterador_Agregar(&iter, &c);
	tIterador_Agregar(&iter, &d);
	tIterador_Agregar(&iter, &e);
	tIterador_Agregar(&iter, f); //Look!
 
	/*Imprimimos como enteros*/
	tIterador_Iniciar(&iter);
	/*Al imprimir le pasamos la funcion que va a usar como criterio de conversion*/
	while ((tIterador_Fin(&iter))) {
		tIterador_Imprimir(&iter, imprimirEnteros);
		tIterador_Avanzar(&iter);
	}
	printf("\n");
	/*Imprimimos como Caracteres*/
	tIterador_Iniciar(&iter);
	/*Al imprimir le pasamos la funcion que va a usar como criterio de conversion*/
	while ((tIterador_Fin(&iter))) {
		tIterador_Imprimir(&iter, imprimirCaracteres);
		tIterador_Avanzar(&iter);
	}
	printf("\n");	
	/*Imprimimos como Strings*/
	tIterador_Iniciar(&iter);
	/*Al imprimir le pasamos la funcion que va a usar como criterio de conversion*/
	while ((tIterador_Fin(&iter))) {
		tIterador_Imprimir(&iter, imprimirStrings);
		tIterador_Avanzar(&iter);
	}	
 
	return 0;
}

Si usaramos el imprimirPersonas obviamente nos tiraría un segmentation fault.

Muchas gracias por detenerse a leer, y saludos!

Muy buenas preguntas. Gracias por ayudarme!

Anastacio, para vos que tenías algunas dudas aca te dejo una info sobre punteros a funciones, la podes leer cuando quieras, lo mejor cuando uno arranca C, its do like a sloth, slowy is better! jajajaj osea no te precipites. Espero que te sea de ayuda.

Para los que tienen dudas acerca de los void, el void no solo sirve para decir que una función no devuelve nada, el void sirve para manipular direcciones de memoria directamente. Imaginense lo siguiente, cuando yo declaro una variable de algún tipo, tengo una posición de memoria reservada e identificada como de ese tipo. Si yo declaro un puntero a void (void*) tengo una dirección apuntada por el puntero, en esta dirección puedo tener cualquier dirección de cualquier otro dato, ¿Para que voy a querer tener en una variable las direcciones de memoria de otros datos? Bueno porque la principal propiedad del puntero a void es que se puede castear a cualquier otro tipo de puntero, de cualquier otro tipo de dato a excepción de algunas cosas que voy a detallar en este ejemplo:

#include <stdio.h>
#include <stdlib.h>
//Pequeña macro que nos dice la direccion de memoria de una variable
#define Address(x) printf("Address: %p\n",(&x)); fflush(stdout);
 
typedef void* Direccion;
 
int main(int argc, char** argv)
{
	int a = 4;
	//Esta es la unica manera de almacenar un valor en un puntero a void.
	//Los punteros a void almacenan cualquier tipo de puntero.
	Direccion dir=&a;
	//No se puede asignar la direccion de una constante!
	//ie Direccion dir=&b; Siendo b int const b = 45;
	printf("-----------------\n");
	Address(dir)
	Address(dir)
	printf("-----------------\n");
	printf("a=%i\n",a);
 
	//Vamos a modificar indirectamente el valor de la variable a
	*(int *) dir = 65;
	//Nota: Los punteros a miembros y los punteros a funciones no pueden asignarse a un puntero a void!
	printf("-----------------\n");
	Address(dir)
	Address(dir)
	printf("-----------------\n");
	printf("a=%i\n",a);
 
	printf("Siguen iguales! No podemos cambiar las referencias de un puntero, pero si copiar su contenido!\n");
	printf("Tambien teniendo el puntero a void podemos castearlo para usar el valor al que apunta en diferentes formatos!\n");
 
	printf("Imprimimos la variable a en char %c",(* ((char*) dir)));
	return 0;
}

¿Y si tengo estructuras?, En ese caso se tiene que hacer que todos los elementos tengan el mismo tamaño que la estructura mas grande, sino al imprimirla o tratar con ella, supongase que tengo una estructura que pesa 12 bytes y tengo elementos de tipo int en la misma lista. Al imprimir todos los elementos, cuando quiera imprimir como del tipo de la estructura a los tipo int, va a tirar un segmentation fault. O sino tambien se puede tener una estructura "tipo nodo" que tenga un campo que permita discernir de que tipo es el elemento al que apunta.

#include <stdio.h>
#include <stdlib.h>
typedef struct asd{
	char * n;
} asd;
 
int main() {
	asd j;
	int* k = (int*) malloc (sizeof(asd));
	*k = 4;
	j.n = "Hola\0";
	void* dir=&j;
	printf("%s\n",((asd*)(dir))->n);
	printf("%i\n",(*((int*)(dir))));  
	dir = &k;
	printf("%s\n",((asd*)(dir))->n);
	printf("%i\n",(*((int*)(dir))));  
	return 0;
}

Muy bien, re lindo poder castear dinámicamente cualquier otra variable, pero ¿Para que me sirve realmente?, para armar estructuras genéricas, donde puedas tener varios tipos de datos. aqui tienen un ejemplo de una lista genérica:

#include <stdio.h>
#include <stdlib.h>
 
typedef struct t_Persona {
	char* nombre;
	char* apellido;
} t_Persona;
 
//Decimos que un puntero a void es sinonimo de una direccion.
typedef void* t_Direccion;
 
typedef struct t_Lista {
	t_Direccion* dato;
	//El size NO lo necesitamos simplemente para saber cuantos elementos tenemos, SI lo necesitamos para seguirle la pista
	//A cuanto espacio tenemos que alocar.
	int size; 
} t_Lista;
 
//El tipo iterador contiene la lista y la posicion actual dentro de ella
typedef struct t_Iterador {
	t_Lista* lista;
	//Nodo actual para recorrer
	int actual;
} t_Iterador;
 
t_Iterador tIterador_Crear () {
	t_Iterador nue;
	nue.lista= (t_Lista*) malloc (sizeof(t_Lista));
		(nue.lista)->size=0;
		(nue.lista)->dato=NULL;
	nue.actual=0;
	return nue;
}
 
void tIterador_Iniciar(t_Iterador* iter) {
	iter->actual=0;
}
 
/* Notese la diferencia entre el crear y el iniciar; El crear nos crea una nueva instancia, y el iniciar
 * prepara el iterador para iterar, recibiendo la lista sobre la cual va a trabajar y poniendo su posicion
 * actual a cero. */
 
/*Un simple agregar al final*/
 
void tIterador_Agregar (t_Iterador* iter, t_Direccion i) {
	if (iter->lista->size == 0) {
		iter->lista->dato = (t_Direccion*) malloc (sizeof(t_Direccion)*(++iter->lista->size));
	} else { 
		iter->lista->dato = (t_Direccion*) realloc (iter->lista->dato, sizeof(t_Direccion)*(++iter->lista->size));
	}
	iter->lista->dato[iter->actual++] = i;	
}
 
/*Funciones que imprimen en diferentes formatos, utilizadas para el imprimir*/
 
void imprimirEnteros (t_Direccion x) {
	printf("%i, ",*((int*)(x)));
}
 
void imprimirCaracteres (t_Direccion x) {
	printf("%c, ",*((char*)(x)));
}
 
void imprimirStrings (t_Direccion x) {
	printf("%s, ",((char*)(x)));
}
 
/* No escatimes en el uso del parentesis en estos casos!!! */
/* void imprimirPersonas (t_Direccion x) {
	printf("%s %s, ",((t_Persona*)(x))->nombre, ((t_Persona*)(x))->apellido);
} */
/* En estos casos hay que asegurarse de que todos los elementos tienen el mismo tamaño*/
 
/*El imprimir generico*/
/*Nomenclatura de una funcion pasada como parametro a otra (puntero a funcion)
 *TIPORETORNO (*NOMBRE)(PARAMETROS) Notese que para un puntero a funcion el asterisco se usa a la izquierda*/
void tIterador_Imprimir (t_Iterador* iter, void (*criterio)(t_Direccion)) {
	criterio(iter->lista->dato[iter->actual]); /*Modo de uso de un puntero a funcion*/
}
 
int tIterador_Fin (t_Iterador* iter) {
	return (iter->actual < iter->lista->size)?(1):(0);
}
 
void tIterador_Avanzar (t_Iterador* iter) {
	iter->actual++;
}
 
int main(int argc, char** argv)
{
 
	int a=65, b=66, c='a', d=68, e='c';
	char* f = "Holaaa";
	t_Iterador iter = tIterador_Crear();
 
	tIterador_Iniciar(&iter);
 
	/*Vamos a agregar los numeros del 65 al 70*/
	tIterador_Agregar(&iter, &a);
	tIterador_Agregar(&iter, &b);
	tIterador_Agregar(&iter, &c);
	tIterador_Agregar(&iter, &d);
	tIterador_Agregar(&iter, &e);
	tIterador_Agregar(&iter, f); //Look!
 
	/*Imprimimos como enteros*/
	tIterador_Iniciar(&iter);
	/*Al imprimir le pasamos la funcion que va a usar como criterio de conversion*/
	while ((tIterador_Fin(&iter))) {
		tIterador_Imprimir(&iter, imprimirEnteros);
		tIterador_Avanzar(&iter);
	}
	printf("\n");
	/*Imprimimos como Caracteres*/
	tIterador_Iniciar(&iter);
	/*Al imprimir le pasamos la funcion que va a usar como criterio de conversion*/
	while ((tIterador_Fin(&iter))) {
		tIterador_Imprimir(&iter, imprimirCaracteres);
		tIterador_Avanzar(&iter);
	}
	printf("\n");	
	/*Imprimimos como Strings*/
	tIterador_Iniciar(&iter);
	/*Al imprimir le pasamos la funcion que va a usar como criterio de conversion*/
	while ((tIterador_Fin(&iter))) {
		tIterador_Imprimir(&iter, imprimirStrings);
		tIterador_Avanzar(&iter);
	}	
 
	return 0;
}

Lo de t_Persona solamente lo deje expresado para que se sepa como se debería hacer la comparacion si se hubiera alocado el espacio suficiente.