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 10000
const int MAX = 1000000000;
/*大规模数组的定义*/
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 10000
const int MAX = 1000000000;


宏定义和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宏定义注释掉即可。



附录

万能头文件的定义
#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

Python自动生成代码 - 通过tkinter图形化操作生成代码框架
背景
脚本代码
Demo_CodeGenerator.py
display.py
FileHandler.py:
脚本运行结果：
脚本代码目录
其它好玩的Python脚本

背景
在写代码过程中，如果有频繁重复性的编码操作，或者可以Reuse的各类代码，可以通过Python写一个脚本，自动生成这类代码，就不用每次手写、或者copy了。

应用场景：比如新建固定的代码框架、添加一些既定的软件逻辑，通讯协议、消息模板等等，再编写一套代码时，或者一个Function时，每次使通过脚本一键生成代码，就不需要每次都写一遍了，同时可以把相关软件逻辑放进去，也能避免出错。

脚本代码
Demo_CodeGenerator.py
通过以下代码框架，大家想生成什么样的代码就在mycode中append相应的行，然后点开Display输入相关参数，就可以自动生成code文件。
#conding=utf-8

from FileHandler import WritetoFile
import sys

PwdPath = sys.argv[0]

class BuildCode_Dev:
    'Auto Generate code of Device control'

    def __init__(self, KeyWord = 'TestDemoCommand'):
        self.CmdKeyWord = KeyWord

    def Generate(self):
        fileName = 'Code_Dev.txt'

        mycode = []  
		#想生成什么样的代码就在mycode中append相应的行，
        mycode.append('\n---------------------- Demo code Below: ---------------------- ')

        mycode.append('\n---------------------- Demo code Below: ---------------------- ')  

        mycode.append('\n---------------------- Demo code Below: ---------------------- ')
        mycode.append('\n***** DemoCode_Get_DataLength() *****  ')
        mycode.append('\n***** DemoCode_Set_DataLength() *****  ')

        mycode.append('Switch ('+ self.CmdKeyWord + '):')
        mycode.append('    case('+ self.CmdKeyWord + '):') 
        mycode.append('    break;') 


        WritetoFile(fileName,mycode)

        print('Code:'+self.CmdKeyWord + ' Generator OK!')

        return(mycode)



if __name__ == '__main__':
    if(sys.argv[1:] == []):
        print('Not input parameter , Use Test Data')
        CmdKeyWord = 'TestDemoCommand'
    else:
        CmdKeyWord = sys.argv[1]
        
    
#code = BuildCode_Dev(CmdKeyWord)
#code.Generate()


#print(PwdPath)
#print(CmdKeyWord)


display.py
主要通过tkinter图形化显示，根据输入参数，点击按钮 生成相应的代码。
# -*- coding: utf-8 -*-
from tkinter import *
from GatewayControl_CodeGenerator import *
from DeviceControl_CodeGenerator import *


def GWMsg():
     txt.delete(1.0,END)
     Input = str(inputData.get(1.0,END))
     
     Cmd_Gw = BuildCode_GW(Input)
     CodeRst = Cmd_Gw.Generate()
     s = 'Code_GW.txt Generate Success:\n\n'
     txt.insert(END, s)
     txt.insert(END, CodeRst) 
     #inputData.delete(0.0, END)  

def DevMsg():
     txt.delete(1.0,END)
     Input = str(inputData.get(1.0,END))
     
     Cmd_Dev = BuildCode_Dev(Input)
     CodeRst = Cmd_Dev.Generate()
     s = 'Code_Dev.txt Generate Success:\n\n'
     txt.insert(END, s)
     txt.insert(END, CodeRst) 
     #inputData.delete(0.0, END)     

def clearContent():
     inputData.delete(1.0, END)  
     txt.delete(1.0,END)


root = Tk()
root.geometry('1000x600')
root.title(' Code Generator')
root.config(bg='#f0ffff')

#Lable
intro = Label(root,text='请在左侧输入消息/命令名字, 然后选择相应按钮生成代码',\
                       bg='#d3fbfb',\
                       fg='red',\
                       font=('华文新魏',11),\
                       width=20,\
                       height=2,\
                       relief=RIDGE)

intro.place(relx=0.1, rely=0.1, relwidth=0.8, relheight=0.1)

#Input
inputData = Text(root, font = ('',14))
inputData.place(relx=0.1, rely=0.2, relwidth=0.3, relheight=0.6)

#Output
txt = Text(root, font = ('',9))
txt.place(relx=0.6, rely=0.2, relwidth=0.3, relheight=0.6)

#Button 
bt_json2bin = Button(root, text='**Demo Control', command=GWMsg, fg ='blue')
bt_json2bin.place(relx=0.4, rely=0.25, relwidth=0.2, relheight=0.1)

bt_bin2json = Button(root, text='**Demo Control', command=DevMsg, fg ='blue')
bt_bin2json.place(relx=0.4, rely=0.45, relwidth=0.2, relheight=0.1)

bt_clear = Button(root, text='Clear', command=clearContent, fg ='blue')
bt_clear.place(relx=0.4, rely=0.65, relwidth=0.2, relheight=0.1) 

intro = Label(root,text='产生的完整代码在 Code_GW.txt或Code_Dev.txt中(当前目录 ), 问题联系人：Howard',\
                       bg='#d3fbfb',\
                       fg='red',\
                       font=('华文新魏',11),\
                       width=20,\
                       height=2,\
                       relief=RIDGE)

intro.place(relx=0.1, rely=0.8, relwidth=0.8, relheight=0.1)

root.mainloop()


FileHandler.py:
主要是把代码写入文件保存

def WritetoFile(FileName,Data):
    with open(FileName,'w') as record:
        strr = "\n"
        content = strr.join(Data)
        record.write(content+'\n')


脚本运行结果：
运行display.py， 选择相应按钮后，会调用相应生成代码py文件。

最后可以把这个打包成一个exe，方便使用。


脚本代码目录

其它好玩的Python脚本
Python实现自动发送邮件 --自动抓取博客/网站中留言的邮箱并发送相应邮件

Python自动生成代码 - 通过tkinter图形化操作并生成代码框架

Python解析CSV数据 - 通过Pandas解析逻辑分析仪导出的CSV数据

Python通过Django搭建网站执行Lua脚本 （实现数据解析）

选择标准
简要：目前代码框架琳琅满目。主要氛围：mvc，mvp，mvvm，mvpvm，mvi以及相关变种：mvc hodler变种，theMvp变种，mvpMosby，ArmsMvp，HabbitMvvm，等等。框架将影响整个产品周期，以及相关维护。筛选一个适用的框架需要一个衡量标准。


确定mvp左右主框架进行。

理由：根据App产品的开发规范和流程。参见《产品设计七层自检模型》


已经成熟1年以上的框架。

理由：新出来的框架，没有经历时间的考验，作为应用主框架，是有风险的。


有实际产品例子在用。

理由：再好的框架也要有实战经验，并且是别人趟过地雷的经验。


有千万级或者亿级别大用户量产品的经验。

理由：大用户量的千锤百炼才能得出框架的稳固。


可以实现多变模块的完全结偶，比如view层

理由：view层是经常改变，复用的。结偶代表维护成本低


可以完全掌握并管理生命周期

理由：生命周期的掌控，可以最大性能优化，回收资源，防止生命周期泄漏。


选择TheMvp理由

TheMVP起源于2015年
支付宝里明确说明，引用该框架
view层完全结偶，并且可以复用
activity作为presenter完全可以掌控自身的所有生命周期

工具篇
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