Hola, gente.
Tengo un inconveniente en la validación para que no se supere el máximo y el mínimo que soporta el tipo float, en internet no encuentro nada relacionado y modifique el código muchas veces y nada, solo me deja ingresar números negativos.

#include <stdio.h>
#include <float.h>
 
float suma( const float o1, const float o2 );
float resta( const float o1, const float o2 );
float division( const float o1, const float o2 );
float multiplicacion( const float o1, const float o2 );
 
 
int main( void ){
	float (*ptrf[]) ( float, float ) = {suma, resta, division, multiplicacion};
	int ok, ch, opc;
	float opeUno, opeDos, result; 
 
	printf( "\n ========== Calculadora ==========\n\n" );
 
	do{
		printf("\n Introduzca el primer operando....:");
		ok = scanf("%g", &opeUno) == 1 && opeUno <= FLT_MIN && opeUno <= FLT_MAX;
		while ((ch = getchar()) != EOF && ch != '\n');
	}while(!ok);
 
	do{
		printf("\n Introduzca el segundo operando...:");
		ok = scanf("%g", &opeDos) == 1 && opeDos <= FLT_MIN && opeDos <= FLT_MAX;
		while ((ch = getchar()) != EOF && ch != '\n');
	}while(!ok);
 
	printf( "\n 1 - Suma \n 2 - Resta \n 3 - Divide \n 4 - Multiplica" );
	do{
		printf( "\n\n Ingrese una opcion...:" );
		ok = scanf("%d", &opc) == 1 && opc >= 1 && opc <= 4;
		while ((ch = getchar()) != EOF && ch != '\n');
	}while(!ok);
 
	result = ( ptrf[opc-1] ) ( opeUno, opeDos );
 
	printf( "\n El resultado es %g", result );
 
	return 0;
}
 
 
float suma( const float o1, const float o2 ){
	return o1 + o2;
}
 
float resta( const float o1, const float o2 ){
	return o1 - o2;
}
 
float division( const float o1, const float o2 ){
	return o1 / o2;
}
 
float multiplicacion( const float o1, const float o2 ){
	return o1 * o2;
}

Saludos a todos y espero puedan ayudarme a encontrar la solución.-

Hola a todos.
Copie el código de la siguiente página que me indico Eternal Idol, referente a realloc:
http://www.cplusplus.com/reference/cstdlib/realloc/

Y grande fue mi sorpresa cuando descubrí que utilizando memoria dinámica se podía hacer lo mismo que con un array, digo sorpresa porque considero haber leído bastante sobre punteros y en ninguno hace referencia a esto. -
Si esto es correcto, tengo 1 pregunta para hacerles. -
¿Que es más eficiente, utilizar array o memoria dinámica?, para el caso. -  

#include <stdio.h>
#include <stdlib.h>
#include <limits.h>
 
int main ( void ){
	size_t ingresos, n, contador = 0, ok, ch;
	int* numeros = NULL;
	int* mas_numeros = NULL;
 
	do{
		do{
			printf("\n Ingresa un numero entero(maximo %d  => 0 finaliza )....: ", INT_MAX);
			ok = scanf("%u", &ingresos) == 1 && ingresos >= 0 && ingresos <= INT_MAX;
			while( (ch = getchar()) != EOF && ch != '\n' );
			if( ok == 0 ){
				printf( "\n El ingreso es incorrecto, intentelo nuevamente...\n\n\t Pulse una tecla para continuar..." ); getchar();
			} 
		}while(!ok);
 
		contador++;
 
		mas_numeros = (int*)realloc( numeros, contador * sizeof(int) );
 
		if( mas_numeros!=NULL ){
			numeros=mas_numeros;
			numeros[contador-1]=ingresos;
		}
		else{
			free( numeros );
			puts( "Error (re)allocating memory" );
			exit(1);
		}
	}while (ingresos!=0);
 
	printf ("\n Numeros introducidos.....: ");
	for( n=0; n < contador - 1; n++ )
		printf( "%d ",numeros[n] );
 
	free (numeros);
 
	return 0;
}

Es redundante decir que al código original le efectué bastante modificaciones, pero la esencia es la misma.

Saludos.

Hola, gente. -
¿Es necesario liberar los 2 punteros por separado?, como lo hago en el código que dejo a continuación o es suficiente con liberar el puntero que devuelve malloc (tengo claro que malloc retorna un puntero void). -

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
int main( void ){
	char *string1, *string2;
	string1 = (char*) malloc(16);
	strcpy(string1, "0123456789AB");
 
	string2 = realloc(string1, 8);
	printf("string1 Valor: %p [%s]\n", string1, string1);
	printf("string2 Valor: %p [%s]\n", string2, string2);
 
 
	free(string1);
	free(string2);
 
	return 0;
}

Bueno es todo, espero aclaración.
Un abrazo.

Hola, gente.
Nuevamente con cositas que no puedo resolver consultando al amigo Google, de la manera como está planteado el programa ¿es imposible liberar la memoria asignada al puntero arr?, el manual aconseja que nunca se reserve memoria de esta manera, pero aunque sea para tener un conocimiento más, es realmente cierta mi pregunta. -

#include <stdio.h>
#include <stdlib.h>
 
int *asignar_Array(int size, int valor); 
 
int main( void ){
	size_t i;
	int *vector = asignar_Array(5,45);
 
	for( i=0; i<5; i++ ){
		printf("\n %d", vector[i]);
	}
 
	free(vector);
 
	return (EXIT_SUCCESS);	
}
 
int *asignar_Array(int size, int valor) {
	size_t i;
	int *arr = (int*)malloc( size * sizeof(int ));
 
	for( i=0; i<size; i++ ) {
		arr[i] = valor;
	}
 
	return arr;
}

Saludos.

Hola, gente.
Lo que me trae en este caso es una duda con la función free, con el libro que estoy estudiando punteros a cada instante remarca que la función free es insegura, no pongo aquí los argumento porque necesitaría 2 post, la pregunta es ¿por su experiencia consideran que esto es cierto?, debería utilizar la función que dejo a continuación o es esto una falacia. -

#include <stdio.h>
#include <stdlib.h>
 
#define safeFree(p) saferFree((void**)&(p))
 
void saferFree(void **pp); 
 
int main( void ){
	int *pi;
	pi = (int*) malloc(sizeof(int));
	*pi = 5;
 
	printf("\n Antes.....: %p\n",pi);
 
	safeFree(pi);
 
	printf("\n Despues...: %p\n",pi);
 
	safeFree(pi);
 
	return (EXIT_SUCCESS);	
 
}
 
void saferFree(void **pp) {
	if (pp != NULL && *pp != NULL) {
		free(*pp);
		*pp = NULL;
	}
}

Saludos.
Daniel

Hola gente.
Como veo que por allí MAFUS hizo un desafío, bueno esto es algo parecido solo que yo no tengo suficientes conocimientos para desafiar a nadie, la consulta es ¿conocen otra manera para logrear lo mismo?.-

#include<stdio.h>
 
int main( void ){
	int numero = 12345, i, b = 1, temp = 0, x;
 
	for( i = 0; i < 32; i++ ){
		temp += numero & b;
		x = numero & b;
		if( x > 0 ) printf("\n bit encendido ==> [%2d] = %d", i, x);
		b <<= 1;
	}
 
	printf( "\n\n La direccion de memoria %p contiene el valor %d\n\n", &numero, temp );
 
	return 0;	
}

Cuando el número es positivo, el simple pero cuando es negativo se me complica un poco entenderlo.-
 



Saludos.
Daniel

Hola, a todos.
Desearía  que alguien me ayude a entender la utilidad práctica de los punteros dobles, entiendo que una variable puntero apunta a la dirección de memoria donde está alojada una variable del mismo tipo, o sea su valor es la dirección de memoria de una variable común.-
Un puntero doble apunta a otro puntero, si bien mi descripción no es para escribir un libro pero es lo que hay.-
Por ahí leí que los punteros dobles se asemejan a los array de 2 dimensiones, es esto cierto y porque?.-
El manual con el que estoy estudiando punteros pone este ejemplo pero no tengo claro el beneficio en utilizar punteros dobles, el autor en este caso no da demasiadas explicaciones sobre el tema, no me cabe dudas que más adelante profundizara  sobre el particular pero me gustaría aprenderlo de Uds. El libro tiene más de 200 páginas dedicadas exclusivamente a punteros y de paso está en inglés.-

#include <stdio.h>
 
int main( void ){
	char *titles[] = {"A Tale of Two Cities",
		"Wuthering Heights","Don Quixote",
		"Odyssey","Moby-Dick","Hamlet",
		"Gulliver's Travels"};
 
	char **bestBooks[3];
	char **englishBooks[4];	
 
	bestBooks[0] = &titles[0];
	bestBooks[1] = &titles[3];
	bestBooks[2] = &titles[5];
	englishBooks[0] = &titles[0];
	englishBooks[1] = &titles[1];
	englishBooks[2] = &titles[5];
	englishBooks[3] = &titles[6];
 
	printf("%s\n\n",*englishBooks[1]);	/*Wuthering Heights*/
 
	return 0;
}

   

Bueno es todo por el momento y desde ya muchas gracias.-
Daniel

Hola, gente.
Esta vez los molesto por poco, me podrían decir que tengo que agregar a mi código para medir el tiempo que tarda en ejecutarse, busqué en foros y lo que intené no funcionó. -
Es probable que me quieran dar un tirón de orejas por tratar de reinventar la rueda, pero créanme que es tan solo para practicar con punteros y de paso cotejarlo con el método de la burbuja y saber que es más rápido si un doble for o un bucle while. -

#include <stdio.h>
 
void ordenar(size_t *ptrV, size_t elementos);
void mostrar(size_t *ptrV, size_t elementos);
 
int main( void ){
	size_t vector[] = {99, 8, 13, 6, 104, 40, 7, 2, 1}, *ptrV = vector;
	static size_t elementos = sizeof (vector) / sizeof (size_t);
 
	ordenar(ptrV, elementos);
	mostrar(ptrV, elementos);
 
	return 0;
}
 
void ordenar(size_t *ptrV, size_t elementos){
	size_t i, tmp = 0;
 
	while(1){
		if( *(ptrV+i) >  *(ptrV+(i+1)) ){
			tmp = *(ptrV+i);
			*(ptrV+i) = *(ptrV+(i+1));
			*(ptrV+(i+1)) = tmp;
		}
		if( i+1 == elementos ){
			if( tmp == 0) break;
			else{tmp = 0; i = -1;}
		}	
		i++;
	}
}
 
void mostrar(size_t *ptrV, size_t elementos){
	size_t i;
 
	for( i = 0; i < elementos; i++ )
		printf( " %u", *(ptrV+i) );
}

Desde ya muchas gracias. -

Saludo.
Daniel

Hola, gente.
Tengo un error que por más que investigo no logro solucionar, hice un montón de pruebas como con la función printf para saber si accedía a la posición de memoria correcta y realmente en todos los casos imprimía la fila correcta y el contenido de la primer columna, pero siempre al acceder a esta parte del programa el mismo se cierra. -
Un favorcito más, si alguien conoce otra manera para lograr lo mismo le agradecería me dé alguna pista. - 


lineas 67 y 73

#include <stdio.h>
#include <ctype.h>
#include <windows.h>
 
int ingreso( int monto[] );
void mostrar( int monto[], int contador );
 
 
int main( void ){
	int monto[3], contador = 0;
 
	contador = ingreso( monto );
	mostrar( monto, contador );
 
	return 0;
}
 
int ingreso( int monto[] ){
	int ch, ok, contador ;
 
	do{
		system("cls||clear");	
		ok = 1; contador = 0;
		printf("\n\n Ingrese monto del cheque (superior a \"0\" e inferior a \"1000\")....:" );
		while(( ch = getchar()) != '\n'){
			if( isdigit(ch) ){
				if( contador < 3 ){
					monto[contador] = ch - '0';
					contador++;
				}
				else{
					ok = 0;
				}
			}
			else{
				ok = 0;
			}
		}
		if( ok == 0 || monto[0] == '0'){
			printf( "\n Ingreso incorrecto...\n\n\tPulse <Enter> para intentarlo nuevamente..." );
			getchar();  
			ok = 0;
		}
	}while(!ok);	
 
	return contador;
}
 
void mostrar( int monto[], int contador ){
	char  *unidades[] = { "", "uno", "dos", "tres", "cuatro", "cinco", "seis", "siete", "ocho", "nueve", "diez" },
	      *decenas[]  = { "veinte", "treinta", "cuarenta", "cincuenta", "sesenta", "setenta", "ochenta", "noventa" },
		  *centenas[] = { "", "Cien", "Doscientos", "Trescientos", "Cuatrociento", "Quinientos",
								"Seiscientos", "Setecientos", "Ochocientos", "Novecientos" },
		  *especiales[] = { "Diez", "Once", "Doce", "Trece", "Catorce", "Quince", "Dieciseis", "Diecisiete",
								  "Dieciocho", "Diecinueve", "Veinti" };	
	int tmp;
 
	if( contador == 1 ){
		printf( "\n %s", unidades[monto[0]] );
	}
 
	if( contador == 2 ){
		tmp = monto[0]-2;
		if( monto[0] == 1)
			printf( "\n %s ", especiales[monto[1]] );
		else if( monto[1] == 0 ){
			decenas[tmp][0] = toupper(decenas[tmp][0]);  
			printf( "\n %s", decenas[monto[0]-2] );
		}
		else if( monto[0] == 2 && monto[1] > 0 )
			printf( "\n %s%s", especiales[10], unidades[monto[1]] );
		else{
			decenas[tmp][0] = toupper(decenas[tmp][0]);  
			printf( "\n %s y %s", decenas[monto[0]-2], unidades[monto[1]] );
		}
	}
 
	if( contador == 3 ){
		printf( "\n %s ", centenas[monto[0]] );
		if( monto[1] == 0 )
			printf( "%s", unidades[monto[2]] );
		else if( monto[1] == 1 )
			printf( "%s", especiales[monto[2]] );
		else
			printf( "%s y %s", decenas[monto[1]-2], unidades[monto[2]] );
	}
}
 
 
/*
Ejercicio 6-1. Escriba un programa que solicite un número entero positivo menor que 1000
y a continuación, cree y genere un valor de tipo string que es el valor del entero en palabras.
Por ejemplo, si 941 es introducido, el programa creará la cadena "Novecientos cuarenta y uno".
*/

Saludos.
Daniel

Hola.

		fgets( word[i], MAX_COL , stdin );
 
		if((p=strchr(word[i], '\n'))){
			*p='\0';
		}
		else{
			while((ch = getchar()) !='\n' && ch!=EOF);
			word[i][MAX_COL] = '\0';
		}

En este trozo de código está mi gran duda, según lo que tengo leído es que si ingreso menos caracteres que  MAX_COL fgets los guarda desde el buffer de teclado en la variable indicada, en este caso word y también el carácter de nueva línea (\n) que se produce al apretar < Enter >, la primera duda, ¿es estrictamente necesario remplazar el carácter \n por \0? -
En el caso de ingresar más caracteres del establecido por MAX_COL fgets lee  MAX_COL – 1 y en la última casilla de memoria asignada a MAX_COL copia el carácter \n, de ser esto cierto la otra duda es:  ¿la sentencia else no se ejecuta nunca en este caso, o estoy equivocado?

Es todo y desde ya muchas gracias por el tiempo que le dediquen al tema,-

Saludos.
Daniel