C++计时器（用于计算算法运行时间等）

最新推荐文章于 2024-04-23 04:33:05 发布
最新推荐文章于 2024-04-23 04:33:05 发布
阅读量1.3w 收藏 123
点赞数 17
分类专栏： C++常用 文章标签： c++ stl
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_51371693/article/details/121589590
版权

C++算法计时器


有时为了检测和比较算法效率和复杂度，需要一个计时器，而这个计时器往往需要精确到毫秒ms、微秒μs甚至纳秒ns，不太常用的库或api就不放上来了。

1.毫秒级精度

1.1 CLOCKS_PER_SEC

在头文件time.h或ctime中，clock()函数返回从“开启这个程序进程”到“程序中调用clock()函数”时之间的CPU时钟计时单元（clock tick）数，在MSDN中称之为挂钟时间（wal-clock），常量CLOCKS_PER_SEC，它用来表示一秒钟会有多少个时钟计时单元，精确到毫秒，其使用方法如下:

精华代码：

#include <iostream>
#include<vector>
#include <algorithm>
#include <ctime>
using namespace std;
int main()
{
    
    clock_t begin, end;
    begin = clock();
    for (int i = 1; i <= 100; ++i)
    {
       
    }
    end = clock();
    cout << "100次循环所用时间：" << double(end - begin) / CLOCKS_PER_SEC * 1000 << "ms" << endl;
       
    return 0;
}

示例为检测二叉堆不同输入一个一个插入所用时间（不能直接跑）：

#include <iostream>
#include<vector>
#include <algorithm>
#include <ctime>
using namespace std;

int main()
{
    int num, mode;
    cout << "输入大小和模式，其中模式1为正序，2为倒序，3位随机" << endl;
    cout << "示例：1000 2" << endl;
    cin >> num >> mode;//输入大小和模式，其中模式1为正序，2为倒序，3位随机
    BinaryHeap<int> heap1,heap2;
    clock_t begin, end;
    switch (mode)
    {
    case 1://正序
        begin = clock();
        for (int i = 1; i <= num; ++i)
        {
            heap1.insert(i);
        }
        end = clock();
        cout << "一个一个正序插入所用时间：" << double(end - begin) / CLOCKS_PER_SEC * 1000 << "ms" << endl;
        break;
    case 2://倒序
        begin = clock();
        for (int i = num; i >= 1; --i)
        {
            heap1.insert(i);
        }
        end = clock();
        cout << "一个一个倒序插入所用时间：" << double(end - begin) / CLOCKS_PER_SEC * 1000 << "ms" << endl;
        break;
    case 3://正倒序交叉模拟随机
        begin = clock();
        for (int i = 1; i<num/2; ++i)
        {
            heap1.insert(i);
            heap1.insert(num - i);
        }
        end = clock();
        cout << "一个一个随机插入所用时间：" << double(end - begin) / CLOCKS_PER_SEC * 1000 << "ms" << endl;
        break;
    default:
        break;
    }
  
 
    return 0;
}

1.2 GetTickCount()函数 （Windows API）

GetTickCount返回（retrieve）从操作系统启动所经过（elapsed）的毫秒数，它的返回值是DWORD。

#include <stdio.h>
#include <windows.h>
#include<iostream>
#pragma comment(lib, "winmm.lib") //告诉编译器要导入winmm库，有时候可删

int main()
{
    DWORD t1, t2;
    t1 = GetTickCount();
    for(int i=1;i<=10000;++i)
    {
        
    }//do something
    t2 = GetTickCount();
    //printf("Use Time:%f\n", (t2 - t1) * 1.0);
    cout<<"Use Time:"<<(double)(t2-t1)<<"ms"<<endl;
    return 0;
}

1.3 timeGetTime()函数（Windows API）

以毫秒计的系统时间，该时间为从系统开启算起所经过的时间。在使用timeGetTime之前应先包含头文件＃include <Mmsystem.h>或＃include <Windows.h>并在project->settings->link->Object/library modules中添加winmm.lib。也可以在文件头部添加 #pragma comment( lib,“winmm.lib” )。

备注：命令行：#pragma comment( lib,“xxx.lib” )时预编译处理指令，让vc将winmm.lib添加到工程中去进行编译。

//#include<stdio.h>
#include<windows.h>
#include<iostream>
#pragma comment( lib,"winmm.lib" )

int main()
{
    DWORD t1, t2;
    t1 = timeGetTime();
    foo();//do something
    t2 = timeGetTime();
    //printf("Use Time:%f\n", (t2 - t1)*1.0 / 1000);
    cout<<"Use Time:"<<(double)(t2-t1)<<"ms"<<endl;
    return 0;
}

该函数的时间精度是五毫秒或更大一些，这取决于机器的性能。可用timeBeginPeriod和timeEndPeriod函数提高timeGetTime函数的精度。如果使用了，连续调用timeGetTime函数，一系列返回值的差异由timeBeginPeriod和timeEndPeriod决定。也可以用timeGetTime实现延时功能Delay

void Delay(DWORD delayTime)
{
　　DWORD delayTimeBegin;
　　DWORD delayTimeEnd;
　　delayTimeBegin=timeGetTime();
　　do
　　{　　　　
　　	delayTimeEnd=timeGetTime();
　　}while((delayTimeEnd-delayTimeBegin)<delayTime)
}

1.4 timeval结构体（Linux）

timeval结构体

#include <sys/time.h> 
#include <iostream> 
#include <time.h> 
double get_wall_time() 
{ 
  struct timeval time ; 
  if (gettimeofday(&time,NULL)){ 
    return 0; 
  } 
  return (double)time.tv_sec + (double)time.tv_usec * .000001; 
} 
 
int main() 
{ 
  unsigned int t = 0; 
  double start_time = get_wall_time() 
  while(t++<10e+6); 
  double end_time = get_wall_time() 
  std::cout<<"循环耗时为:"<<end_time-start_time<<"ms"; 
  return 0; 
}

2.微秒级精度

QueryPerformanceCounter()函数和QueryPerformanceFrequency()函数（Windows API）

QueryPerformanceFrequency()函数返回高精确度性能计数器的值,它可以以微妙为单位计时，但是QueryPerformanceCounter()确切的精确计时的最小单位是与系统有关的,所以,必须要查询系统以得到QueryPerformanceCounter()返回的嘀哒声的频率。QueryPerformanceFrequency()提供了这个频率值,返回每秒嘀哒声的个数。

//#include<stdio.h>
#include<iostream>
#include<windows.h>
#pragma comment( lib,"winmm.lib" )

int main()
{
    LARGE_INTEGER t1, t2, tc;
    QueryPerformanceFrequency(&tc);
    QueryPerformanceCounter(&t1);
    foo();//do something
    QueryPerformanceCounter(&t2);
    //printf("Use Time:%f\n", (t2.QuadPart - t1.QuadPart)*1.0 / tc.QuadPart);
    cout << "Use Time:" << (double)((t2.QuadPart - t1.QuadPart) * 1000000.0 / tc.QuadPart) << "μs" << endl;
    return 0;
}

封装好的易于调用的代码：

//MyTimer.h// 
#ifndef __MyTimer_H__  
#define __MyTimer_H__  
#include <windows.h>  
 
class MyTimer 
{ 
private: 
  int _freq; 
  LARGE_INTEGER _begin; 
  LARGE_INTEGER _end; 
 
public: 
  long costTime;      // 花费的时间(精确到微秒)  
 
public: 
  MyTimer() 
  { 
    LARGE_INTEGER tmp; 
    QueryPerformanceFrequency(&tmp);//QueryPerformanceFrequency()作用：返回硬件支持的高精度计数器的频率。  
 
    _freq = tmp.QuadPart; 
    costTime = 0; 
  } 
 
  void Start()      // 开始计时  
  { 
    QueryPerformanceCounter(&_begin);//获得初始值  
  } 
 
  void End()        // 结束计时  
  { 
    QueryPerformanceCounter(&_end);//获得终止值  
    costTime = (long)((_end.QuadPart - _begin.QuadPart) * 1000000 / _freq); 
  } 
 
  void Reset()      // 计时清0  
  { 
    costTime = 0; 
  } 
}; 
#endif  
 
//main.cpp 
#include "MyTimer.h" 
#include <iostream> 
 
 
int main() 
{ 
  MyTimer timer; 
  unsigned int t = 0;  
  timer.Start(); 
  while (t++ < 10e+5); 
  timer.End();  
  std::cout << "耗时为：" << timer.costTime << "us"; 
  return 0 ; 
}

3.纳秒级精度

要先获取CPU频率。

在Intel Pentium以上级别的CPU中，有一个称为“时间戳（Time Stamp）”的部件，它以64位无符号整型数的格式，记录了自CPU上电以来所经过的时钟周期数。由于目前的CPU主频都非常高，因此这个部件可以达到纳秒级的计时精度。这个精确性是上述几种方法所无法比拟的.在Pentium以上的CPU中，提供了一条机器指令RDTSC（Read Time Stamp Counter）来读取这个时间戳的数字，并将其保存在EDX:EAX寄存器对中。由于EDX:EAX寄存器对恰好是Win32平台下C++语言保存函数返回值的寄存器，所以我们可以把这条指令看成是一个普通的函数调用，因为RDTSC不被C++的内嵌汇编器直接支持，所以我们要用_emit伪指令直接嵌入该指令的机器码形式0X0F、0X31。

inline unsigned __int64 GetCycleCount()
{
    __asm
    {
        _emit 0x0F;
        _emit 0x31;
    }
}

void test()
{
    unsigned long t1,t2;
    t1 = (unsigned long)GetCycleCount();
    foo();//dosomething
    t2 = (unsigned long)GetCycleCount();
    printf("Use Time:%f\n",(t2 - t1)*1.0/FREQUENCY);   //FREQUENCY指CPU的频率
}

下面为获取CPU精度的代码

#include<Windows.h>
LONGLONG GetFrequency(DWORD sleepTime) //获取CPU主频

{

    DWORD low1 = 0, high1 = 0, low2 = 0, high2 = 0;

    LARGE_INTEGER fq, st, ed;

    /*在定时前应该先调用QueryPerformanceFrequency()函数获得机器内部计时器的时钟频率。接着在

需要严格计时的事件发生前和发生之后分别调用QueryPerformanceCounter()，利用两次获得的技术

之差和时钟的频率，就可以计算出时间经历的精确时间。*/

    ::QueryPerformanceFrequency(&fq); //精确计时（返回硬件支持的高精度计数器的频率）

    ::QueryPerformanceCounter(&st); //获得起始时间

    __asm { //获得当前CPU的时间数

rdtsc

mov low1, eax

mov high1, edx

    }

    ::Sleep(sleepTime); //将线程挂起片刻

    ::QueryPerformanceCounter(&ed); //获得结束时间

    __asm {
rdtsc //读取CPU的时间戳计数器

mov low2, eax

mov high2, edx

    }

    //将CPU得时间周期数转化成64位整数

    LONGLONG begin = (LONGLONG)high1 << 32 | low1;

    LONGLONG end = (LONGLONG)high2 << 32 | low2;

    //将两次获得的CPU时间周期数除以间隔时间，即得到CPU的频率

    //由于windows的Sleep函数有大约15毫秒的误差，故以windows的精确计时为准

    return (end - begin) * fq.QuadPart / (ed.QuadPart - st.QuadPart);
}

4.利用chrono的各精度集成版（本质微秒）

4.1 chrono库介绍

函数原型：

template <class Clock, class Duration = typename Clock::duration>
  class time_point;

std::chrono::time_point 表示一个具体时间

第一个模板参数Clock用来指定所要使用的时钟,在标准库中有三种时钟，分别为：

  • system_clock：当前系统范围(即对各进程都一致)的一个实时的日历时钟(wallclock)
  • steady_clock：当前系统实现的一个维定时钟，该时钟的每个时间嘀嗒单位是均匀的(即长度相等)。
  • high_resolution_clock：当前系统实现的一个高分辨率时钟。
    第二个模板函数参数用来表示时间的计量单位(特化的std::chrono::duration<> )

时间点都有一个时间戳，即时间原点。chrono库中采用的是Unix的时间戳1970年1月1日 00:00。所以time_point也就是距离时间戳(epoch)的时间长度（duration）。

4.2 代码示例

#include <iostream>
#include <chrono>
 
using namespace std;
using namespace std::chrono;
 
class TimerClock
{
public:
 TimerClock()
 {
  update();
 }
 
 ~TimerClock()
 {
 }
 
 void update()
 {
  _start = high_resolution_clock::now();
 }
 //获取秒
 double getTimerSecond()
 {
  return getTimerMicroSec() * 0.000001;
 }
 //获取毫秒
 double getTimerMilliSec()
 {
  return getTimerMicroSec()*0.001;
 }
 //获取微妙
 long long getTimerMicroSec()
 {
  //当前时钟减去开始时钟的count
  return duration_cast<microseconds>(high_resolution_clock::now() - _start).count();
 }
private:
 time_point<high_resolution_clock>_start;
};
 
//测试的主函数
int main()
{
 TimerClock TC;
 int sum = 0;
 TC.update();
 for (int i = 0; i > 100000; i++)
 {
  sum++;
 }
 cout << "cost time:" << TC.getTimerMilliSec() <<"ms"<< endl;
 cout << "cost time:" << TC.getTimerMicroSec() << "us" << endl;
 
 return 0;
}

5.秒级精度

单纯以备不时之需，没人用吧。

time() 函数

在头文件time.h中，time()获取当前的系统时间，只能精确到秒，返回的结果是一个time_t类型，其使用方法如下：

#include <time.h>   
#include <stdio.h>   

int main()
 {  
     time_t first, second;  
     first=time(NULL);  
     delay(2000);  
     second=time(NULL);  
     printf("The difference is: %f seconds",difftime(second,first));  //调用difftime求出时间差
     return 0;   
}
KiraFenvy
关注
  • 17
    点赞
  • 踩
  • 123
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
高精度VC++计时器及高频事件产生器
03-15
内容索引:VC/C++源码,算法相关,秒表,计时器　　这是一个具有高精度计时和高频事件产生的示例程序，在平时的开发中，我们经常会用到计时，在有些场合，我们对计时的要求是非常高的，那么本程序向大家演示两种精确计时的方法，计时的精度可以达到ms级，可以作为时间的基准， 运行程序后，你会发现系统定时器频率、多媒体定时器时间、多线程定时器时间在高速运转。
操作系统 时间片轮转算法C++代码
12-03
时间片轮转算法 系统将所有的就绪进程按先来先服务的原则排成一个队列，每次调度时把 CPU 分配给队首进程，并令其执行一个时间片。当执行的时间片用完时，由一个计时器发出时钟中断请求，调度程序使据此信号来停止该进程的执行（本实验为模拟时间片轮转算法，故没有实现时钟中断请求），并将它送往就绪队列的末尾。然后，再把处理机分配给就绪队列中的下一个进程，同时也让它执行一个时间片。 每次调度时，总是选择就绪队列的队首进程，让其在CPU上运行一个系统预先设置好的时间片。一个时间片内没有完成运行的进程，返回到就绪队列末尾重新排队，等待下一次调度。一个完成的进程，则退出队列。 考虑到新老进程同时插入队列的冲突，我们假设运行过的进程与运行过的进程条件相同时，系统选新进程运行。即在时间片完成时刻，有一个新进程到来，则先将新进程插入就绪队列尾部，然后才将该时间片中未执行完毕的进程插入就绪队列尾部。
C++：计时器
weixin_44110080的博客
05-25 1032
计时器
C语言小项目——电子秒表（毫秒级）
Super辉sir的博客
11-12 5504
秒表是我们生活中常见的计时工具，特别是在运动会等比赛中，今天我就来写一个简单的电子秒表。
C++ 精确计时方法std::chrono（clock计时为0）
ney18781902474的博客
01-29 487
以下面代码为例，chrono计时为0.042393ms，但是clock的计时为0s，这是因为打印的时间远远小于clock的精度，所以统计时间为0，因此在统计时间非常小的时候用chrono才能反应精确的时间。下面代码中chrono计时部分(double)(te-ts).count()的单位是ns，(double)(te-ts).count()/1000000单位是ms。clock的计时单位是ms，精度是10000ms，即0.01s，低于这个时间的间隙计时为0。
cpptimer:简单的c ++ 11计时器
05-26
cpptimer 简单的C ++ 11计时器（间隔，超时，重复）。 使用构建器模式进行配置的定期作业的进程内计时器。 cpptimer使您可以使用简单的人性化语法以预定的时间间隔定期运行可转换为std :: function <void>的任何事物。 特征 简单的流利/生成器API 允许单线程或多线程更新 线程安全 仅单文件头 没有依赖关系 要求 cpptimer仅需要具有<ctime>和<chrono>库的C ++ 11编译器。 用法 创建计时器管理器。 timer::manager mgr; 注册任务 mgr.interval([]() { cout << " Happens every 5 second " << endl; }, std::chrono::seconds( 5 )); mgr.timeout([]() { cout << " Ha
【C++】如何用C++做一个计时器？(较简单版)
jerryoldtan的博客
01-21 1729
首先，定义分钟、秒的变量，然后输入变量，另外还得加一段判断，直到输入正确范围内的分钟和秒才计时开始（我这里分钟、秒的值的范围设的是0~59，判断用的goto，你们可以设不同的值，判断可以用bool变量和while语句）。具体程序:f:cout
C++: 计时器类的设计和实现
baiyu33的博客
05-14 1295
使用C++完成一个基础的计时器类的设计和实现，能以不同单位（秒、毫秒、微秒）的形式表示耗时，并且计时器可以反复使用。
C++11计时器:chrono库介绍
热门推荐
森明帮大于黑虎帮的博客
01-05 1万+
C++11计时器:chrono库介绍
获取系统时间几种方法 和 使用CPU时间戳进行高精度计时
KEN Bolg
01-10 5038
1 使用time_t time( time_t * timer )    精确到秒　　计算时间差使用double difftime( time_t timer1, time_t timer0 )2 使用clock_t clock() 得到的是CPU时间    精确到1/CLOCKS_PER_SEC秒3 使用DWORD GetTickCount() 得到的是系统运行的时间 精确到毫秒4
C++计时
自动驾驶行业学习、交流
08-16 6282
目录简介方法1(time.h)方法2(sys/time.h)结果 简介 简单介绍c++的计时方法 方法1(time.h) 无使用环境的限制 #include <time.h> // 计时模块 time_t start,end; // 计时 start=clock(); ... end=clock(); std::cout<<"DBSCAN time: "<<(end-start)/1000<<" ms"<<s
concurrencpp，任务，执行程序，计时器和C ++ 20协程来统治它们-C/C++开发
05-26
concurrencpp允许应用程序使用执行程序和协同程序轻松安全地编写异步代码。 通过使用concurrencpp应用程序，可以将需要异步处理的大型过程分解为较小的任务，这些任务可以同时运行并以协作的方式工作以实现所需的结果。 concurrencpp还允许应用程序使用并行协程更轻松地编写并行算法。 concurrencpp，C ++并发库concurrencpp允许应用程序使用执行程序和协同程序轻松安全地编写异步代码。 通过使用concurrencpp应用程序，可以将需要异步处理的大型过程分解为较小的任务，这些任务可以同时运行并以协作的方式工作以实现所需的结果。 concurrencpp还允许应用程序使用并行协程更轻松地编写并行算法。 concurrencpp主要优点
基于C++和EasyX开发的走迷宫益智小游戏源码+项目说明.zip
08-09
基于C++和EasyX开发的走迷宫益智小游戏源码+项目说明.zip 【项目介绍】 该资源内项目代码都是经过测试运行成功，功能ok的情况下才上传的，请放心下载使用！ 本项目适合计算机相关专业(如计科、人工智能、通信工程、自动化、电子信息等)的在校学生、老师或者企业员工下载使用，也适合小白学习进阶， 或者实际项目借鉴参考！ 当然也可作为毕设项目、课程设计、作业、项目初期立项演示等。如果基础还行，也可在此代码基础上进行修改，以实现其他功能。 版本：V1.0 时间：2020-7-22 环境：开始使用 VS2010，后来用 VS2017 修改 简介：一个普通的迷宫小游戏 感谢：感谢 QQ 群 C语言革命7 全体成员为该项目的开发做了巨大的贡献，没有你们，该作品也不能有现在的情况！ 版权：作者原创，无抄袭，不涉及版权问题，仅用作学习、娱乐，欢迎各位fork! ### 玩法： ~~~cpp 游戏开始选择系列关卡 有三种系列： 森林（简单，基于 Prim 算法） 地牢（中等，基于图论 DFS 算法） 地狱（困难，基于暴力 DFS 算法） 选择系列后，进入游戏 WSAD 上下左右，游戏中有计时器 ~~~ ### 文件： ~~~cpp Maze.h : 初始化头文件 Maze.cpp : 程序开端文件 Game.h : 游戏类头文件 Adventrue.cpp : 冒险模式类文件 Forest.cpp : 冒险模式-森林系列类实现文件 Dungeon.cpp : 冒险模式-地牢系列类实现文件 Infernal.cpp : 冒险模式-地狱系列类实现文件 Help.cpp : 帮助信息类实现文件 Other.cpp : 刷新界面、放置按钮、输出对话框类实现文件 ~~~
总结UNIX/LINUX下C++程序计时的方法
12-31
前言 良好的计时器可帮助程序开发人员确定程序的性能瓶颈，或对不同算法进行性能比较。但要精确测量程序的运行时间并不容易，因为进程切换、中断、共享的多用户、网络流量、高速缓存访问及转移预测等因素都会对程序计时产生影响。 下面看看小编为大家整理几个计时方法 方法一： 如果是想统计某个程序的运行时间，那么可以使用 time ./a.out 方法二： 如果是想对某个函数或者语句进行计时，那么有别的方法。比如说，gettimeofday函数。直接贴示例代码: #include void f() { //... } int main() { struct timeval t
数据结构与算法学习笔记七--二叉树(C++)
最新发布
我叫柱子哥
04-23 600
在计算机科学中，树（Tree）是一种抽象数据类型，用于模拟具有树状结构特征的数据集合。树是由一组节点（Nodes）和连接这些节点的边（Edges）组成的，其中一个节点被指定为根节点（Root），其余节点分层组织成子树（Subtrees）。树的每个节点除了根节点外，都恰好连接到一条来自另一个节点的边，这个节点被称为其父节点（Parent Node）。每个节点可以连接到零个或多个子节点，子节点的节点被称为父节点的孩子节点（Child Node）。根节点（Root）：树中的唯一顶层节点，没有父节点。
【C】 初识C语言
努力学习C/C++
04-21 751
从本篇开始，带你从不会C语言到精通C语言。这篇是让大家对C语言有个初步的了解。下面的内容会拆分不同篇幅单独进行详细讲叙。数据类型变量、常量字符串转义字符注释选择语句循环语句函数数组操作符常见关键字define定义常量和宏指针结构体1.什么是C语言？C语言是一门面向过程的计算机编程语言，与C++、C#、Java等面向对象编程语言有所不同。C语言的设计目标是提供一种能以简易的方式编译、处理低级存储器、仅产生少量的机器码以及不需要任何运行环境支持便能运行的编程语言。
C++ WebServer的细节理解
我的博客
04-22 586
在非阻塞模式下，如果 I/O 操作不能立即完成（例如，因为没有数据可读 或 写缓冲区满），系统不会让调用进程阻塞等待，而是立即返回一个错误（通常为 EAGAIN 或 EWOULDBLOCK）。先查询文件描述符 fd 当前的标志，然后将 O_NONBLOCK 标志加入其中，并通过 F_SETFL 来更新文件描述符，最终实现将该文件描述符切换为非阻塞模式。这意味着，如果没有待处理的连接请求（即没有客户端尝试连接到服务器），accept() 会一直阻塞，直到有新的连接请求到达或发生其他特定条件（如超时）为止。
[C++] 内存布局完整解读
wangdsh的博客
04-19 813
右值引用和移动语义：虽然这些特性主要影响临时对象的处理和函数参数的传递，但它们也可能间接影响内存布局，因为它们允许更高效的资源转移和避免不必要的复制。总之，C++11在内存布局方面提供了更多的控制和标准化，使得开发者能够更精确地管理数据结构在内存中的排列，同时也提高了代码的可移植性和性能。继承和多重继承：在多重继承中，基类的数据成员会先于派生类的数据成员排列，且每个基类的数据成员会按照它们在基类中的顺序排列。统一的内存对齐模型：C++11提供了跨编译器和平台的一致内存对齐模型，这有助于提高代码的可移植性。
【动态规划】C++ dp子数组问题（最大/最长：环形/子数组和、乘积最大/为正数、单词拆分、子串）
卜及中的博客
04-22 757
文章介绍了子数组类的dp问题，并通过一系列算法题加深对该类问题的解法理解。
如何用c++查看ransac算法拟合时间
05-26
要查看RANSAC算法拟合时间，可以使用C++的chrono库中的高精度计时器进行计时。具体代码如下： ```c++ #include <iostream> #include <chrono> #include <random> #include <vector> // RANSAC Algorithm void RANSAC() { // Your RANSAC implementation here } int main() { // Generate random data for testing std::default_random_engine generator; std::uniform_real_distribution<double> distribution(-10.0, 10.0); std::vector<double> data(100); for (auto& val : data) { val = distribution(generator); } // Start timer auto start = std::chrono::high_resolution_clock::now(); // Run RANSAC RANSAC(); // Stop timer auto stop = std::chrono::high_resolution_clock::now(); // Calculate elapsed time auto duration = std::chrono::duration_cast<std::chrono::microseconds>(stop - start); std::cout << "Elapsed time: " << duration.count() << " microseconds" << std::endl; return 0; } ``` 在上面的代码中，RANSAC函数是你的RANSAC实现，可以在其中添加任何你想测试的代码。主函数中生成了一些随机数据，然后使用高精度计时器计算RANSAC算法的运行时间。计时器的精度可以达到微秒级别。 需要注意的是，C++的chrono库可以在不同的操作系统上产生不同的结果。因此，为了得到更准确的结果，最好在相同的操作系统上运行代码。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值