Mensajes

Hola,
En verdad mi código no tiene problemas, mirá yo te cuento en realidad el uso de tablas viene a razón de que muchos no saben como manejar bytes y al resultarles ilustrativo el hecho de utilizar una tabla en donde se puede observar
el proceso detalladamente.

Al mismo tiempo es reducido en cuanto a líneas de código (funciones simples pero las tablas lo hacen parecer grande) pero costoso en procesamiento debido a la búsqueda secuencial que realiza cada función por separado. Buscar en una tabla de 255 elementos contínuamente, de forma secuencial es obviamente un tanto costoso. Se puede hacer algo como cortar la búsqueda una vez que se encuentra el elemento, eso reduciría la cantidad de ciclos.
Hacer un lookup sería un acceso directo mucho mejor.
Las tablas estoy de acuerdo que su mejor utilización es cuando se las usa como lookups.

Tu código es de la misma forma reducido en líneas de código y posiblemente más rápido, aunque vemos que usás operaciones aritméticas de tipo divisorias, que dependiendo del cpu, y considerando los avances actuales en compiladores y procesadores, que tratan de reemplazar estas operaciones costosas automáticamente con otras (multiplicaciones, operaciones de bits, etc)
también se debe tomar en cuenta, no precisamente en tu código que son algunas pero no tantas.

Te dejo unos enlaces al respecto ya que es un tema que me interesaba en un proyecto anterior..
http://stackoverflow.com/questions/226465/should-i-use-multiplication-or-division
http://bytes.com/topic/c/answers/811057-how-replace-division-operator
http://www.cplusplus.com/forum/general/17811/
http://en.wikibooks.org/wiki/Optimizing_C%2B%2B/Code_optimization/Faster_operations
http://gamedev.stackexchange.com/questions/27196/which-opcodes-are-faster-at-the-cpu-level

nice problem..

parece un típico problema de Programación I,

si es un ciclo exacto entonces se conoce la cantidad de vueltas del contador por lo tanto se debe utilizar un FOR, aunque también un while, pero se trata de que te enseñan la diferencia entre ambos.

para el punto a, usá un FOR de 29 ciclos o iteraciones, un acumulador de tipo float para acumular la suma de todo lo que cobran los empleados, luego dividir eso por 29.

para el otro punto obtener el valor máximo entre 29, eso se hace con una variable auxiliar por ejemplo, que vaya guardando el valor más grande y lo compare continuamente a lo largo de las 29 vueltas.

no especifica si te dejan usar STRUCT, con lo cual sería más fácil..

el tercer punto, es para utilizar un contador. Es decir dentro de un FOR de 29 ciclos hacés la comparación de cada empleado si obtiene más de 2000 y el contador se incrementa en 1

lo del diagrama podés usar algún programa que genera diagramas automáticamente, sino vas a tener que dibujarlo

Amigo lo que hice fue crear una especie de solución  

http://foro.elhacker.net/programacion_cc/cadena_de_bytes_a_string-t383814.0.html
espero que te guste

[DESCARGA]

Bueno , en realidad el título puede que no lo exprese tal como es..
En este tema alguien había preguntado cómo se pasaba de un array de bytes a convertirlo en un array de chares por decirlo así, y la operación inversa también.
http://foro.elhacker.net/programacion_cc/variable_char_a_byte-t383683.0.html

Entonces usando una lógica que suelo utilizar, lo que hice fue crear una tabla con los 256 bytes, en realidad dos tablas. Una para obtener los bytes y la otra para obtener la posición de un byte en la tabla.
Luego de eso fue tan sólo crear 2 funciones separadas que hagan las operaciones, la una y la inversa, y probarlo

Código [Seleccionar] Expandir


/********************************************************************************************************

// By 85
// boyscout_arg@hotmail.com
// etalking.com.ar
// David Riedel
// 2013

*********************************************************************************************************/

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

/////
/////////////////////////////////////

char* hextabla[] = { //256 BYTES
"00","01","02","03","04","05","06","07","08","09",
"0A","0B","0C","0D","0E","0F","10","11","12","13",
"14","15","16","17","18","19","1A","1B","1C","1D",
"1E","1F","20","21","22","23","24","25","26","27",
"28","29","2A","2B","2C","2D","2E","2F","30","31",
"32","33","34","35","36","37","38","39","3A","3B",
"3C","3D","3E","3F","40","41","42","43","44","45",
"46","47","48","49","4A","4B","4C","4D","4E","4F",
"50","51","52","53","54","55","56","57","58","59",
"5A","5B","5C","5D","5E","5F","60","61","62","63",
"64","65","66","67","68","69","6A","6B","6C","6D",
"6E","6F","70","71","72","73","74","75","76","77",
"78","79","7A","7B","7C","7D","7E","7F","80","81",
"82","83","84","85","86","87","88","89","8A","8B",
"8C","8D","8E","8F","90","91","92","93","94","95",
"96","97","98","99","9A","9B","9C","9D","9E","9F",
"A0","A1","A2","A3","A4","A5","A6","A7","A8","A9",
"AA","AB","AC","AD","AE","AF","B0","B1","B2","B3",
"B4","B5","B6","B7","B8","B9","BA","BB","BC","BD",
"BE","BF","C0","C1","C2","C3","C4","C5","C6","C7",
"C8","C9","CA","CB","CC","CD","CE","CF","D0","D1",
"D2","D3","D4","D5","D6","D7","D8","D9","DA","DB",
"DC","DD","DE","DF","E0","E1","E2","E3","E4","E5",
"E6","E7","E8","E9","EA","EB","EC","ED","EE","EF",
"F0","F1","F2","F3","F4","F5","F6","F7","F8","F9",
"FA","FB","FC","FD","FE","FF",
};
//////////////

BYTE poshextabla[] = { //256 BYTES
/*1*/(BYTE)'\x00',(BYTE)'\x01',(BYTE)'\x02',(BYTE)'\x03',(BYTE)'\x04',(BYTE)'\x05',(BYTE)'\x06',(BYTE)'\x07',(BYTE)'\x08',(BYTE)'\x09',
/*2*/(BYTE)'\x0A',(BYTE)'\x0B',(BYTE)'\x0C',(BYTE)'\x0D',(BYTE)'\x0E',(BYTE)'\x0F',(BYTE)'\x10',(BYTE)'\x11',(BYTE)'\x12',(BYTE)'\x13',
/*3*/(BYTE)'\x14',(BYTE)'\x15',(BYTE)'\x16',(BYTE)'\x17',(BYTE)'\x18',(BYTE)'\x19',(BYTE)'\x1A',(BYTE)'\x1B',(BYTE)'\x1C',(BYTE)'\x1D',
/*4*/(BYTE)'\x1E',(BYTE)'\x1F',(BYTE)'\x20',(BYTE)'\x21',(BYTE)'\x22',(BYTE)'\x23',(BYTE)'\x24',(BYTE)'\x25',(BYTE)'\x26',(BYTE)'\x27',
/*5*/(BYTE)'\x28',(BYTE)'\x29',(BYTE)'\x2A',(BYTE)'\x2B',(BYTE)'\x2C',(BYTE)'\x2D',(BYTE)'\x2E',(BYTE)'\x2F',(BYTE)'\x30',(BYTE)'\x31',
/*6*/(BYTE)'\x32',(BYTE)'\x33',(BYTE)'\x34',(BYTE)'\x35',(BYTE)'\x36',(BYTE)'\x37',(BYTE)'\x38',(BYTE)'\x39',(BYTE)'\x3A',(BYTE)'\x3B',
/*7*/(BYTE)'\x3C',(BYTE)'\x3D',(BYTE)'\x3E',(BYTE)'\x3F',(BYTE)'\x40',(BYTE)'\x41',(BYTE)'\x42',(BYTE)'\x43',(BYTE)'\x44',(BYTE)'\x45',
/*8*/(BYTE)'\x46',(BYTE)'\x47',(BYTE)'\x48',(BYTE)'\x49',(BYTE)'\x4A',(BYTE)'\x4B',(BYTE)'\x4C',(BYTE)'\x4D',(BYTE)'\x4E',(BYTE)'\x4F',
/*9*/(BYTE)'\x50',(BYTE)'\x51',(BYTE)'\x52',(BYTE)'\x53',(BYTE)'\x54',(BYTE)'\x55',(BYTE)'\x56',(BYTE)'\x57',(BYTE)'\x58',(BYTE)'\x59',
/*10*/(BYTE)'\x5A',(BYTE)'\x5B',(BYTE)'\x5C',(BYTE)'\x5D',(BYTE)'\x5E',(BYTE)'\x5F',(BYTE)'\x60',(BYTE)'\x61',(BYTE)'\x62',(BYTE)'\x63',
/*11*/(BYTE)'\x64',(BYTE)'\x65',(BYTE)'\x66',(BYTE)'\x67',(BYTE)'\x68',(BYTE)'\x69',(BYTE)'\x6A',(BYTE)'\x6B',(BYTE)'\x6C',(BYTE)'\x6D',
/*12*/(BYTE)'\x6E',(BYTE)'\x6F',(BYTE)'\x70',(BYTE)'\x71',(BYTE)'\x72',(BYTE)'\x73',(BYTE)'\x74',(BYTE)'\x75',(BYTE)'\x76',(BYTE)'\x77',
/*13*/(BYTE)'\x78',(BYTE)'\x79',(BYTE)'\x7A',(BYTE)'\x7B',(BYTE)'\x7C',(BYTE)'\x7E',(BYTE)'\x7F',(BYTE)'\x80',(BYTE)'\x81',(BYTE)'\x82',
/*14*/(BYTE)'\x83',(BYTE)'\x84',(BYTE)'\x85',(BYTE)'\x86',(BYTE)'\x87',(BYTE)'\x88',(BYTE)'\x89',(BYTE)'\x8A',(BYTE)'\x8B',(BYTE)'\x8C',
/*15*/(BYTE)'\x8D',(BYTE)'\x8E',(BYTE)'\x8F',(BYTE)'\x90',(BYTE)'\x91',(BYTE)'\x92',(BYTE)'\x93',(BYTE)'\x94',(BYTE)'\x95',(BYTE)'\x96',
/*16*/(BYTE)'\x97',(BYTE)'\x98',(BYTE)'\x99',(BYTE)'\x9A',(BYTE)'\x9B',(BYTE)'\x9C',(BYTE)'\x9D',(BYTE)'\x9E',(BYTE)'\x9F',(BYTE)'\xA0',
/*17*/(BYTE)'\xA1',(BYTE)'\xA2',(BYTE)'\xA3',(BYTE)'\xA4',(BYTE)'\xA5',(BYTE)'\xA6',(BYTE)'\xA7',(BYTE)'\xA8',(BYTE)'\xA9',(BYTE)'\xAA',
/*18*/(BYTE)'\xAB',(BYTE)'\xAC',(BYTE)'\xAD',(BYTE)'\xAE',(BYTE)'\xAF',(BYTE)'\xB0',(BYTE)'\xB1',(BYTE)'\xB2',(BYTE)'\xB3',(BYTE)'\xB4',
/*19*/(BYTE)'\xB5',(BYTE)'\xB6',(BYTE)'\xB7',(BYTE)'\xB8',(BYTE)'\xB9',(BYTE)'\xBA',(BYTE)'\xBB',(BYTE)'\xBC',(BYTE)'\xBD',(BYTE)'\xBE',
/*20*/(BYTE)'\xBF',(BYTE)'\xC0',(BYTE)'\xC1',(BYTE)'\xC2',(BYTE)'\xC3',(BYTE)'\xC4',(BYTE)'\xC5',(BYTE)'\xC6',(BYTE)'\xC7',(BYTE)'\xC8',
/*21*/(BYTE)'\xC9',(BYTE)'\xCA',(BYTE)'\xCB',(BYTE)'\xCC',(BYTE)'\xCD',(BYTE)'\xCE',(BYTE)'\xCF',(BYTE)'\xD0',(BYTE)'\xD1',(BYTE)'\xD2',
/*22*/(BYTE)'\xD3',(BYTE)'\xD4',(BYTE)'\xD5',(BYTE)'\xD6',(BYTE)'\xD7',(BYTE)'\xD8',(BYTE)'\xD9',(BYTE)'\xDA',(BYTE)'\xDB',(BYTE)'\xDC',
/*23*/(BYTE)'\xDD',(BYTE)'\xDE',(BYTE)'\xDF',(BYTE)'\xE0',(BYTE)'\xE1',(BYTE)'\xE2',(BYTE)'\xE3',(BYTE)'\xE4',(BYTE)'\xE5',(BYTE)'\xE6',
/*24*/(BYTE)'\xE7',(BYTE)'\xE8',(BYTE)'\xE9',(BYTE)'\xEA',(BYTE)'\xEB',(BYTE)'\xEC',(BYTE)'\xED',(BYTE)'\xEE',(BYTE)'\xEF',(BYTE)'\xF0',
/*25*/(BYTE)'\xF1',(BYTE)'\xF2',(BYTE)'\xF3',(BYTE)'\xF4',(BYTE)'\xF5',(BYTE)'\xF6',(BYTE)'\xF7',(BYTE)'\xF8',(BYTE)'\xF9',(BYTE)'\xFA',
/*26*/(BYTE)'\xFB',(BYTE)'\xFC',(BYTE)'\xFD',(BYTE)'\xFE',(BYTE)'\xFF'
};

/////


El usuario ingresa una array de bytes y la función arregla el resultado en una cadena de chares, lo hace por medio de buscar en una tabla diseñada específicamente para esta situación.

Código [Seleccionar] Expandir


void Test1(){ //Cadena de bytes a string

BYTE* cadena_de_bytes = (BYTE*)"\x68\x68\x68\x68\x68\x68\xFF\xFF\xFF\xFF\x69";
int largo_de_la_cadena_de_bytes = strlen( (char*)cadena_de_bytes);
char* cadena_de_bytes_en_formato_string = (char*)"000000000000000000000\0";
int pos_string=0;

int i;
for(i=0; i<largo_de_la_cadena_de_bytes; i++)
{
for(int j=0; j<256; j++)
{
if(cadena_de_bytes[i] == poshextabla[j])
{
int pos = j;
for(int k=0;k<2;k++){
cadena_de_bytes_en_formato_string[pos_string++]=hextabla[pos][k];
}
}
}
}
printf(cadena_de_bytes_en_formato_string);
printf("\n");
system("pause");
}

//////////


El usuario ingresa una cadena con números que representan bytes,
la función convierte la cadena a un array de bytes.

Código [Seleccionar] Expandir


void Test2(){//String a cadena de bytes

char* cadena_de_bytes = (char*)"686868686868FFFFFFFF69\0";
BYTE* cadena_de_bytes_resultante = (BYTE*)"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00";
int largo_de_la_cadena_de_bytes = strlen( cadena_de_bytes);
int pos_bytes=0;

int i;
for(i=0; i<largo_de_la_cadena_de_bytes; i+=2)
{
for(int j=0; j<256; j++)
{
if(cadena_de_bytes[i] == hextabla[j][0] && cadena_de_bytes[i+1] == hextabla[j][1])
{
int pos = j;

cadena_de_bytes_resultante[pos_bytes++]=poshextabla[pos];
}
}
}

for(int x=0; x<largo_de_la_cadena_de_bytes/2; x++){
printf("%X",*(cadena_de_bytes_resultante+x));
}
printf("\n");
system("pause");
}

///////


Código [Seleccionar] Expandir


int main(){


Test1();
Test2();

return 0;
}


voy a dejar el proyecto en MSVCPP 6
DESCARGA

está listo para compilar en modo 'Release', pero si sólo quitan el archivo .cpp para usarlo en otro compilador, compilen en modo Release también..

//////////////////////////////////////////////////////////////////////

EDITADO:

Debido a que mi código dejó de ser algo didáctico para ser criticado por ser costoso con la utilización de recursos, entonces lo que hice fue simplificar mi código siguiendo la misma lógica con la cual venía trabajando.

Ahora sólo se dispone de una tabla, dicha tabla se usa como lookup en la primera función y en la segunda se requiere recorrerla pero no más de lo necesario.


atte

Código [Seleccionar] Expandir


/********************************************************************************************************

// By 85
// boyscout_arg@hotmail.com
// etalking.com.ar
// David Riedel
// 2013

*********************************************************************************************************/

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

/////
/////////////////////////////////////

char* hextabla[] = { //256 BYTES
"00","01","02","03","04","05","06","07","08","09",
"0A","0B","0C","0D","0E","0F","10","11","12","13",
"14","15","16","17","18","19","1A","1B","1C","1D",
"1E","1F","20","21","22","23","24","25","26","27",
"28","29","2A","2B","2C","2D","2E","2F","30","31",
"32","33","34","35","36","37","38","39","3A","3B",
"3C","3D","3E","3F","40","41","42","43","44","45",
"46","47","48","49","4A","4B","4C","4D","4E","4F",
"50","51","52","53","54","55","56","57","58","59",
"5A","5B","5C","5D","5E","5F","60","61","62","63",
"64","65","66","67","68","69","6A","6B","6C","6D",
"6E","6F","70","71","72","73","74","75","76","77",
"78","79","7A","7B","7C","7D","7E","7F","80","81",
"82","83","84","85","86","87","88","89","8A","8B",
"8C","8D","8E","8F","90","91","92","93","94","95",
"96","97","98","99","9A","9B","9C","9D","9E","9F",
"A0","A1","A2","A3","A4","A5","A6","A7","A8","A9",
"AA","AB","AC","AD","AE","AF","B0","B1","B2","B3",
"B4","B5","B6","B7","B8","B9","BA","BB","BC","BD",
"BE","BF","C0","C1","C2","C3","C4","C5","C6","C7",
"C8","C9","CA","CB","CC","CD","CE","CF","D0","D1",
"D2","D3","D4","D5","D6","D7","D8","D9","DA","DB",
"DC","DD","DE","DF","E0","E1","E2","E3","E4","E5",
"E6","E7","E8","E9","EA","EB","EC","ED","EE","EF",
"F0","F1","F2","F3","F4","F5","F6","F7","F8","F9",
"FA","FB","FC","FD","FE","FF",
};


Código [Seleccionar] Expandir



void Test1(BYTE* array_de_bytes, char* cadena_de_bytes_en_formato_string){ //Cadena de bytes a string

for(int i=0; i<(int)strlen( (char*)array_de_bytes); i++)
strcat(cadena_de_bytes_en_formato_string,hextabla[(int)array_de_bytes[i]]);
printf(cadena_de_bytes_en_formato_string);
printf("\n");
}

//////////

void Test2(char* cadena_de_bytes, BYTE* cadena_de_bytes_resultante){//String a cadena de bytes

int bytes=0;
for(int i=0; i<(int)strlen( cadena_de_bytes); i+=2){
for(int j=0; j<256; j++){
if( cadena_de_bytes[i]==hextabla[j][0] && cadena_de_bytes[i+1]==hextabla[j][1] ){
cadena_de_bytes_resultante[bytes++]=j;
j=256;
}
}
}
for(int x=0; x<(int)strlen( cadena_de_bytes)/2; x++)
printf("%X",*(cadena_de_bytes_resultante+x));
printf("\n");
}

///////

int main(){//Programa

BYTE* array_de_bytes = (BYTE*)"\x68\x68\x68\x68\x68\x68\xFF\xFF\xFF\xFF\x69";
char cadena_de_bytes_en_formato_string[256];
memset(cadena_de_bytes_en_formato_string,0,sizeof(cadena_de_bytes_en_formato_string));
printf("TEST1:\n");
Test1(array_de_bytes, cadena_de_bytes_en_formato_string);
system("pause");

char* cadena_de_bytes = (char*)"686868686868FFFFFFFF69\0";
BYTE* cadena_de_bytes_resultante = (BYTE*)"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00";
printf("TEST2:\n");
Test2(cadena_de_bytes, cadena_de_bytes_resultante);
system("pause");

return 0;
}


claro, por eso yo decía que la mejor es la función 2, las otras estaban incompletas...

igualmente se puede ahcer eso que dice engelx, es decir , luego de llamar a la función , se evalúa el resultado (por ejemplo 'false') y en base a eso se determina que se va a usar uno de los números, etc también la función puede retornar uno de los números si los 3 son iguales, igualmente me quedo con la opción B para este problema  

[EDITADO]

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

Código (cpp) [Seleccionar] Expandir


/********************************************************************************************************

// 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'

Código [Seleccionar] Expandir


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

Código [Seleccionar] Expandir


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:

Código (cpp) [Seleccionar] Expandir


/********************************************************************************************************

// 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

Hola, estaba mirando casualmente dos temas, uno que se refiere al operador ternario y otro sobre como obtener el mayor de 3 números..

y en el tema del operador ternario se hablaba acerca de la utilidad de este operador, en este caso compruebo que resulta conveniente usarlo..
por eso vean la función 2 parece la más conveniente aunque en realidad a mi forma de verlo las 3 terminan realizando comparaciones, que a nivel de ensamblador resultan simples restas..
si alguno sabe como el procesador procesa la información o al menos sabe como se realizan las comparaciones, sabrá a que me refiero.

Código [Seleccionar] Expandir


int max_valor_de_tres_1(int a,int b,int c){

if(a>b)
if(a>c)
return a;
if(b>a)
if(b>c)
return b;
if(c>a)
if(c>b)
return c;
return 0;
}


Código [Seleccionar] Expandir


int max_valor_de_tres_2(int a,int b,int c){

return a>b? (a>c?a:(b>c?b:c)) : (b>c?b:c);
}


Código [Seleccionar] Expandir


int max_valor_de_tres_3(int a,int b,int c){

if((a-b>0)&&(a-c>0)){return a;}
if((b-a>0)&&(b-c>0)){return b;}
if((c-a>0)&&(c-b>0)){return c;}
return 0;
}


Código [Seleccionar] Expandir


int main(){
int a,b,c;
a = 3;
b=4;
c=5;
int res = max_valor_de_tres_3(a,b,c);
printf("%d",res);
printf("\n");
system("pause");

return 0;
}

Estos eran los temas
http://foro.elhacker.net/programacion_cc/aporte_operador_condicional-t383420.0.html

http://foro.elhacker.net/programacion_cc/help_calcular_maximo_de_3_numeros_usando_funcion-t383403.0.html

no se pero tu código me gusta we

[TerminateProcess]

claro, usando la API de Windows..

con TerminateProcess:
http://msdn.microsoft.com/en-us/library/windows/desktop/ms686714(v=vs.85).aspx

o con las API específicas para Hilos (threads), matando todos los hilos es como matar el proceso.

desde dentro de una aplicación podés usar ExitProcess por ejemplo

me acuerdo que yo había usado una lógica parecida anteriormente..

http://foro.elhacker.net/programacion_cc/atoi_itoa_personalizadas-t358459.0.html;msg1734670#msg1734670

http://foro.elhacker.net/programacion_cc/aportacion_programas_en_c_basicos-t365766.0.html;msg1769441#msg1769441