对编程技巧和编程语言语法的熟练掌握有助于提高编码速度和准确率。本篇介绍一些简单的编程技巧并给出部分代码片段。

注：本篇适用于已熟练掌握大一C++内容。标注‘*’适用于计算机大类，标注‘**’仅适用于提升自身水平。

1.编程技巧

1.1 排序性能问题*

一般来说的sort使用都是sort(arr,arr+n，cmp),此种方法固然可行，但却由于cmp函数调用与编译次数过多而导致性能较差。因此一般来说都会定义一个结构体来在排序函数中传入一个cmp对象来优化。部分代码如下：

struct TS{
    int a,b,c;
};
struct cmpfun{
    inline bool operator()(const TS& t1,const TS& t2){
        if(t1.a!=t2.a)return t1.a<t2.a;
        if(t1.b!=t2.b)return t1.b<t2.b;
        return t1.c<=t2.c;
    }
};
TS arr[10010];
int main(){
    sort(arr,arr+10000,cmpfun());
    return 0;
}

1.2 整数输入

没什么大用，可以替换一些想不到的麻烦输入操作。

int readint(){
    int x;cin>>x;return x;
}//其他数据类型同理，也可template操作
vector<int> vc;
vc.push_back(readint());

1.3 循环宏定义

在遇到一些变态的图论问题，动态规划，模拟操作等，写的最多的代码便是循环，为此可以写一些宏定义来使写代码时方便一些。但对性能要求较高时不建议使用。

#define _for(i,a,b) for(int i=(a);i<(b);i++)
#define _rep(i,a,b) for(int i=(a);i<=(b);i++)

1.4 STL容器内容调试输出

懒得写一堆循环，于是搞了这个来输出容器内容：

template<typename T>
ostream& operator<<(ostream os,const vector<T>& v){
    for(int i=0;i<v.size;i++)os<<v[i]<<" ";
    return os;
}
//换个版本
template<typename T>
ostream& operator<<(ostream os,const set <T>& v){
    for(typename set<T>::iterator it=v.begin();it!=v.end();it++)//适用set
    os<<*it<<" ";
    return os;
}

1.5 二维几何运算

搞一个Point，要用就复制粘贴。代码较长。

点击展开

using namespace std;
const int maxn=1010;//一般计算几何数字不会太大
const double pi=acos(-1.0);
const double eps=1e-8;
int sgn(double x){//double而决定的0
    if(fabs(x)<eps)return 0;
    else return x<0?-1:1;
}
int Dcmp(double x,double y){//double而决定的比较大小
    if(fabs(x-y)<eps)return 0;
    return 1;
}
struct Point{//点的基操
    double x,y;
    Point(){}
    Point(double x,double y):x(x),y(y){}
    Point operator + (Point B){return Point(x+B.x,y+B.y);}
    Point operator - (Point B){return Point(x-B.x,y-B.y);}
    Point operator * (double k){return Point(x*k,y*k);}
    Point operator / (double k){return Point(x/k,y/k);}
    bool operator == (Point B){return sgn(x-B.x)==0&&sgn(y-B.y)==0;}
    bool operator < (Point B){return sgn(x-B.x<0)||(sgn(x-B.x)==0&&sgn(y-B.y)<0);}
};
typedef Point Vector;//定义向量
double Dot(Vector A,Vector B){return A.x*B.x+A.y*B.y;}
double Len(Vector A){return sqrt(Dot(A,A));}
double Len_2(Vector A){return Dot(A,A);}
double Angle(Vector A,Vector B){return acos(Dot(A,B)/Len(A)/Len(B));}
double Cross(Vector A,Vector B){return A.x*B.y-A.y*B.x;}
double Area2(Point A,Point B,Point C){return Cross(B-A,C-A);}
double Dist(Point A,Point B){return hypot(A.x-B.x,A.y-B.y);}
Vector Normal(Vector A){return Vector(-A.y/Len(A),A.x/Len(A));}
bool Parallel(Vector A,Vector B){return sgn(Cross(A,B))==0;}
Vector Rotate(Vector A,double rad){return Vector(A.x*cos(rad)-A.y*cos(rad),A.x*sin(rad)+A.y*sin(rad));}
struct Line{
    Point p1,p2;
    Line(){};
    Line(Point p1,Point p2):p1(p1),p2(p2){}
    Line(Point p,double angle){
        p1=p;
        if(sgn(angle-pi/2)==0){p2=p1+Point(0,1);}
        else {p2=(p1+Point(1,tan(angle)));}
    }
    Line(double a,double b,double c){
        if(sgn(a)==0){
            p1=Point(0,-c/b);
            p2=Point(1,-c/b);
        }
        else if(sgn(b)==0){
            p1=Point(-c/a,0);
            p2=Point(-c/a,1);
        }
        else{
            p1=Point(0,-c/a);
            p2=Point(1,(-c-a)/b);
        }
    }
};
typedef Line Segment;
double Line_angle(Line v){
    double k=atan2(v.p2.y-v.p1.y,v.p2.x-v.p1.x);
    if(sgn(k)<0)k+=pi;if(sgn(k-pi)==0)k-=pi;return k;
}
int Point_line_relation(Point p,Line v){
    int c=sgn(Cross(p-v.p1,v.p2-v.p1));
    if(c<0) return 1;//left
    if(c>0)return -1;//right
    return 0;//on
}
bool Point_on_seg(Point p,Line v){return (sgn(Cross(p-v.p1,v.p2-v.p1))==0&&sgn(Dot(p-v.p1,v.p2-v.p1))<=0);}
int Line_relation(Line v1,Line v2){
    if(sgn(Cross(v1.p2-v1.p1,v2.p2-v2.p1))==0){
        if(Point_line_relation(v1.p1,v2)==0)return 1;//重合
        else return 0;//平行
    }
    return -1;//相交
}
double Dis_point_line(Point p,Line v){return fabs(Cross(p-v.p1,v.p2-v.p1));}
Point Point_line_proj(Point p,Line v){return (v.p1+(v.p2-v.p1)*(Dot(v.p2-v.p1,p-v.p1)/Len_2(v.p2-v.p1)));}
Point Point_line_symmetry(Point p,Line v){
    Point q=Point_line_proj(p,v);
    return Point(2*q.x-p.x,2*q.y-p.y);
}
double Dis_point_seg(Point p,Segment v){
    if(sgn(Dot(p-v.p1,v.p2-v.p1))<0||sgn(Dot(p-v.p2,v.p1-v.p2))<0)
        return min(Dist(p,v.p1),Dist(p,v.p2));
    return Dis_point_line(p,v);
}
Point Cross_point(Point a,Point b,Point c,Point d){
    double s1=Cross(b-a,c-a);
    double s2=Cross(b-a,d-a);
    return Point(c.x*s2-d.x*s1,c.y*s2-d.y*s1)/(s2-s1);
}
bool Corss_segment(Point a,Point b,Point c,Point d){
    double c1=Cross(b-a,c-a);double c2=Cross(b-a,d-a);
    double d1=Cross(d-c,a-c);double d2=Cross(d-c,b-c);
    return sgn(c1)*sgn(c2)<0&&sgn(d1)*sgn(d2)<0;
}
struct Polygon{
    int n;
    Point p[maxn];
    Line v[maxn];
};
int Point_in_polygon(Point pt,Point *p,int n){
    for(int i=0;i<n;i++){
        if(p[i]==pt)return 3;//点上
    }
    for(int i=0;i<n;i++){
        Line v=Line(p[i],p[(i+1)%n]);
        if(Point_on_seg(pt,v))return 2;//边上
    }
    int num=0;
    for(int i=0;i<n;i++){
        int j=(i+1)%n;
        int c=sgn(Cross(pt-p[j],p[i]-p[j]));
        int u=sgn(p[i].y-pt.y);
        int v=sgn(p[j].y-pt.y);
        if(c>0&&u<0&&v>=0)num++;
        if(c<0&&u>0&&v<0)num--;
        return num!=0;//1内0外
    }
}
double Polygon_area(Point *p,int n){
    double area=0;
    for(int i=0;i<n;i++)area+=Cross(p[i],p[(i+1)%n]);
    return area/2;
}
Point Polygon_center(Point *p,int n){
    Point ans(0,0);
    if(Polygon_area(p,n)==0)return ans;
    for(int i=0;i<n;i++)ans=ans+((p[i]+p[(i+1)%n])*Cross(p[i],p[(i+1)%n]));
    return ans/Polygon_area(p,n)/6;
}
int Convex_hull(Point *p,int n,Point *ch){
    sort(p,p+n);n=unique(p,p+n)-p;int v=0;
    for(int i=0;i<n;i++){
        while(v>1&&sgn(Cross(ch[v-1]-ch[v-2],p[i]-ch[v-2]))<=0)v--;
        ch[v++]=p[i];
    }
    int j=v;
    for(int i=n-2;i>=0;i--){
        while(v>j&&sgn(Cross(ch[v-1]-ch[v-2],p[i]-ch[v-2]))<=0)v--;
        ch[v++]=p[i];
    }
    if(n>1)v--;
    return v;
}
struct Circle{
    Point c;double r;
    Circle(){};
    Circle(Point c,double r):c(c),r(r){}
    Circle(double x,double y,double _r){c=Point(x,y);r=_r;}
};
int Point_circle_relation(Point p,Circle C){
    double dst=Dist(p,C.c);
    if(sgn(dst-C.r)<0)return 0;
    if(sgn(dst-C.r)==0)return 1;
    return -1;
}
int Line_circle_relation(Segment v,Circle C){
    double dst=Dis_point_line(C.c,v);
    if(sgn(dst-C.r)<0)return 1;
    if(sgn(dst-C.r)==0)return 0;
    return -1;
}
int Line_cross_circle(Line v,Circle C,Point &pa,Point &pb){
    if(Line_circle_relation(v,C)==-1)return 0;
    Point q=Point_line_proj(C.c,v);
    double d=Dis_point_line(C.c,v);
    double k=sqrt(C.r*C.r-d*d);
    if(sgn(k)==0){
        pa=q;pb=q;return 1;
    }
    Point n=(v.p2-v.p1)/Len(v.p2-v.p1);
    pa=q+n*k;pb=q-n*k;
    return 2;

1.6 内存池**

在一些题目中，需要动态分配对象。例如，表达解析时需要动态分配语法树的节点对象。一般的做法是直接用数组开辟空间，但是未必容易实现估计出开辟的空间大小，在逻辑控制中还要维护一个变量进行分配和释放，如果是多种对象都要动态分配，则更加繁琐。为此编写内存池。

template<typename T>
struct Pool{
    vector<T*> buf;
    T* createNew(){
        buf.push_back(new T());
        return buf.back();
    }
    void dispose(){
        for(int i=0;i<buf.size();i++)delete buf[i];
        buf.clear();
    }
};
struct Node{};
Pool <Node> n1pool;
Node *p=n1pool.createNew();
n1pool.dispose();

1.7 泛型参数

没什么用，很简单，就是简化代码。

template<int maxsize>
struct Dijkstra{//举个栗子
    int n,m,dp[maxsize],p[maxsize];
};
//……不再赘述

1.8 位运算操作封装*

我们经常遇到一个操作为取得一个整数中的某几位对应int值。这件事代码繁琐，有时还要多次调用，很麻烦。为此封装了一个位运算操作类，使用时复制粘贴即可。

template<typename TI>//int or long long
struct BitOp{
    inline TI flip(TI op,size_t pos,size_t len=1){return op^(((1<<len)-1)<<pos);}
    inline TI& set(TI& op,size_t pos,int v,size_t len=1){
        int o=((1<<len)-1);
        return op=(op&(~(o<<pos)))|((v&o)<<pos);
    }
    inline int get(TI op,size_t pos,size_t len=1){return (op>>pos)&((1<<len)-1);}
    ostream& outBits(ostream& os,TI i){
        if(i)outBits(os,(i>>1))<<(i&1);
        return os;
    }
};

1.9 脚本编译

当你的编译器坏了/得不到想要结果，便可自行编译(Windows环境)。

ojc.bat
cls
g++ "%1" -lm -O2 -pipe -o"%~n1.exe"

ojr.bat
cls
echo
del %~n1.exe
@g++ "%1" -lm -O2 -pipe -o"%~n1.exe"
@%~n1.exe<%~n1.in

使用时只需命令行输入ojc 文件名或ojr 文件名即可。

待更……

1.10 万能头文件

一般来说支持C++14以上的编译器均支持#include<bits/stdc++.h>，若编译器提示无法找到相应文件，只需在对应位置创建名为stdc++.h的文件，插入如下代码即可。

点击展开

// C
#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 <cuchar>
#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 <codecvt>
#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

#if __cplusplus >= 201402L
#include <shared_mutex>
#endif

#if __cplusplus >= 201703L
#include <charconv>
#include <filesystem>
#endif