C/C++算法竞赛代码框架
 


 
文章目录
 
C/C++算法竞赛代码框架
一、基本代码框架
1.最简框架
2.万能框架
   
二、测试代码框架
1.时间测试框架
2.文件重定向框架
   
三、本地测试框架
1.本地测试框架代码：
2.本地测试框架说明：
   
四、终极框架
附录
 

 
一、基本代码框架
 
1.最简框架
 
 
 
最初接触C/C++时，没有学习文件、函数等知识，仅知道在这个框架下写出语句就可以在终端进行基本输入输出。
 
 
 
(1)C语言
 
#include <stdio.h>
int main()
{
    /*code*/
    return 0;
}
 
 
(2)C++
 
#include <iostream>
using namespace std;
int main()
{
    /*code*/
    return 0;
}
 
 
2.万能框架
 
 
 
随着学习的深入，基本的输入输出已经无法满足做题的需要，可以为了方便程序编写，事先将常用头文件包含进来。
 
 
 
C语言(包含常用头文件)
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
int main()
{
    /*code*/
    return 0;
}
 
 
C++(包含万能头文件)
 
#include <bits/stdc++.h>
using namespace std;
int main()
{
    /*code*/
    return 0;
}
 
 
二、测试代码框架
 
1.时间测试框架
 
在面临较大规模的数据输入时，需要大致判断程序运行时间和算法效率的对比时，可以使用<time.h>头文件，并在输出的最后一行打印出程序的时间。clock()函数获得程序运行的时间，CLOCKS_PER_SEC和系统相关，两者相除便是程序运行秒数。由于输入数据会占用程序运行时间，可以使用文件重定向方法（见下文）和“管道”小技巧：
 
 
 
管道小技巧：
 使用命令行运行程序echo 数据 | 程序名
 
 
 
C语言
 
#include <stdio.h>
#include <time.h>
int main()
{

    /*code*/
    
    printf("\nTime used = %f", (double)clock() / CLOCKS_PER_SEC);
    return 0;
}
 
 
C++
 
#include <bits/stdc++.h>
using namespace std;
int main()
{

    /*code*/
    
    printf("\nTime used = %f", (double)clock() / CLOCKS_PER_SEC);
    return 0;
}
 
 
2.文件重定向框架
 
对于大规模数据的输入和输出，可以将标准输入输出重定向到程序同一目录下的输入data.in输出data.out文件中。使用重定向语句：freopen( "data.in", "r", stdin);和freopen( "data.out", "r", stdout);。在提交代码时一定记得将这两行语句注释掉！！！
 
 
C语言
 
#include <stdio.h>
int main()
{
    freopen("data.in", "r", stdin);		//提交代码时记得注释掉或删除
    freopen("data.out", "r", stdout);	//提交代码时记得注释掉或删除
    
    /*code*/
    
    return 0;
}
 
 
C++
 
#include <bits/stdc++.h>
using namespace std;
int main()
{
    freopen("data.in", "r", stdin);   //提交代码时记得注释掉或删除
    freopen("data.out", "r", stdout); //提交代码时记得注释掉或删除

    /*code*/
    
    return 0;
}
 
 
三、本地测试框架
 
1.本地测试框架代码：
 
 
 
C++可以兼容C语言程序，且拥有更多函数模板、类模板和算法，因此终极框架采取C++语言。
 
 
#define LOCAL            //本地调试宏定义
#include <bits/stdc++.h> //万能头文件
/*宏定义及常量定义部分*/
#define INF 10000000
const int N = 10;
/*大规模数组的定义*/
int Array[INF];

using namespace std;
int main()
{
#ifdef LOCAL
    freopen("data.in", "r", stdin);   //提交代码时记得注释掉或删除
    freopen("data.out", "r", stdout); //提交代码时记得注释掉或删除
#endif

    /*code*/

#ifdef LOCAL
    printf("\nTime used = %f", (double)clock() / CLOCKS_PER_SEC);
#endif
    return 0;
}
 
2.本地测试框架说明：
 
 
1.测试本地条件编译宏定义
 
#define LOCAL 
 
  
 
   
定义宏用于本地测试时的条件编译，提交代码时仅需将此行注释掉
 
  
 
 
2.万能头文件
 
#include <bits/stdc++.h> //万能头文件
 
  
 
   
C++的万能头文件，此头文件包含了几乎所有的头文件，具体头文件内容定义见本文末附录部分。大部分竞赛和oj平台支持万能头文件，但不推荐在工程上使用。
 
  
 
 
3.常量及宏定义
 
/*宏定义及常量定义部分*/
#define INF 100000000
const int N = 10;
 
  
 
   
宏定义和const常量定义均可以用来定义常量，方便更改常量的值，且提高代码可读性，在存储空间充足的条件下，推荐const常量定义，可以进行类型检查。
 
  
 
 
4.大规模数组定义
 
int Array[INF];
 
  
 
   
将大规模数组定义在main函数外，定义成全局变量，一是可以无需手动初始化，全局变量数组定义后自动初始化；二是全局变量存储在数据区，减小栈区的开销。
 
  
 
 
5.条件编译文件重定向语句及运行时间测试语句
 
#ifdef LOCAL
    freopen("data.in", "r", stdin);   //提交代码时记得注释掉或删除
    freopen("data.out", "r", stdout); //提交代码时记得注释掉或删除
#endif
 
#ifdef LOCAL
    printf("\nTime used = %f", (double)clock() / CLOCKS_PER_SEC);
#endif
 
  
 
   
将重定向语句及运行时间测试语句均设置为条件编译，在本地编译运行时可以重定向输入输出并查看运行时间，提交代码时，只需要将第一行的LOCAL宏定义注释掉即可。
 
  
 
 
四、终极框架
 
#include <bits/stdc++.h>
using namespace std;
using ll=long long;
using vi=vector<int>;
using pii=pair<int,int>;
const int inf=0x3f3f3f3f;
const int mod=1e9+7;
const double eps=1e-6;
#define pb push_back
#define eb emplace_back
#define fi first
#define se second
#define all(x) x.begin(),x.end()
#define rep(i,a,b) for(int i=a;i<=b;++i)
#define rrep(i,a,b) for(int i=a;i>=b;--i)
#define mst(x,i) memset(x,i,sizeof(x))
#define gkd ios::sync_with_stdio(0),cin.tie(0),cout.tie(0)
#define lb(x) (x&-x)
const int maxm=9+1e6;
const int N=9;
const int maxn=9+2e3;

#define LOCAL

int main()
{
    gkd;
#ifdef LOCAL
    freopen("data.in", "r", stdin);   //提交代码时记得注释掉或删除
    freopen("data.out", "r", stdout); //提交代码时记得注释掉或删除
#endif

    /*code*/

#ifdef LOCAL
    printf("\nTime used = %f", (double)clock() / CLOCKS_PER_SEC);
#endif
    return 0;
}
 
附录
 
万能头文件的定义
#ifndef _GLIBCXX_NO_ASSERT
#include <cassert>
#endif
#include <cctype>
#include <cerrno>
#include <cfloat>
#include <ciso646>
#include <climits>
#include <clocale>
#include <cmath>
#include <csetjmp>
#include <csignal>
#include <cstdarg>
#include <cstddef>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>

#if __cplusplus >= 201103L
#include <ccomplex>
#include <cfenv>
#include <cinttypes>
#include <cstdalign>
#include <cstdbool>
#include <cstdint>
#include <ctgmath>
#include <cwchar>
#include <cwctype>
#endif

// C++
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <exception>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <locale>
#include <map>
#include <memory>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <streambuf>
#include <string>
#include <typeinfo>
#include <utility>
#include <valarray>
#include <vector>

#if __cplusplus >= 201103L
#include <array>
#include <atomic>
#include <chrono>
#include <condition_variable>
#include <forward_list>
#include <future>
#include <initializer_list>
#include <mutex>
#include <random>
#include <ratio>
#include <regex>
#include <scoped_allocator>
#include <system_error>
#include <thread>
#include <tuple>
#include <typeindex>
#include <type_traits>
#include <unordered_map>
#include <unordered_set>
#endif
 

 
 
  
工具篇
ORB-SLAM的代码框架
 
 
 
 
 
转载请注明出处：http://blog.csdn.net/c602273091/article/details/54933404
 
工具篇
 
在看代码方面，有不少软件推荐。我觉得首推还是得Understand【1】，这个工具可以把代码的流程图、依赖关系、整个框架给描述出来。有钱的话，买正版。其次的话，我推荐SourceInsight。这个工具比较方便看出你的类的定义。我在使用的时候一般是上面一半是代码，下面一半看类的定义。这样看代码就是事半功倍。
 
ORB-SLAM的代码框架
 
 
 在这里我主要分析的是单目SLAM中的kitti数据集的流程图。
 
接下来从main函数开始抽丝剥茧：
 
/**
* This file is part of ORB-SLAM2.
*
* Copyright (C) 2014-2016 Ra煤l Mur-Artal <raulmur at unizar dot es> (University of Zaragoza)
* For more information see <https://github.com/raulmur/ORB_SLAM2>
*
* ORB-SLAM2 is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* ORB-SLAM2 is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with ORB-SLAM2. If not, see <http://www.gnu.org/licenses/>.
*/


#include<iostream>
#include<algorithm>
#include<fstream>
#include<chrono>
#include<iomanip>

#include<opencv2/core/core.hpp>

#include"System.h"

using namespace std;

// 从文件夹中load图片进来
void LoadImages(const string &strSequence, vector<string> &vstrImageFilenames,
                vector<double> &vTimestamps);

int main(int argc, char **argv)
{
    // 判断参数是否符合规范
    // ./mono_kitti path_to_vocabulary path_to_settings path_to_sequence
    // 一共有四个参数：可执行文件argv[0]、字典的目录argv[1]、配置的路径argv[2]、图片序列的路径argv[3]
    if(argc != 4)
    {
        cerr << endl << "Usage: ./mono_kitti path_to_vocabulary path_to_settings path_to_sequence" << endl;
        return 1;
    }

    // Retrieve paths to images
    vector<string> vstrImageFilenames;
    vector<double> vTimestamps;
    // 加载图片，传入图片路径、传回的是图片的文件名、每幅图片的时间戳
    LoadImages(string(argv[3]), vstrImageFilenames, vTimestamps);

    // 图片的个数
    int nImages = vstrImageFilenames.size();

    // 对SLAM系统进行初始化，传入字典和配置的路径
    // Create SLAM system. It initializes all system threads and gets ready to process frames.
    ORB_SLAM2::System SLAM(argv[1],argv[2],ORB_SLAM2::System::MONOCULAR,true);


    // Vector for tracking time statistics
    vector<float> vTimesTrack;
    // 计算追踪所花的时间
    vTimesTrack.resize(nImages);

    cout << endl << "-------" << endl;
    cout << "Start processing sequence ..." << endl;
    cout << "Images in the sequence: " << nImages << endl << endl;

    // Main loop
    cv::Mat im;
    for(int ni=0; ni<nImages; ni++)
    {
        // Read image from file
        im = cv::imread(vstrImageFilenames[ni],CV_LOAD_IMAGE_UNCHANGED);
        double tframe = vTimestamps[ni];

        if(im.empty())
        {
            cerr << endl << "Failed to load image at: " << vstrImageFilenames[ni] << endl;
            return 1;
        }

#ifdef COMPILEDWITHC11
        // 如果编译器可以编译c++11
        // 获取当前时间
        std::chrono::steady_clock::time_point t1 = std::chrono::steady_clock::now();
#else
        std::chrono::monotonic_clock::time_point t1 = std::chrono::monotonic_clock::now();
#endif

        // Pass the image to the SLAM system
        // 图片放入SLAM系统中进行追踪
        SLAM.TrackMonocular(im,tframe);

#ifdef COMPILEDWITHC11
        std::chrono::steady_clock::time_point t2 = std::chrono::steady_clock::now();
#else
        std::chrono::monotonic_clock::time_point t2 = std::chrono::monotonic_clock::now();
#endif

        double ttrack= std::chrono::duration_cast<std::chrono::duration<double> >(t2 - t1).count();
        // 计算追踪该图片花的时间
        vTimesTrack[ni]=ttrack;

        // Wait to load the next frame
        // 计算下一帧图片时间戳与当前时间戳的差值T，与追踪所需时间进行比较
        // 如果有必要就将当前线程暂停sleep
        // 主要是为了模拟时间情况，因为追踪结束以后下一帧可能还没来
        double T=0;
        if(ni<nImages-1)
            T = vTimestamps[ni+1]-tframe;
        else if(ni>0)
            T = tframe-vTimestamps[ni-1];

        if(ttrack<T)
            usleep((T-ttrack)*1e6);
    }

    // Stop all threads
    // 追踪完所有图片序列以后，关掉当前的线程
    SLAM.Shutdown();

    // Tracking time statistics
    // 对追踪的部分进行一个统计
    // 计算中位数，总数、平均值
    sort(vTimesTrack.begin(),vTimesTrack.end());
    float totaltime = 0;
    for(int ni=0; ni<nImages; ni++)
    {
        totaltime+=vTimesTrack[ni];
    }
    cout << "-------" << endl << endl;
    cout << "median tracking time: " << vTimesTrack[nImages/2] << endl;
    cout << "mean tracking time: " << totaltime/nImages << endl;

    // Save camera trajectory
    // 保存整个相机的位姿的轨迹
    SLAM.SaveKeyFrameTrajectoryTUM("KeyFrameTrajectory.txt");

    return 0;
}

void LoadImages(const string &strPathToSequence, vector<string> &vstrImageFilenames, vector<double> &vTimestamps)
{
    ifstream fTimes;
    // 读4541幅图片的时间戳（kitti的00图片序列）
    string strPathTimeFile = strPathToSequence + "/times.txt";
    // string类型转化为char*类型
    fTimes.open(strPathTimeFile.c_str());
    while(!fTimes.eof())
    {
        string s;
        getline(fTimes,s);
        if(!s.empty())
        {
            // string类型转化为double类型
            // 使用stringstream类型
            stringstream ss;
            ss << s;
            double t;
            ss >> t;
            vTimestamps.push_back(t);
        }
    }
    // 使用image_0目录下的文件，这是双目摄像头的左边的摄像头的序列
    string strPrefixLeft = strPathToSequence + "/image_0/";

    const int nTimes = vTimestamps.size();
    vstrImageFilenames.resize(nTimes);

    for(int i=0; i<nTimes; i++)
    {
        stringstream ss;
        // 设置0~nTime-1的图片的路径
        ss << setfill('0') << setw(6) << i;
        vstrImageFilenames[i] = strPrefixLeft + ss.str() + ".png";
    }
}
 
整个main函数看下来，真正有价值的地方在于：
 
SLAM系统初始化：ORB_SLAM2::System
SLAM(argv[1],argv[2],ORB_SLAM2::System::MONOCULAR,true);
SLAM系统的追踪部分：SLAM.TrackMonocular(im,tframe);
 
次要的地方是
 
线程关闭：SLAM.Shutdown();
保存整条轨迹： SLAM.SaveKeyFrameTrajectoryTUM(“KeyFrameTrajectory.txt”); 看了源码我觉得如果是kitti的数据集的话，应该调用SaveTrajectoryKITTI
 
当然在看代码之前把ORB-SLAM的论文看一遍非常重要。对于这片论文的介绍，可以看我的系列文章【2】【3】【4】。
 
参考链接： 
 【1】understand下载： http://www.qqtn.com/down/91669.html 
 【2】http://blog.csdn.net/c602273091/article/details/54348202 
 【3】http://blog.csdn.net/c602273091/article/details/54411989 
 【4】http://blog.csdn.net/c602273091/article/details/54428693

【前言】
 
        在更深入地阅读了工程中 Audio 部分的驱动代码之后，整理出了一个 ASoC Platform 驱动代码的框架图。类似的 ASoC Machine驱动代码框架图在《ASoC Machine 驱动代码框架图》中，ASoC Codec驱动代码框架图在《ASoC Codec 驱动代码框架图》中。
 

 
 
【图示说明】
 
        浅绿色：模块入口
 
        黄色：声卡中的部件 snd_soc_component 设备实例
 
        棕色：平台设备驱动 sst_platform_driver 驱动实例
 
        红色：注册 设备结构体/驱动结构体 到 Linux设备驱动模型内核
 
        粉色：platform设备驱动模型中 ASoC架构 所嵌入的位置
 
        墨蓝色：ASoC Platform_driver实例
 
        蓝色：简要说明
 

 
 
 
【ASoC Platform驱动代码框架图】
 
        图片很大，想看清楚细节需要 放大网页（Ctrl+鼠标滚轮）或 在新的页面打开图片 或 下载图片到本地。这张图对于工程中的 ASoC Platform 部分的说明应该十分详尽了。关于 Framework、HAL 的代码框架图，等我整理完了慢慢也都发上来作为备份。
 

 

选择标准
 
简要：目前代码框架琳琅满目。主要氛围：mvc，mvp，mvvm，mvpvm，mvi以及相关变种：mvc hodler变种，theMvp变种，mvpMosby，ArmsMvp，HabbitMvvm，等等。框架将影响整个产品周期，以及相关维护。筛选一个适用的框架需要一个衡量标准。
 
 
确定mvp左右主框架进行。
 理由：根据App产品的开发规范和流程。参见《产品设计七层自检模型》
 
 
已经成熟1年以上的框架。
 理由：新出来的框架，没有经历时间的考验，作为应用主框架，是有风险的。
 
 
有实际产品例子在用。
 理由：再好的框架也要有实战经验，并且是别人趟过地雷的经验。
 
 
有千万级或者亿级别大用户量产品的经验。
 理由：大用户量的千锤百炼才能得出框架的稳固。
 
 
可以实现多变模块的完全结偶，比如view层
 理由：view层是经常改变，复用的。结偶代表维护成本低
 
 
可以完全掌握并管理生命周期
 理由：生命周期的掌控，可以最大性能优化，回收资源，防止生命周期泄漏。
 
 
选择TheMvp理由
 
TheMVP起源于2015年
支付宝里明确说明，引用该框架
view层完全结偶，并且可以复用
activity作为presenter完全可以掌控自身的所有生命周期