- chen2312 的博客
C++超快读（类似cin,cout）
-
chen2312
LV 8
@
2025-10-5 14:59:16
C++超快读:
// fastio.h
#include <cctype>
#include <iostream>
#include <cstdio>
#include <string>
#include <algorithm>
#include <type_traits>
#include <cmath>
#include <cstdlib>
#include <cstring>
#if defined(_WIN32)
#include <fcntl.h>
#include <io.h>
#else
#include <unistd.h>
#endif
#define BUF_SIZE (1 << 16)
#define STR_BUF_SIZE ((1 << 24) + 1)
#define Ciallo int // 可自定义默认整数类型
namespace fastio {
class FastEndl{
}fastendl;
// 读取模式枚举
enum ReadMode {
DEFAULT, // 默认模式（按空白分隔）
LINE, // 行模式（按换行分隔）
RAW, // 原始模式（不跳过空白）
BINARY // 二进制模式
};
// 布尔值输出格式
enum BoolFormat {
DIGIT, // 数字格式（1/0）
TEXT // 文本格式（true/false）
};
class FastIO {
private:
// 输入缓冲区
static char in_buf[BUF_SIZE];
static char* in_p1; // 缓冲区读指针（当前位置）
static char* in_p2; // 缓冲区尾指针
// 输出缓冲区
static char out_buf[BUF_SIZE];
static char* out_p; // 缓冲区写指针
// 字符串处理缓冲区
static char str_buf[STR_BUF_SIZE];
// 全局配置
static ReadMode current_mode; // 当前读取模式
static BoolFormat bool_format; // 布尔值输出格式
// 从缓冲区快速读取一个字符
inline char getc_faster() {
if (in_p1 == in_p2) {
// 缓冲区为空时从stdin读入
in_p2 = (in_p1 = in_buf) + fread(in_buf, 1, BUF_SIZE, stdin);
if (in_p1 == in_p2) return EOF; // 到达文件尾
}
return *in_p1++;
}
// 快速写入一个字符到缓冲区
inline void putc_faster(char c) {
*out_p++ = c;
// 缓冲区即将满时刷新
if (out_p - out_buf >= BUF_SIZE - 64) flush();
}
// 跳过空白字符（根据当前模式）
void skip_whitespace() {
if (current_mode != RAW && current_mode != BINARY) {
char c;
while ((c = getc_faster()) != EOF) {
if (current_mode == LINE) {
// 行模式下跳过换行符
if (c != '\n' && c != '\r') {
in_p1--; // 回退指针（保留非换行符）
break;
}
} else {
// 默认模式下跳过所有空白
if (!isspace(c)) {
in_p1--; // 回退指针（保留非空白符）
break;
}
}
}
}
}
// 判断是否到达文件尾
bool eof() {
if (in_p1 < in_p2) return false; // 缓冲区还有数据
// 尝试刷新缓冲区
in_p1 = in_buf;
in_p2 = in_buf + fread(in_buf, 1, BUF_SIZE, stdin);
return in_p1 == in_p2; // 缓冲区仍为空则到达文件尾
}
public:
// 构造函数默认
FastIO() = default;
// 析构函数：刷新输出缓冲区
~FastIO() {
flush();
}
// 设置读取模式
static void set_read_mode(ReadMode mode) {
current_mode = mode;
}
// 设置布尔值输出格式
static void set_bool_format(BoolFormat format) {
bool_format = format;
}
// 刷新输出缓冲区
void flush() {
if (out_p != out_buf) {
fwrite(out_buf, 1, out_p - out_buf, stdout);
fflush(stdout);
out_p = out_buf;
}
}
// ==================== 输入运算符重载（>>） ====================
// 有符号整数输入
template<typename T>
typename std::enable_if<std::is_integral<T>::value && std::is_signed<T>::value, FastIO&>::type
operator>>(T& x) {
x = 0;
bool neg = false;
char c = getc_faster();
// 跳过非数字字符，记录符号
while (!isdigit(c) && !eof()) {
if (c == '-') neg = true;
c = getc_faster();
}
// 读取数字部分
while (isdigit(c) && !eof()) {
x = x * 10 + (c - '0');
c = getc_faster();
}
// 应用符号
if (neg) x = -x;
return *this;
}
// 无符号整数输入
template<typename T>
typename std::enable_if<std::is_integral<T>::value && std::is_unsigned<T>::value, FastIO&>::type
operator>>(T& x) {
x = 0;
char c = getc_faster();
// 跳过非数字字符
while (!isdigit(c) && !eof()) c = getc_faster();
// 读取数字部分
while (isdigit(c) && !eof()) {
x = x * 10 + (c - '0');
c = getc_faster();
}
return *this;
}
// 浮点数输入
template<typename T>
typename std::enable_if<std::is_floating_point<T>::value, FastIO&>::type
operator>>(T& x) {
x = 0;
bool neg = false;
char c = getc_faster();
// 跳过无关字符（寻找数字、小数点或符号）
while (!isdigit(c) && c != '.' && c != '-' && !eof()) {
c = getc_faster();
}
// 处理符号
if (c == '-') {
neg = true;
c = getc_faster();
}
T factor = 1.0; // 小数部分的因子
bool after_dot = false;
// 读取整数和小数部分
while ((isdigit(c) || c == '.') && !eof()) {
if (c == '.') {
after_dot = true;
} else {
if (after_dot) {
factor *= 0.1;
x += factor * (c - '0');
} else {
x = x * 10 + (c - '0');
}
}
c = getc_faster();
}
// 处理指数部分（如123e-4）
if (c == 'e' || c == 'E') {
int exp = 0;
bool exp_neg = false;
c = getc_faster();
// 指数符号
if (c == '-') {
exp_neg = true;
c = getc_faster();
} else if (c == '+') {
c = getc_faster();
}
// 读取指数值
while (isdigit(c) && !eof()) {
exp = exp * 10 + (c - '0');
c = getc_faster();
}
// 应用指数
if (exp_neg) {
while (exp--) x /= 10.0;
} else {
while (exp--) x *= 10.0;
}
}
// 应用符号
if (neg) x = -x;
return *this;
}
// 字符输入（跳过空白）
FastIO& operator>>(char& c) {
c = getc_faster();
// 跳过空白字符（除非是原始模式）
while (isspace(c) && !eof()) c = getc_faster();
return *this;
}
// 布尔值输入（支持t/T/1为true，其他为false）
FastIO& operator>>(bool& b) {
char c = getc_faster();
if (c == EOF) {
b = false;
return *this;
}
// 跳过非字母数字字符
while (!isalnum(c) && !eof()) {
c = getc_faster();
if (c == EOF) {
b = false;
return *this;
}
}
// 判断布尔值
b = (c == 't' || c == 'T' || c == '1');
// 跳过当前值的剩余字符
while (c != EOF && !isspace(c) && !eof()) {
c = getc_faster();
}
return *this;
}
// C风格字符串输入（按空白分隔）
FastIO& operator>>(char* s) {
char c = getc_faster();
// 跳过前导空白
while (isspace(c) && !eof()) c = getc_faster();
// 读取直到空白或结束
while (!isspace(c) && c != EOF && !eof()) {
*s++ = c;
c = getc_faster();
}
*s = '\0'; // 终止符
return *this;
}
// 字符串输入（根据模式读取）
FastIO& operator>>(std::string& s) {
s.clear();
// 二进制模式：读取整个流
if (current_mode == BINARY) {
while (true) {
if (eof()) break;
size_t bytes_read = fread(str_buf, 1, STR_BUF_SIZE, stdin);
if (bytes_read == 0) break;
s.append(str_buf, bytes_read);
}
return *this;
}
// 非原始模式：跳过前导空白
if (current_mode != RAW) skip_whitespace();
// 读取直到分隔符
char c;
while (!eof() && (c = getc_faster()) != EOF) {
if (current_mode == LINE) {
// 行模式：遇到换行则停止
if (c == '\n' || c == '\r') break;
} else if (current_mode != RAW) {
// 默认模式：遇到空白则停止
if (isspace(c)) break;
}
s += c;
}
return *this;
}
// ==================== 输出运算符重载（<<） ====================
// 无符号整数输出
template<typename T>
typename std::enable_if<std::is_integral<T>::value && std::is_unsigned<T>::value, FastIO&>::type
operator<<(T x) {
if (x == 0) {
putc_faster('0');
return *this;
}
// 用栈存储数字的逆序
static char stack[20];
int top = 0;
while (x) {
stack[top++] = x % 10 + '0';
x /= 10;
}
// 逆序输出
while (top--) {
putc_faster(stack[top]);
}
return *this;
}
// 有符号整数输出
template<typename T>
typename std::enable_if<std::is_integral<T>::value && std::is_signed<T>::value, FastIO&>::type
operator<<(T x) {
if (x < 0) {
putc_faster('-'); // 输出负号
// 转换为无符号类型处理（避免溢出）
*this << static_cast<typename std::make_unsigned<T>::type>(-x);
} else {
*this << static_cast<typename std::make_unsigned<T>::type>(x);
}
return *this;
}
// 浮点数输出（保留6位小数）
template<typename T>
typename std::enable_if<std::is_floating_point<T>::value, FastIO&>::type
operator<<(T x) {
if (x < 0) {
putc_faster('-');
x = -x;
}
// 输出整数部分
long long integer = static_cast<long long>(x);
*this << integer;
// 输出小数部分（保留6位）
T fractional = x - integer;
if (fractional > 1e-9) { // 存在有效小数
putc_faster('.');
fractional += 1e-7; // 四舍五入修正
for (int i = 0; i < 6; i++) {
fractional *= 10;
int digit = static_cast<int>(fractional);
putc_faster('0' + digit);
fractional -= digit;
}
}
return *this;
}
// 字符输出
FastIO& operator<<(char c) {
putc_faster(c);
return *this;
}
// 布尔值输出（根据格式）
FastIO& operator<<(bool value) {
if (bool_format == DIGIT) {
putc_faster(value ? '1' : '0');
} else {
const char* str = value ? "true" : "false";
while (*str) putc_faster(*str++);
}
return *this;
}
// 字符串输出
FastIO& operator<<(const std::string& s) {
for (char c : s) putc_faster(c);
return *this;
}
// C风格字符串输出
FastIO& operator<<(const char* s) {
while (*s) putc_faster(*s++);
return *this;
}
// ==================== 辅助功能 ====================
// 读取一行（忽略回车符）
void read_line(std::string& s) {
s.clear();
char c;
while (!eof() && (c = getc_faster()) != EOF) {
if (c == '\n') break; // 遇到换行停止
if (c != '\r') s += c; // 忽略回车符
}
}
// 换行并刷新
FastIO& writeln() {
putc_faster('\n');
flush();
return *this;
}
// 输出内容并换行
template<typename T>
FastIO& writeln(const T& x) {
*this << x;
return writeln();
}
// ==================== 新增 fastendl 支持 ====================
// 定义 endl 操纵符类型
typedef FastIO& (*EndlManipulator)(FastIO&);
// 重载 << 运算符以支持 endl 操纵符
FastIO& operator<<(EndlManipulator manip) {
return manip(*this);
}
FastIO& operator<<(FastEndl endl) {
putc_faster('\n');
flush();
return *this;
}
// 定义 endl 风格的流操作符
// static FastIO& fastendl(FastIO& os) {
// os.write('\n'); // 或使用其他输出字符的方法
// os.flush();
// return os;
// }
// 重载 << 操作符以接受函数指针
// FastIO& operator<<(FastIO& (*manipulator)(FastIO&)) {
// return manipulator(*this);
// }
// 兼容标准库的 std::endl
FastIO& operator<<(std::ostream& (*manip)(std::ostream&)) {
if (manip == static_cast<std::ostream& (*)(std::ostream&)>(std::endl)) {
putc_faster('\n');
flush();
}
return *this;
}
// 初始化IO（跨平台设置）
static void init() {
#if defined(_WIN32)
// Windows设置二进制模式（避免CRLF转换）
_setmode(_fileno(stdin), _O_BINARY);
_setmode(_fileno(stdout), _O_BINARY);
#endif
// 可根据需要设置缓冲区模式
}
};
// 静态成员初始化
char FastIO::in_buf[BUF_SIZE];
char* FastIO::in_p1 = FastIO::in_buf;
char* FastIO::in_p2 = FastIO::in_buf;
char FastIO::out_buf[BUF_SIZE];
char* FastIO::out_p = FastIO::out_buf;
char FastIO::str_buf[STR_BUF_SIZE];
ReadMode FastIO::current_mode = DEFAULT;
BoolFormat FastIO::bool_format = DIGIT;
class StrFastIO {
private:
// 输入字符串
std::string* in_str = nullptr;
size_t in_pos = 0;
// 输出字符串
std::string* out_str = nullptr;
// 全局配置
ReadMode current_mode = DEFAULT; // 当前读取模式
BoolFormat bool_format = DIGIT; // 布尔值输出格式
// 从字符串快速读取一个字符
inline char getc_faster() {
if (in_str == nullptr || in_pos >= in_str->size()) {
return EOF; // 到达字符串尾
}
return (*in_str)[in_pos++];
}
// 快速写入一个字符到字符串
inline void putc_faster(char c) {
if (out_str != nullptr) {
out_str->push_back(c);
}
}
// 跳过空白字符（根据当前模式）
void skip_whitespace() {
if (current_mode != RAW && current_mode != BINARY) {
char c;
while ((c = getc_faster()) != EOF) {
if (current_mode == LINE) {
// 行模式下跳过换行符
if (c != '\n' && c != '\r') {
in_pos--; // 回退指针（保留非换行符）
break;
}
} else {
// 默认模式下跳过所有空白
if (!isspace(c)) {
in_pos--; // 回退指针（保留非空白符）
break;
}
}
}
}
}
// 判断是否到达字符串尾
bool eof() {
return in_str == nullptr || in_pos >= in_str->size();
}
public:
// 构造函数
StrFastIO() = default;
// 设置输入字符串
void set_input_string(std::string& str) {
in_str = &str;
in_pos = 0;
}
// 设置输出字符串
void set_output_string(std::string& str) {
out_str = &str;
str.clear();
}
// 设置读取模式
void set_read_mode(ReadMode mode) {
current_mode = mode;
}
// 设置布尔值输出格式
void set_bool_format(BoolFormat format) {
bool_format = format;
}
// 刷新输出（对于字符串输出，不需要特殊操作）
void flush() {
// 字符串输出不需要刷新
}
// ==================== 输入运算符重载（>>） ====================
// 有符号整数输入
template<typename T>
typename std::enable_if<std::is_integral<T>::value && std::is_signed<T>::value, StrFastIO&>::type
operator>>(T& x) {
x = 0;
bool neg = false;
char c = getc_faster();
// 跳过非数字字符，记录符号
while (!isdigit(c) && !eof()) {
if (c == '-') neg = true;
c = getc_faster();
}
// 读取数字部分
while (isdigit(c) && !eof()) {
x = x * 10 + (c - '0');
c = getc_faster();
}
// 应用符号
if (neg) x = -x;
return *this;
}
// 无符号整数输入
template<typename T>
typename std::enable_if<std::is_integral<T>::value && std::is_unsigned<T>::value, StrFastIO&>::type
operator>>(T& x) {
x = 0;
char c = getc_faster();
// 跳过非数字字符
while (!isdigit(c) && !eof()) c = getc_faster();
// 读取数字部分
while (isdigit(c) && !eof()) {
x = x * 10 + (c - '0');
c = getc_faster();
}
return *this;
}
// 浮点数输入
template<typename T>
typename std::enable_if<std::is_floating_point<T>::value, StrFastIO&>::type
operator>>(T& x) {
x = 0;
bool neg = false;
char c = getc_faster();
// 跳过无关字符（寻找数字、小数点或符号）
while (!isdigit(c) && c != '.' && c != '-' && !eof()) {
c = getc_faster();
}
// 处理符号
if (c == '-') {
neg = true;
c = getc_faster();
}
T factor = 1.0; // 小数部分的因子
bool after_dot = false;
// 读取整数和小数部分
while ((isdigit(c) || c == '.') && !eof()) {
if (c == '.') {
after_dot = true;
} else {
if (after_dot) {
factor *= 0.1;
x += factor * (c - '0');
} else {
x = x * 10 + (c - '0');
}
}
c = getc_faster();
}
// 处理指数部分（如123e-4）
if (c == 'e' || c == 'E') {
int exp = 0;
bool exp_neg = false;
c = getc_faster();
// 指数符号
if (c == '-') {
exp_neg = true;
c = getc_faster();
} else if (c == '+') {
c = getc_faster();
}
// 读取指数值
while (isdigit(c) && !eof()) {
exp = exp * 10 + (c - '0');
c = getc_faster();
}
// 应用指数
if (exp_neg) {
while (exp--) x /= 10.0;
} else {
while (exp--) x *= 10.0;
}
}
// 应用符号
if (neg) x = -x;
return *this;
}
// 字符输入（跳过空白）
StrFastIO& operator>>(char& c) {
c = getc_faster();
// 跳过空白字符（除非是原始模式）
while (isspace(c) && !eof()) c = getc_faster();
return *this;
}
// 布尔值输入（支持t/T/1为true，其他为false）
StrFastIO& operator>>(bool& b) {
char c = getc_faster();
if (c == EOF) {
b = false;
return *this;
}
// 跳过非字母数字字符
while (!isalnum(c) && !eof()) {
c = getc_faster();
if (c == EOF) {
b = false;
return *this;
}
}
// 判断布尔值
b = (c == 't' || c == 'T' || c == '1');
// 跳过当前值的剩余字符
while (c != EOF && !isspace(c) && !eof()) {
c = getc_faster();
}
return *this;
}
// C风格字符串输入（按空白分隔）
StrFastIO& operator>>(char* s) {
char c = getc_faster();
// 跳过前导空白
while (isspace(c) && !eof()) c = getc_faster();
// 读取直到空白或结束
while (!isspace(c) && c != EOF && !eof()) {
*s++ = c;
c = getc_faster();
}
*s = '\0'; // 终止符
return *this;
}
// 字符串输入（根据模式读取）
StrFastIO& operator>>(std::string& s) {
s.clear();
// 二进制模式：读取整个字符串
if (current_mode == BINARY) {
if (in_str != nullptr) {
s = in_str->substr(in_pos);
in_pos = in_str->size();
}
return *this;
}
// 非原始模式：跳过前导空白
if (current_mode != RAW) skip_whitespace();
// 读取直到分隔符
char c;
while (!eof() && (c = getc_faster()) != EOF) {
if (current_mode == LINE) {
// 行模式：遇到换行则停止
if (c == '\n' || c == '\r') break;
} else if (current_mode != RAW) {
// 默认模式：遇到空白则停止
if (isspace(c)) break;
}
s += c;
}
return *this;
}
// ==================== 输出运算符重载（<<） ====================
// 无符号整数输出
template<typename T>
typename std::enable_if<std::is_integral<T>::value && std::is_unsigned<T>::value, StrFastIO&>::type
operator<<(T x) {
if (x == 0) {
putc_faster('0');
return *this;
}
// 用栈存储数字的逆序
static char stack[20];
int top = 0;
while (x) {
stack[top++] = x % 10 + '0';
x /= 10;
}
// 逆序输出
while (top--) {
putc_faster(stack[top]);
}
return *this;
}
// 有符号整数输出
template<typename T>
typename std::enable_if<std::is_integral<T>::value && std::is_signed<T>::value, StrFastIO&>::type
operator<<(T x) {
if (x < 0) {
putc_faster('-'); // 输出负号
// 转换为无符号类型处理（避免溢出）
*this << static_cast<typename std::make_unsigned<T>::type>(-x);
} else {
*this << static_cast<typename std::make_unsigned<T>::type>(x);
}
return *this;
}
// 浮点数输出（保留6位小数）
template<typename T>
typename std::enable_if<std::is_floating_point<T>::value, StrFastIO&>::type
operator<<(T x) {
if (x < 0) {
putc_faster('-');
x = -x;
}
// 输出整数部分
long long integer = static_cast<long long>(x);
*this << integer;
// 输出小数部分（保留6位）
T fractional = x - integer;
if (fractional > 1e-9) { // 存在有效小数
putc_faster('.');
fractional += 1e-7; // 四舍五入修正
for (int i = 0; i < 6; i++) {
fractional *= 10;
int digit = static_cast<int>(fractional);
putc_faster('0' + digit);
fractional -= digit;
}
}
return *this;
}
// 字符输出
StrFastIO& operator<<(char c) {
putc_faster(c);
return *this;
}
// 布尔值输出（根据格式）
StrFastIO& operator<<(bool value) {
if (bool_format == DIGIT) {
putc_faster(value ? '1' : '0');
} else {
const char* str = value ? "true" : "false";
while (*str) putc_faster(*str++);
}
return *this;
}
// 字符串输出
StrFastIO& operator<<(const std::string& s) {
for (char c : s) putc_faster(c);
return *this;
}
// C风格字符串输出
StrFastIO& operator<<(const char* s) {
while (*s) putc_faster(*s++);
return *this;
}
// ==================== 辅助功能 ====================
// 读取一行（忽略回车符）
void read_line(std::string& s) {
s.clear();
char c;
while (!eof() && (c = getc_faster()) != EOF) {
if (c == '\n') break; // 遇到换行停止
if (c != '\r') s += c; // 忽略回车符
}
}
// 换行并刷新
StrFastIO& writeln() {
putc_faster('\n');
return *this;
}
// 输出内容并换行
template<typename T>
StrFastIO& writeln(const T& x) {
*this << x;
return writeln();
}
// ==================== fastendl 支持 ====================
StrFastIO& operator<<(FastEndl) {
putc_faster('\n');
return *this;
}
// 兼容标准库的 std::endl
StrFastIO& operator<<(std::ostream& (*manip)(std::ostream&)) {
if (manip == static_cast<std::ostream& (*)(std::ostream&)>(std::endl)) {
putc_faster('\n');
}
return *this;
}
};
// 全局IO对象（类似fastin/fastout）
static FastIO fastin;
static FastIO fastout;
// 全局IO对象
static StrFastIO strfast;
}
using namespace std;
using namespace fastio;
int main() {
FastIO::init();//可有可无
int a, b;
fastin >> a >> b;//读入，支持int,short,long long,float,string,double,
fastin.set_read_mode(LINE);
fastin.set_read_mode(DEFAULT);
/*enum ReadMode {
DEFAULT, // 默认模式（按空白分隔）
LINE, // 行模式（按换行分隔）
RAW, // 原始模式（不跳过空白）
BINARY // 二进制模式
};*/
fastout << "Sum: " << a + b << fastendl;
fastout << "Product: " << a * b << fastendl;
fastout << "Difference: " << a - b << fastendl;//注意2.0不会输出2.0，输出2，2.1输出2.100000
fastout << "Sum: " << a + b << '\n';
fastout << "Product: " << a * b << '\n';
fastout << "Difference: " << a - b << '\n';
int a;
string input,output;
strfast.set_input_string(input);
strfast.set_output_string(output);
strfast>>a<<a;
return 0;
}