EDITADO
SE AGREGARON VERSIONES MEJORADAS PARA NO HACER USO DE TABLAS, NI DE FUNCIONES INNECESARIAS COMO LOG, POW, STRLEN, de CTYPE, de STRING, etc
SIN ASIGNACIONES DINÁMICAS, y USANDO MACROS PARA HACER EL CÓDIGO MÁS LEGIBLE..
//////////////////
Estaba repasando un poco cómo había hecho las implementaciones personales de estas funciones,
http://foro.elhacker.net/programacion_cc/atoi_itoa_personalizadas-t358459.0.html;msg1734670#msg1734670
..pero antes de hacer una implementación lo primero es saber como funciona realmente la original.. en base a esto es que decidí arreglar estas funciones siguiendo la misma lógica de construcción, que por cierto es una que suelo usar seguido.
Empezando por ATOI
/********************************************************************************************************
// By 85
// boyscout_arg@hotmail.com
// etalking.com.ar
// David Riedel
// 2013
*********************************************************************************************************/
#pragma warning (disable:4305)
#pragma warning (disable:4309)
#pragma warning (disable:4244)
#pragma warning (disable:4018)
#include <windows.h>
#include <stdlib.h>
#include <stdio.h>
/////
// Sin necesidad de llamadas innecesarias a funciones de CTYPE, MATH, STRING, etc
// Sin necesidad de Tablas, solo un array con los números enteros que tampoco es necesario
// pero no hace la gran diferencia ;-D
//////////////////////////////////////////////////
//Se requiere pasar una cadena terminada en CERO!.
//Si no se le pasa una cadena terminada en CERO, la función va a buscar el
//primer 0 que encuentre y puede terminar en una sección de memoria contigua
//que no pertenece a la cadena pasada como parámetro.
int mi_atoi(const char* str)//Respetar el tipo de parámetro (Sólo cadenas)
{
int len, ocurrencias =0, sig=0;
for(len=0; str[len]; len++);
for(int a=0; a<len;a++) if((str[a]>=48&&str[a]<=57)) ocurrencias++;
if(ocurrencias==0) return 0;
if((sig=str[0]=='+')||(sig=str[0]=='-')) ocurrencias+=1;
if(ocurrencias<len) return 0;//Casos "11f" son 0
if(len==1) return str[0]-'0';
int ac=0, v1, cifras = len,m = 1;
for(int x=0;x<((cifras-1)-sig);x++) m*=10;
for(int i=sig;i<cifras;i++){//Factoriza y acumula
v1=str[i]-'0';
v1*=m;
ac+=v1;
m/=10;
}
if(str[0]=='-') ac*=-1;
return ac;
}
////////////////////
int main(){
// char str = 'B';
// int entero = mi_atoi(&str);
// char* str = "asdasd\0";
// int entero = mi_atoi(str);
// char* str = "8a3\0";
// int entero = mi_atoi(str);
// char* str = "83312321\0";
// int entero = mi_atoi(str);
// char* str = "000000099\0";
// int entero = mi_atoi(str);
// char* str = "9\0";
// int entero = mi_atoi(str);
// char* str = "20\0";
// int entero = mi_atoi(str);
// char* str = "500\0";
// int entero = mi_atoi(str);
// char* str = "+500\0";
// int entero = mi_atoi(str);
// char* str = "0500\0";
// int entero = mi_atoi(str);
// char* str = "0\0";
// int entero = mi_atoi(str);
// char* str = "10f\0";
// int entero = mi_atoi(str);
// char* str = "01ff\0";
// int entero = mi_atoi(str);
// char* str = "0f\0";
// int entero = mi_atoi(str);
// char* str = "+12\0";
// int entero = mi_atoi(str);
// char* str = "+12\0";
// int entero = mi_atoi(str);
// char* str = "03232\0";
// int entero = mi_atoi(str);
// printf("%d", entero);
printf("%d\n",mi_atoi("-110"));
printf("%d\n",mi_atoi("-10"));
printf("%d\n",mi_atoi("0"));
printf("%d\n",mi_atoi("1"));
printf("%d\n",mi_atoi("-1"));
printf("%d\n",mi_atoi("-11"));
printf("%d\n",mi_atoi("-2"));
printf("%d\n",mi_atoi("-200"));
printf("%d\n",mi_atoi("-220"));
printf("%d\n",mi_atoi("+0"));
printf("%d\n",mi_atoi("-0"));
printf("%d\n",mi_atoi("+1"));
printf("%d\n",mi_atoi("+33"));
printf("%d\n",mi_atoi("-330"));
printf("%d\n",mi_atoi("-3000"));
// printf("%d\n",mi_atoi("-1"));
// printf("%d\n",mi_atoi("-200"));
// printf("%d\n",mi_atoi("-220"));
printf("%d\n",mi_atoi("+12"));
printf("\n");
system("pause");
return 0;
}
El problema que enfrenta esta función es cuando alguien trata de pasarle un parámetro que no es una cadena, por ejemplo un 'char'
char str = 'B';
int entero = mi_atoi(&str);
se lo hace de esa forma especificando la dirección de la variable, pero en la función original ATOI esto devuelve 0, según mis pruebas.
y al respecto revisaba también unos post en los cuales se hablaba acerca de la utilidad del operador ternario, como se puede observar son muy útiles para usarlos como índices en matrices y vectores.
http://foro.elhacker.net/programacion_cc/calcular_el_maximo_usando_operador-t383707.0.html
http://foro.elhacker.net/programacion_cc/aporte_operador_condicional-t383420.0.html
int tab1[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
val1 = tab1[(str[i]=='0' ? 9:(((int)str[i]-48)-1))];
para los principiantes les explico que la evaluación que se hace es que si el caractér es 0 se procede a usar el número 9 como índice, de otra forma se usa otro índice..
Bueno y la implementación de ITOA es esta:
/********************************************************************************************************
// By 85
// boyscout_arg@hotmail.com
// etalking.com.ar
// David Riedel
// 2013
*********************************************************************************************************/
#pragma warning (disable:4305)
#pragma warning (disable:4309)
#pragma warning (disable:4244)
#pragma warning (disable:4018)
#include <windows.h>
#include <stdlib.h>
#include <stdio.h>
/////
// Sin necesidad de llamadas innecesarias a funciones de CTYPE, MATH, STRING, etc
// Sin necesidad de Tablas, sólo un array con los números enteros que tampoco es necesario
// pero no hace la gran diferencia ;-D
//////////////////////////////////////////////////
char* mi_itoa(int num, char* str)
{
int sig = -1;
if(num<0){
num*=-1;
if(num<10){
str[0]='-'; str[1]='0'+num; str[2]=0; return str;
} else {
sig=1;
}
}
else if(num==0){
str[0]='0'; str[1]=0; return str;
} else {
if(num<10){
str[0]='0'+num; str[1]=0; return str;
} else {
sig=0;
}
}
if(sig!=-1){
int copia= num, m = 1, cifras = 1;
for(;copia>=10;copia/=10) cifras++;
for(int x=0;x<(cifras-1);x++) m*=10;
float v1=num;
int v2=0, v3=num;
if(sig) str[0]='-';
for(int i=0; i<cifras; i++){//Descompone en factores
v1/=m;
v2=(int)v1*m;
v3-=v2;
m/=10;
str[i+sig]=48+(int)v1;
v1=v3;
}
str[i+sig]=0;//Si str está a 0 no es necesario..
}
return str;
}
///////////////////
int main(){
char str[256];
// mi_itoa(321312,str);
// printf(str);
// itoa(02321,str,10);
// printf(str);
// mi_itoa(02321,str);
// printf(str);
// mi_itoa(-12321,str);
// printf(str);
// itoa(-012321,str,10);
// printf(str);
// mi_itoa(-012321,str,10);
// printf(str);
// mi_itoa(555,str);
// printf(str);
// mi_itoa(0,str);
// printf(str);
// mi_itoa(1,str);
// printf(str);
// mi_itoa(500,str);
// printf(str);
printf(mi_itoa(+321312,str));printf("\n");
printf(mi_itoa(-321312,str));printf("\n");
printf(mi_itoa(321312,str));printf("\n");
printf(mi_itoa(+0,str));printf("\n");
printf(mi_itoa(0,str));printf("\n");
printf(mi_itoa(-0,str));printf("\n");
printf(mi_itoa(+1,str));printf("\n");
printf(mi_itoa(1,str));printf("\n");
printf(mi_itoa(-1,str));printf("\n");
printf(mi_itoa(10,str));printf("\n");
printf(mi_itoa(+10,str));printf("\n");
printf(mi_itoa(-10,str));printf("\n");
printf(mi_itoa(-110,str));printf("\n");
printf(mi_itoa(-100,str));printf("\n");
printf(mi_itoa(-5000,str));printf("\n");
printf(mi_itoa(-55555,str));printf("\n");
printf(mi_itoa(550,str));printf("\n");
printf(mi_itoa(500,str));printf("\n");
printf(mi_itoa(+330,str));printf("\n");
printf(mi_itoa(-000,str));printf("\n");
printf(mi_itoa(+000,str));printf("\n");
// printf(mi_itoa(+00009,str));printf("\n");
printf(mi_itoa(+109,str));printf("\n");
printf(mi_itoa(-109,str));printf("\n");
// printf(mi_itoa(-09,str));printf("\n");
// printf(mi_itoa(+09,str));printf("\n");
printf(mi_itoa(-999,str));printf("\n");
// printf(mi_itoa(-00000999,str));printf("\n");
printf("\n");
system("pause");
return 0;
}
/////
cualquier problema diganme, sólo trataba de crear un par de funciones que funcionen tal cual las originales, y usando la misma lógica que venía usando.
les dejo el proyecto en MSVC++ 6 ya que es el compilador que tengo para esta clase de minipruebas, tengo el 2010 también..
http://www.mediafire.com/?wbscy4bu2vrq273
Cita de: 85 en 22 Febrero 2013, 03:32 AMEl problema que enfrenta esta función es cuando alguien trata de pasarle un parámetro que no es una cadena, por ejemplo un 'char'
char str = 'B';
int entero = mi_atoi(&str);
La función atoi no puede conocer a prior si se pasa la dirección de una cadena o un carácter, esta literalmente confía en que sera usada correctamente. En otras palabras no tienes que preocuparte ya que eso es responsabilidad de quien llama a tu función.
Cita de: 85 en 22 Febrero 2013, 03:32 AM
se lo hace de esa forma especificando la dirección de la variable, pero en la función original ATOI esto devuelve 0, según mis pruebas.
El comportamiento de atoi es el siguiente:
1) Se descarta el espacio blanco.
2) Se procesa el signo.
3) Se procesan los dígitos hasta encontrar un carácter no valido.
Si por lo menos se procesa un dígito se retorna el numero, caso contrario la función debe retornar cero. No es lo ideal ya que ante una cadena como "123JKL" la función retorna 123 pero bueno, esa es su especificación.
----
En tus funciones no es necesario utilizar tablas. Para obtener el entero o carácter correspondiente solo debes sumar (o restar, dependiendo del caso) el valor '0':
'0' + Digito == '0', '1', '2', ... /* Digito == 0, 1, 2, ... */
Caracter - '0' == 0, 1, 2, ... /* Caracter == '0', '1', '2', ...*/----
Una implementación de la función atoi con el comportamiento indicado:
#include <ctype.h>
int fn_atoi(const char *p)
{
int num = 0;
int sign = 1;
while (isspace(*p))
p++;
if (*p == '-'){
sign = -1;
p++;
}else if (*p == '+')
p++;
while (isdigit(*p)){
num = num * 10 + *p - '0';
p++;
}
return sign * num;
}Y una implementación de itoa (que por cierto no es parte de la biblioteca estándar de C) es:
#include <math.h>
char *fn_itoa(int num, char *str)
{
char *p = str + 1;
if (num < 0){
*str = '-';
num = -num;
p++;
}
if (num >= 10)
p += (int) log10(num);
*p = '\0';
do {
*--p = '0' + num % 10;
}while ((num /= 10) > 0);
return str;
}Un saludo
Aún se puede cambiar las CTYPE por algo como
Citar>=48&&<=57
, evitaríamos código extra
la tabla no es realmente necesaria es cierto, viene quedando de anteriores versiones; me gusta la ITOA como quedó
Saludos
Cita de: 85 en 24 Febrero 2013, 00:19 AMAún se puede cambiar las CTYPE por algo como Citar>=48&&<=57
, evitaríamos código extra
No porque sin un motivo de peso se afectaría la claridad en el código fuente. En la misma linea mejor evitar el uso de 48 y 57 sustituyendo estos por '0' y '9', el valor es el mismo con la ventaja de indicar el contexto (proceso de caracteres).
Casi lo olvido, bucles como este:
int copia = num;
int unidades_decimales = 1;// unidad de 1
while(1)
{
if(copia>=10)
{
copia /= 10;
unidades_decimales++;
}
else
{
break;
}
}Los puedes reducir a:
int unidades_decimales = 1;
int copia;
for (copia = num; copia >= 10; copia /= 10)
unidades_decimales++;Por ultimo, ¿Estas aprendiendo C en base a un buen libro? Si todavía no tienes uno de calidad te recomiendo "The C Programming Language" o bien "Pointers on C", puedes obtener mas información sobre ellos mediante el motor de búsqueda de los foros.
Un saludo
EDITADO: Discusión no objetiva
Amigo te cuento algo,
esto:
Citar>=48&&<=57
SI, lo deberías usar ya que te vuelvo a decir SI es necesario si te gusta optimizar las cosas.
no es necesario que hagás un salto a una rutina en otra parte para ejecutar un código innecesario,
sabiendo que comparando algo directamente así:
Pseudocódigo
Citar
if(>=48&&<=57);
else NO ES UN ESPACIO NI CUALQUIER OTRA COSA SINO SÓLO NÚMEROS
Esto:
while(1)
{
if(copia>=10)
{
copia /= 10;
unidades_decimales++;
}
else
{
break;
}
}
Y esto:
int unidades_decimales = 1;
int copia;
for (copia = num; copia >= 10; copia /= 10)
unidades_decimales++;
es lo mismo al traducirse a ASM ya que lo que vos plantéas es un cambio al nivel de TEXTO en el código humanizado o de alto nivel (C). Prestá atención que realizan las mismas operaciones y sino lo hicieran, termina siendo lo mismo porque el compilador te cuento que optimiza el código automáticamente, a lo máximo tal REDUCCiÓN termina siendo algo así como un par de instrucciones insignificantes:
push
push
call
.......
push ebp
mov ebp, esp
mov esp, ebp
pop ebp
retn
add esp, 0x8
y asumiento que no cambiás la convención de llamada a __stdcall o __fastcall, en cuyo caso la pila se limpia automáticamente por el código que hace la llamada (callee)
@85, te estas equivocando, @rir3760 solo pretende ayudar, ha sido respetuoso y si que ha optimizado bastante tus codigos. Que te parezca que son mas dificiles de entender para una persona solo demuestra que te da mil vueltas codeando.
Si no puedes aceptar que mejoren un aporte que has hecho de forma constructiva, no se porque lo publicas.
¿En que mensaje rir3760 menciono el termino optimizar? En ninguno. ¿Verdad? Eso lo dice todo 85, mejor revee tu postura, tu reaccion estuvo fuera de lugar y deberias agradecer por los datos concretos que te aportaron (vease que uno debe respetar el tipo de los parametros que se le pasan a una funcion).
EDITADO: Discusión no objetiva
Dejando la discusión de lado, si vamos a hablar de optimizaciones en serio vayamos directamente al código ensamblador, porque jugar con palabras de código humanizado no representa precisamente una optimización para la PC, sino más bien para REDUCIR líneas de texto que dan la impresión VISUAL de una simplificación.
Encontré una versión en ASM, hecha por sk0r
__declspec(naked) int __stdcall m_atoi(char* szTarget, unsigned int dwLength)
{
#define SUB_OFFS 48
__asm {
push ebp; //Save old framepointer value
mov ebp, esp; //Copy ESP into EBP -> EBP:[Old-EBP:4][Ret-Addr:4][dwLength:4][szTarget:4]
sub esp, 5; //Allocate 5 bytes [EBP-4]: unsigned int dwResult, [EBP-5]:char cMinusChar
mov dword ptr [ebp-4], 0; //Zero bytes of dwResult value. dwResult holds entire result value
mov byte ptr[ebp-5], 0; //Zero byte of cMinusChar. cMinusChar holds first char @szTarget for '-' check
cmp szTarget, 0; //Check if szTarget is a null pointer
je fEnd; //If so goto function end
cmp dwLength, 0; //Check if string length is zero
je fEnd; //If so goto function end
//Save registers for use
push ebx; //Holds mulitplied value of current positon.
push ecx; //Used for loop cmd
push edx; //For saving temporary stuff
push esi; //Holds start address + length of string
pushf; //For modifying direction flag
mov ebx, 1; //Set to one. The first position is the ones, second tens, third hundrets, etc.
mov ecx, dwLength; //Copy length to ECX for counting
mov esi, szTarget; //Copy string address to ESI
add esi, ecx; //Add string length
dec esi; //Decrement not to go too far (because of zero position)
push eax; //Save EAX temorarly
mov eax, szTarget; //Copy string address to EAX
mov al, byte ptr[eax]; //Copy the first byte to AL
mov byte ptr[ebp-5], al; //Copy it to EBP-5 (cMinusChar)
pop eax; //Restore EAX
cmp byte ptr[ebp-5], '-'; //Check if the char is a minus char
jne fOvr1; //If not goto fOvr1
dec ecx; //Decrement, because we ignore the '-' char to not corrupt the entire number
fOvr1:
std; //Set direction flag to 1 to go from hight to low addresses
fLoop:
xor eax, eax; //Clear bits of EAX
lodsb; //Copy byte at [ESI] to AL and extend ESI (in this case decrement)
sub al, SUB_OFFS; //Substract offset to make from char to real number
mul ebx; //Multiplicate EAX with EBX depending on its current position. Ones with 1, Tens with 10, Hundrets with 100, etc.
mov edx, dword ptr[ebp-4]; //Copy entire result value to EDX
add edx, eax; //Add EAX on it
mov dword ptr [ebp-4], edx; //Copy back to result value
mov eax, ebx; //Copy EBX to EAX
mov ebx, 10; //Copy 10 to EBX
mul ebx; //Multiply with 10 to go to the next positon: 1*10 = 10, 10*10 = 100, 100*10 = 1000, etc
mov ebx, eax; //Copy back to EBX
loop fLoop; //Goto fLoop and decrement ECX if not already zero
cmp byte ptr[ebp-5], '-'; //Check if first char was '-'
jne fOvr2; //If not goto fOvr2
mov eax, [ebp-4]; //Copy result value to EAX
mov ebx, -1; //Copy -1 to EBX
imul ebx; //Make signed multiplication to make a positive value to a negative one
mov [ebp-4], eax //Copy back to result value
fOvr2:
//Restore all used registers
popf;
pop esi;
pop edx;
pop ecx;
pop ebx;
fEnd:
mov eax, dword ptr[ebp-4]; //Copy result value to EAX for result
add esp, 5; //Remove both stack variables
pop ebp; //Restore EBP
ret 8; //Restore Ret-Address and remove the 8 argument bytes
}
}
Hola, que yo sepa atoi ya no se usa pues está obsoleta e itoa no está definida en el estándar de C como decía rir3760 en lugar de todo ello habría que usar:
long int strtol (const char* str, char** endptr, int base);
Referencia: http://www.cplusplus.com/reference/cstdlib/strtol/
Información de atoi obsoleta en la página de la libc: http://www.gnu.org/software/libc/manual/html_node/Parsing-of-Integers.html
Y para itoa se puede usar esto(que lo único que arregla es la portabilidad):
int sprintf ( char * str, const char * format, ... );
En teoría lo de las conversiones de bases debería funcionar con esas funciones.
PD: Digo esto porque tiene poco sentido ponerse a reinventar atoi e itoa ( si es para aprender y practicar si lo tiene ) cuando estas no son usadas o no deberían usarse.
¡Un saludo!
Muy cierto, en realidad no debí haber creado el topic XD ya que siempre alguien lo va a hacer de una forma diferente, o arreglando uno existente, habría miles de implementaciones y en muchos lenguajes. Pero aveces está bueno para el aprendizaje
El tema se inicia con el objetivo:
Cita de: 85antes de hacer una implementación lo primero es saber como funciona realmente la original.. en base a esto es que decidí arreglar estas funciones siguiendo la misma lógica de construcción, que por cierto es una que suelo usar seguido.
Empezando por ATOI
En mi primer mensaje publique el comportamiento de esa funcion, un consejo para reducir las expresiones en tus programas y dos ejemplos. ¿La intencion de estos ultimos? Tener a la vista el codigo fuente de otros realizando la misma operacion, a partir de ahi ya tienes un punto de referencia.
Acabas de publicar dos nuevas versiones de los programas con un comentario que, para decirlo de una forma amable, preocupa:
Cita de: 85SE AGREGARON VERSIONES MEJORADAS PARA NO HACER USO DE TABLAS, NI DE FUNCIONES INNECESARIAS COMO LOG, POW, STRLEN, de CTYPE, de STRING, etc SIN ASIGNACIONES DINÁMICAS, y USANDO MACROS PARA HACER EL CÓDIGO MÁS LEGIBLE
Si la intencion es desarrollar funciones propias con el mismo comportamiento que atoi (estandar) e itoa (extension) me temo que en el caso de la primera esta continua lejos del comportamiento indicado.
Esto lo puedes comprobar imprimiendo el resultado de atoi y tu version de ella, por ejemplo:
printf("%d, %d\n", atoi("+123"), mi_atoi("+123"));
printf("%d, %d\n", atoi(" +123"), mi_atoi(" +123"));
printf("%d, %d\n", atoi(" 123"), mi_atoi(" 123"));Y al utilizar un array que para empezar no es necesario complicas las expresiones, un ejemplo de ello se da si la cadena a procesar es "0", la sentencia:
return tab1[((int)str[0]-48)-1];Resulta en:
return tab1[-1];Hay que eliminar el uso del array, de las macros y usar expresiones mejores, en el sentido de ser mas claras y con un minino de subexpresiones. Por ejemplo al expandirse una macro terminas con la expresion:
val1 = tab1[(int)(str[i]=='0' ? 9:(((int)str[i]-48)-1))]Innecesariamente larga ya que se puede sustituir por:
val1 = str[i] - '0'Por ultimo en el caso de las macros no entiendo porque piensas que hacen el codigo fuente mas legible cuando el efecto es el opuesto.
----
En cuanto a la funcion atoi los problemas aqui son un poco mas complejos. Para empezar las sentencias de retorno (salvo la ultima) estan demas debido a los condicionales.
Tambien debes analizar los dos bloques principales ya que salvo las dos operaciones en el caso de un numero negativo (almacenar el signo en la cadena y cambiarlo a positivo) son identicos. Aqui las dos opciones son restructurar la funcion para tener un solo bloque o bien crear una funcion.
Y como en el caso de la primera funcion hay que eliminar las macros.
Un saludo
Amí me preocupa que esos códigos que publicaste tengan partes parecidas a esto:
http://foro.elhacker.net/programacion_cc/atoi_itoa_personalizadas-t358459.0.html;msg1735068#msg1735068
A no ser que seas blackzero..
Mis modificaciones recientes no fueron probadas, sólamente se quitaron ciertas cosas que no son necesarias, tablas, funciones std, y otras cosas. La idea era quitar las tablas y los llamados innecesarios a funciones ajenas.
lamentable que no funcionen, si necesitás versiones funcionando usá las originales.
Otra cosa , las macros están hechas para simplificar y hacer el código más legible, entre otras cosas.. no se de qué libro aprendiste que no era así.
Todos sabemos que el código en las macros se copia adonde es invocada, no es en sí resumir código sino para simplificar el entendimiento.
No es lo mismo copiar 2 veces el código de la macro FACTORES, que poner 2 veces una sóla línea que diga FACTORES(). Me extraña que no lo entiendas porque eras el más interesado en resumir líneas de TEXTO..
Se entiende que el que usa la macro FACTORES la conoce, sabe su código, no necesita verlo repetido tantas veces. Si no entendés la macro no la uses porque en ese caso, si tenés razón, el código sería más ilegible.
Mi consejo entonces es que no uses macros que no entiendas..
Saludos.
EDITADO 1
hecha una revisión rápida del código, no estaba funcionando ni como las primeras versiones :/
atoi original ante esta situación:
"5f" o "11www"
devuelve 5 u 11
lo cual aunque parece tener sentido, mi función sólo devuelve 0
porque 11www no es 11.
para que cumpla con lo de pasar parámetros correctamente!
Por otro lado , comprueba el signo y guarda un resultado para usarse posteriormente a la hora de diferenciar entre significados y no:
int sig=0;
if((sig=str[0]=='+')||(sig=str[0]=='-'))
..
El índice que mostraste fue considerado como otra opción.
ITOA no fue mayormente revisada, sólo hice algunas pruebas generales, las que aparecen en el ENTRY. Tiene dos bloques de código bastante parecidos como muy bien notaste, y no estaría nada mal inventar algo para usar sólo un bloque de entre ambos.
Saludos
EDITADO 2
Decidí seguir tus sugerencias y quité el array y las macros.
Al mismo tiempo, ahora en MI_ITOA se usa 1 sólo bloque de procesamiento por factores.
Saludos
Cita de: 85 en 27 Febrero 2013, 04:14 AMAmí me preocupa que esos códigos que publicaste tengan partes parecidas a esto:
http://foro.elhacker.net/programacion_cc/atoi_itoa_personalizadas-t358459.0.html;msg1735068#msg1735068
A no ser que seas blackzero.
No, el es otro usuario con quien he tenido el gusto de conversar en algunos temas, por ejemplo [Ayuda] Error con delete[]... algo extraño... (http://foro.elhacker.net/programacion_cc/ayuda_error_con_delete_algo_extrano-t332814.0.html).
¿Que es lo que te preocupa?
Cita de: 85 en 27 Febrero 2013, 04:14 AMOtra cosa , las macros están hechas para simplificar y hacer el código más legible, entre otras cosas.. no se de qué libro aprendiste que no era así.
De uno que te recomendé al principio del tema: "The C Programming Language" de Brian W. Kernighan y Dennis M. Ritchie.
Cita de: 85 en 27 Febrero 2013, 04:14 AMTodos sabemos que el código en las macros se copia adonde es invocada, no es en sí resumir código sino para simplificar el entendimiento.
No es lo mismo copiar 2 veces el código de la macro FACTORES, que poner 2 veces una sóla línea que diga FACTORES(). Me extraña que no lo entiendas porque eras el más interesado en resumir líneas de TEXTO..
No. Yo estoy interesado en reducir el código fuente y eso no se consigue con macros (el numero de sentencias y expresiones es el mismo con o sin ellas). Ejemplos de ello los tienes en este tema, por ejemplo eliminar el array.
Cita de: 85 en 27 Febrero 2013, 04:14 AMSe entiende que el que usa la macro FACTORES la conoce, sabe su código, no necesita verlo repetido tantas veces. Si no entendés la macro no la uses porque en ese caso, si tenés razón, el código sería más ilegible.
Mi consejo entonces es que no uses macros que no entiendas.
Primero me cuestionas con una Falacia del hombre de paja (http://es.wikipedia.org/wiki/Falacia_del_hombre_de_paja) y ahora con un Argumento ad hominem (http://es.wikipedia.org/wiki/Argumento_ad_hominem). Te aclaro: no respondo a ese tipo de comentarios.
Mi argumento es: la mayoría de tus macros no mejoran la claridad del código fuente como tampoco facilitan su desarrollo. Digo "la mayoría" y no "todas" porque haz estado actualizando tus programas.
Bueno, si piensas que mi argumento esta errado podemos discutirlo, no hay problema.
Cita de: 85 en 27 Febrero 2013, 04:14 AMITOA no fue mayormente revisada, sólo hice algunas pruebas generales, las que aparecen en el ENTRY. Tiene dos bloques de código bastante parecidos como muy bien notaste, y no estaría nada mal inventar algo para usar sólo un bloque de entre ambos.
OK. Solo una recomendación: coloca el código fuente de las funciones en un solo lugar (tu primer mensaje).
Un saludo