在 C++ 编程中，优化是提升程序性能的关键步骤。常数优化，虽然看似细微，但在某些情况下却能显著提高程序的运行效率。本文将为您介绍一些实用的 C++ 常数优化技巧。

输入输出优化

看一下这道题：

【模板】快速读入

题目背景

制约解除作战！

题目描述

给你 $n$ 个数，你需要求和并输出。

输入格式

第一行一个整数 $n$。

之后一行 $n$ 个整数以空格隔开，表示给定的 $n$ 个数。

输出格式

一行一个数表示给定的数的和。

样例 #1

样例输入 #1

5
-1 2 -3 4 -5

样例输出 #1

-3

提示

对于 $25\%$ 的数据，满足 $n=10^5$。

对于 $25\%$ 的数据，满足 $n=10^6$。

对于 $25\%$ 的数据，满足 $n=10^7$。

对于 $25\%$ 的数据，满足 $n=10^8$。

对于 $100\%$ 的数据，满足所有数在 $[-n,n]$ 之间。

普通cin

#include<bits/stdc++.h>
using namespace std;
long long n,a,ans;
int main(){
	cin>>n;
	while(n--){
		cin>>a;
		ans+=a;
	}
	cout<<ans<<endl;
}

IOScin

#include<bits/stdc++.h>
using namespace std;
long long n,a,ans;
int main(){
	ios::sync_with_stdio(0);
	cin.tie(0);cout.tie(0);
	cin>>n;
	while(n--){
		cin>>a;
		ans+=a;
	}
	cout<<ans<<endl;
}

scanf

#include<bits/stdc++.h>
using namespace std;
long long n,a,ans;
int main(){
	scanf("%lld",&n);
	while(n--){
		scanf("%lld",&a);
		ans+=a;
	}
	printf("%lld\n",ans);
}

传引用快读

#include<bits/stdc++.h>
using namespace std;
template<typename T>
inline void read(T &x)
{
    x=0;char c = getchar();int s = 1;
    while(c < '0' || c > '9') {if(c == '-') s = -1;c = getchar();}
    while(c >= '0' && c <= '9') {x = x*10 + c -'0';c = getchar();}
    x*=s;
}
template<typename T>
inline void write(T x)
{
    if(x<0)
        putchar('-'),x=-x;
    if(x>9)
        write(x/10);
    putchar(x%10+'0');
    return;
}
long long n,a,ans;
int main(){
	read(n);
	while(n--){
		read(a);
		ans+=a;
	}
	write(ans);
}

返回值快读

#include <bits/stdc++.h>
using namespace std;
inline int read(){
	int x = 0, f = 1;
	char ch = getchar();
	while (!isdigit(ch)){
		if (ch == '-') 
			f = -1;
		ch = getchar();
	}
	while (isdigit(ch)){
		x = (x << 1) + (x << 3) + (ch ^ 48);
		ch = getchar();
	}
	return x * f;
}

inline void write(int x){
	if (x < 0) putchar('-'), x = -x;
	if (x > 9) write(x / 10);
	putchar(x % 10 + '0');
}

int main(){
	int n = read(),ans = 0;
	int a[n + 1];
	while(n--){
		ans += read();
	}
	write(ans);
	return 0;
}

快读优化

#include <bits/stdc++.h>
using namespace std;
inline int read(){
	int x = 0, f = 1;
	char ch = getchar_unlocked();
	while (!isdigit(ch)){
		if (ch == '-') 
			f = -1;
		ch = getchar_unlocked();
	}
	while (isdigit(ch)){
		x = (x << 1) + (x << 3) + (ch ^ 48);
		ch = getchar_unlocked();
	}
	return x * f;
}

inline void write(int x){
	if (x < 0) putchar('-'), x = -x;
	if (x > 9) write(x / 10);
	putchar(x % 10 + '0');
}

int main(){
	int n = read(),ans = 0;
	int a[n + 1];
	while(n--){
		ans += read();
	}
	write(ans);
	return 0;
}

结论：
在Windows系统上，传参快读最快，优化快读会CE
在测评机上，速度排序依次为优化快读，传参快读，返回值快读，IOScin，scanf，朴素cin

常量表达式优化

C++11 引入了常量表达式（constexpr）的概念。常量表达式是指在编译期间就能计算出结果的表达式。通过使用 constexpr ，可以让编译器在编译时进行计算，从而避免在运行时进行计算，提高程序的效率。

// 未优化版本
int fibonacci(int n) {
    if (n <= 1) {
        return n;
    }
    return fibonacci(n - 1) + fibonacci(n - 2);
}

// 优化版本：使用常量表达式计算斐波那契数列
constexpr int fibonacci(int n) {
    return (n <= 1)? n : fibonacci(n - 1) + fibonacci(n - 2);
}

循环的边界优化

在循环中，尽量使用常量来定义循环的边界。这样可以让编译器更好地进行优化，例如展开循环或者消除一些不必要的边界检查。

// 未优化版本
int arr[100];
for (int i = 0; i < 100; ++i) {
    arr[i] = i;
}

// 优化版本：使用常量定义循环边界
const int arrSize = 100;
for (int i = 0; i < arrSize; ++i) {
    arr[i] = i;
}

类型转换优化

类型转换可能会带来性能开销。特别是在频繁执行的代码段中，应尽量避免不必要的类型转换。

double value = 3.14;
int intValue = static_cast<int>(value);  // 仅在必要时进行类型转换

位运算优化

在某些情况下，位运算（如左移、右移）可以替代乘法和除法，因为位运算通常比乘法和除法运算更快。但是，在程序中，编译器一般会帮你优化，不用你费心思去写右移左移了。

// 未优化版本
int multiplyByEight(int num) {
    return num * 8;
}

// 优化版本：使用左移 3 位替代乘以 8
int multiplyByEight(int num) {
    return num << 3;
}

预计算优化

对于一些在程序运行过程中不会改变的值，可以在程序开始时进行预计算，避免在运行时重复计算。

// 未优化版本
void calculateSum(int n) {
    int sum = 0;
    for (int i = 0; i < n; ++i) {
        sum += i;
    }
}

// 优化版本：预计算求和公式
void calculateSum(int n) {
    const int sum = (n * (n - 1)) / 2;
    // 后续使用预计算的 sum
}

数据类型优化

根据实际需求选择合适的数据类型，避免使用过大或过小的数据类型。例如，如果一个整数的值不会超过 255 ，使用 uint8_t 而不是 int 。

// 未优化版本
int age = 25; 
// 优化版本：如果年龄范围确定在 0 到 150 之间，使用更紧凑的数据类型
unsigned char age = 25; 

结构体优化

拿存图举例，如下代码：

struct edge{
		int u,v,w;
	}e[M];

是优于如下代码的

int u[M],v[M],w[M];

原因是我们很可能同时关心一条边的所有信息，存储关联的一组数据时，结构体一般会比存储空间局部性更好，更好地利用缓存

提高复杂度

algorithm中的sort函数，当区间长度小于16时，就会切换到$O(n^2)$插入排序，因为插入排序是连续的，对内存十分友好，在这个长度下$O(logn)$并不比$O(n)$快多少，log的函数还很难维护，所以，分治的结尾，用O(n)的算法，反而可以优化时间复杂度。

表达式优化

如果一个式子在程序里多次出现，就可以提前将式子的结果存下来。

尾递归优化

某些函数在结束时返回调用自己的值。一种典型的例子就是线段树：例如，某个询问完全当前节点的左子节点时，常见的写法是直接递归调用自己，并将节点和区间改为左子节点和询问区间不变。

int query(int x,int l,int r,int ql,int qr){
	if(l==ql&&r==qr){
		...... 
	}
	int mid=l+r>>1;
	if(qr<=mid)
		return query(t[x].l,l,mid,ql,qr);
	else
	.....
}

这里的return query并不会调用函数，而是直接将参数替换并跳到函数开头。这样，就避免了一次额外的函数调用和函数返回，调用栈也只会有一层。因此，将线段树写为上面这样的适合尾递归的形式，比依次if累加起来性能要好。

内联优化

C++中，inline是一个优化的表示，对于极其简单的函数，编译器很容易分析，内联后就会加快程序的运行速度，但需要注意的是：内联并不是在每一个时候都对程序是好的，内联后，被内联的代码会膨胀，函数大小甚至发生了指数级别的增长，反而会拖慢程序的运行效率。

取模优化

许多计数类的题都会让你将结果对某个特殊的数取模，对于整数来说，加减法，位运算是最快的，其次是乘法，最慢的是除法，在对一个数取模时，应将他设为一个常量，这样编译器就会优化它的取模效，注意，定义常量要用const 关键字，#define只是单纯的替换

关于STL

STL中通常只有数据结构需要担心性能，sort等函数的表现还是很优秀的而且数据结构吸氧之后会有很大提升
vector,priority_queue通常并不必担心性能，实在不行用数组实现
list的性能很差，并不能满足竞赛的要求建议避免使用，代替方案：手写链表
deque和给予其的stack，queue性能都比较差，建议使用数组模拟
set,map底层基于平衡树，功能强大，但性能一般
unordered_map等比map好，但也不算快，其实可以手写哈希表，二次勘测性能比拉链要好。