Mensajes

modifiqué el post igualmente, pero fijate que dentro del FOR no se hace un CALL a la función por cada vuelta sino que se realiza una suma y una asignación.

por lo tanto fijate todo lo que te ahorrás

Function calls (including parameter passing and placing the object's address on the stack)
Preservation of caller's stack frame
New stack-frame setup
Return-value communication
Old stack-frame restore
Return

http://pintucoperu.wordpress.com/2007/12/12/programacion-en-c-cuando-usar-funciones-inline/

http://stackoverflow.com/questions/1932311/when-to-use-inline-function-and-when-not-to-use-it

http://msdn.microsoft.com/en-us/library/1w2887zk(v=vs.80).aspx

funciones pequeñas, y redundantes que se llaman seguido.

EDIT:

Código [Seleccionar] Expandir

inline sumar(a, b){

return (a+b);
}

Código [Seleccionar] Expandir

for(int i=0; i<30; i++){

res[i] = sumar(0,i);
}

por ejemplo. No es algo tan simple como sumar pero la idea la podés captar XD.

fijate el ejemplo que muestran ak
http://en.wikipedia.org/wiki/Inline_function

lo que podés hacer es compilar un ejemplo así y fijarte en un desensamblaor como quedó el código ensamblador en el ejecutable.

Tenés otros ejemplos más

http://foro.elhacker.net/programacion_cc/manipulacion_de_punteros_ejemplo_con_float-t358223.0.html

http://adilevin.wordpress.com/2009/06/07/createthread-an-example/

hay muchos ejemplos XD

http://www.codeproject.com/Questions/109659/Running-time-calculation-using-QueryPerformanceCou
http://stackoverflow.com/questions/1739259/how-to-use-queryperformancecounter
http://support.microsoft.com/kb/172338/es
http://blogs.msdn.com/b/oldnewthing/archive/2008/09/08/8931563.aspx

Yo tenía estas pero esa que postiaste está mucho mejor  

Código [Seleccionar] Expandir


char* mi_strtok(char* str, const char* delimiters){

printf("mi_strtok\n");
system("pause");
static char* last;
char* tok;

/* pick up from previous stopping point, if told to do so */
if (str == NULL && (str = last) == NULL) return NULL;

/* skip initial delimiters to find start of token */
tok = str + strspn(str, delimiters);

/* skip over non-delimiters to find end of token */
str = tok + strcspn(tok, delimiters);

/*
* Save state for next call, and return token. If there
* is no token, both *tok and *s will be '\0'. If there
* is one token that is ended with '\0', *s will be '\0'.
* (If there are trailing delimiters, we will skip them
* later.)
*/
last=*str=='\0' ?NULL:str+1;
return *tok=='\0' ?NULL:tok;
}


Código [Seleccionar] Expandir


char* mi_strtok2(char* input, const char* tokenizer)
{
printf("mi_strtok2\n");
system("pause");
static char* memorizeInput;
bool tokenFound = false;
if(input != NULL)
memorizeInput = input;
else
input = memorizeInput;
if(!(*memorizeInput))
return NULL;
while(*memorizeInput)
{
for(int i=0; i<(int)(strlen(tokenizer)&&!tokenFound);i++){
 
if(*memorizeInput == tokenizer[i])
{
*memorizeInput = 0;
tokenFound = true;
}
}
if(tokenFound)
{
memorizeInput++;
break;
}
memorizeInput++;
}

return input;
}


Código [Seleccionar] Expandir


char* lastPos = 0;
char token[100];

char* mi_strtok3(char* str, const char* delim)
{
printf("mi_strtok3\n");
system("pause");
if(!str && !lastPos) return 0;
if(!delim) return 0;
if(str)
lastPos = str;
int delim_len = strlen(delim);
char* strt_ptr = lastPos;
int count = 0;
while(*lastPos != '\0')
{
bool is_found = false;
for(int y=0; y<delim_len; y++)
{
if(*(delim + y) == *lastPos)
is_found = true;
}
lastPos++;
if(is_found) break;
count++;
}

if(*lastPos == '\0')
lastPos = 0;

//added to remove empty ones
if(!count)
return mi_strtok3(0, delim);
//
for(int x=0; x<count; x++)
token[x] = *(strt_ptr + x);
token[count] = '\0';
return token;
}


habría que probar con el ejemplo de aquí:
http://www.cplusplus.com/reference/cstring/strtok/

http://www.cplusplus.com/reference/cstdio/fscanf/
http://c.conclase.net/librerias/?ansifun=fscanf

se usa para archivos, fijate su primer parámetro

http://foro.elhacker.net/programacion_cc/programa_para_pasar_de_numero_decimal_a_coma_flotante-t385432.0.html;msg1836860#msg1836860

yo había hecho algo así, pero la idea de Maik33 tiene mucho sentido también.
otra cosa es que esto es descomponer en unidades y no factorizar, porque factorizar es otra cosa. Te digo porque en ese código la función se llama 'Factorizar' pero lo que hace es descomponer en unidades.
Factorizar es descomponer en números o en factores, que multiplicados todos dan como resultado el número inicial.

'inline' es para funciones, se usa en funciones que son redundantes y que se utilizan continuamente, y el efecto que tiene es hacer que el código de la función forme parte de la función en donde se llama, en lugar de que se genere un CALL a ella.

No siempre que usés 'inline' significa que el compilador va a aceptar esa directiva, incluso se puede hacer que el compilador trate de aceptar forzadamente que una función sea 'inline' con '__forceinline', pero es cuestión de que el compilador lo acepte de todas formas.

se usa para funciones muy redundates (y pequeñas en general), no tiene sentido en otro tipo de funciones.

El efecto que se genera al usar 'inline' en funciones que se llaman en diferentes lugares y repetidas veces, es un ejecutable de mayor tamaño, que como te dije antes, no se genera un CALL a la función sino que se genera todo el código de la función para cada llamada a ella.

Aquí alguien preguntó lo mismo , podés fijarte
http://www.cplusplus.com/forum/beginner/9209/

En este topic se muestra como se usa 'inline' en 2 funciones, fijate que sólo se permiten usar dentro de la misma unidad de compilación en la que se definen.
http://foro.elhacker.net/programacion_cc/clases_de_almacenamiento-t386497.0.html

por ahí, el muchacho se refería a la potencia pero a la operación matemática y no a la potencia eléctrica que es una magnitud en física o ingeniería eléctrica.

si es la operación matemática suponete que tenés I = 5 amper

float P = R * pow(I,2);

http://www.cplusplus.com/reference/cmath/pow/
http://www.cplusplus.com/reference/cmath/exp/

Lo saqué de ak: http://es.wikipedia.org/wiki/Potencia_el%C3%A9ctrica
XD

disculpen no he leído todo el topic detenidamente (Estoy perezoso XD), pero no será que necesita crear una ventana de consola, algo así

Código [Seleccionar] Expandir


AllocConsole();  // Create Console Window
freopen("CONIN$","rb",stdin);   // reopen stdin handle as console window input
freopen("CONOUT$","wb",stdout);  // reopen stout handle as console window output
freopen("CONOUT$","wb",stderr); // reopen stderr handle as console window output

... código

FreeConsole();  // Free Console Window


Porque leí algo de crear otro proceso, etc pero a juzgar por el título...
aunque yo para lo que usé este código fue para crear una ventana de consola en una aplicación win32, para ingresar unos datos por consola y luego cerrarla.

Saludos