Iniciar sesiónCerrar
Correo:
Contraseña:
Entrar
Recordar sesión en este navegador
Iniciar sesiónIniciar sesiónCrear cuentaCrear cuenta
LWP » Foros » C/Visual C » Trabajando con segundos

C/Visual C - Trabajando con segundos

Volver
Nuevo Tema
<<>>
 
Vista:

Trabajando con segundos

Publicado por dimus (1 intervención) el 29/09/2002 19:13:14
Buenas.

¿sabeis alguna forma para saber cuantas centesimas o milesimas de segundo ha tardado en ejecutarse una parte del codigo? He leido algo sobre la funcion ftime(), pero no he logrado encontrar nada claro.

Venga un saludo a todos.
Valora esta pregunta
Me gusta: Está pregunta es útil y esta claraNo me gusta: Está pregunta no esta clara o no es útil
0
Responder
Imágen de perfil de Alejandro

Trabajando con segundos

Publicado por Alejandro (913 intervenciones) el 24/03/2025 18:34:50
Para medir el tiempo de ejecución de una parte del código en C o C++, puedes utilizar varias funciones. Una de ellas es `ftime()`, que forma parte de la biblioteca `<sys/timeb.h>`, pero hay otras opciones más precisas, como `clock()` de `<time.h>` o `std::chrono` enC++11 y versiones posteriores. A continuación, te muestro cómo usar cada una de estas opciones.

Opción 1: Usar `ftime()`



La función `ftime()` te permite obtener el tiempo en segundos y milisegundos. Aquí tienes un ejemplo de cómo usarla:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#include <iostream>
#include <sys/timeb.h>
 
int main() {
    struct timeb start, end;
 
    // Obtener el tiempo de inicio
    ftime(&start);
 
    // Código cuya duración deseas medir
    for (volatile int i = 0; i < 1000000; ++i); // Simulación de trabajo
 
    // Obtener el tiempo de fin
    ftime(&end);
 
    // Calcular la diferencia
    double elapsed = (end.time - start.time) * 1000.0 + (end.millitm - start.millitm);
    std::cout << "Tiempo transcurrido: " << elapsed << " milisegundos" << std::endl;
 
    return 0;
}

Opción 2: Usar `clock()`



La función `clock()` mide el tiempo de CPU utilizado por el programa. Aquí tienes un ejemplo:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#include <iostream>
#include <ctime>
 
int main() {
    clock_t start, end;
 
    // Obtener el tiempo de inicio
    start = clock();
 
    // Código cuya duración deseas medir
    for (volatile int i = 0; i < 1000000; ++i); // Simulación de trabajo
 
    // Obtener el tiempo de fin
    end = clock();
 
    // Calcular la diferencia
    double elapsed = double(end - start) / CLOCKS_PER_SEC * 1000; // Convertir a milisegundos
    std::cout << "Tiempo transcurrido: " << elapsed << " milisegundos" << std::endl;
 
    return 0;
}

Opción 3: Usar `std::chrono` (C++11 y posterior)



Si estás utilizando C++11 o una versión posterior, `std::chrono` es una opción más moderna y precisa:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#include <iostream>
#include <chrono>
 
int main() {
    // Obtener el tiempo de inicio
    auto start = std::chrono::high_resolution_clock::now();
 
    // Código cuya duración deseas medir
    for (volatile int i = 0; i < 1000000; ++i); // Simulación de trabajo
 
    // Obtener el tiempo de fin
    auto end = std::chrono::high_resolution_clock::now();
 
    // Calcular la diferencia
    std::chrono::duration<double, std::milli> elapsed = end - start;
    std::cout << "Tiempo transcurrido: " << elapsed.count() << " milisegundos" << std::endl;
 
    return 0;
}

Conclusión



Cualquiera de estas opciones te permitirá medir el tiempo de ejecución de una parte de tu código en C o C++. La opción de `std::chrono` es la más recomendada si estás trabajando con C++ moderno, ya que ofrece una mayor precisión y facilidad de uso. ¡Un saludo, Dimus!
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar