当前位置： 首页 > news >正文

C语言实现类似C#的格式化输出

news 2025/8/16 10:44:22

在C#中，格式化输出可以使用索引占位符以及复合格式的占位符，可以不用关心后面参数是什么类型，使用起来非常方便，如下简单的示例：

Console.WriteLine("{2} {1} {0} {{{2}}}", "Hello, World!", 1, 8.8);

会输出：

8.8 1 Hello, World! {8.8}

规范可以参见：复合格式设置

在C语言标准库中使用的printf系列函数中，需要使用格式化字符串明确指定后面参数的类型，如果指定错误，可能会引发灾难！ 那C语言，可以实现上述功能吗 ？ 在C11泛型的加持下，使用关键字_Generic也可以实现上述功能了，下面笔者就一步步来实现，并且支持可以不指定索引，支持C标准格式化字符串。

一、实现效果

我们假定要实现的是printx和print，其使用的方式如下：

main.c：

#include "printx.h"int main() {char a = 'A';unsigned char b = 130;int age = 25;unsigned int ui = 123456;long l = 12345678;unsigned ul = 123456789;long long ll = 98761234567890;unsigned long long ull = 9998761234567890;float f = 2.71828F;double pi = 3.14159;const char* name = "Witton";unsigned int hexv = 8192;auto x = '\n';printx("test\n");printx("Name: {{{}}}, Age: {}\n", name, age);printx("Age: {1}, Name: {}\n", name, age);printx("Name: {0}, Age: {1}\n", name, age);printx("Pi: {0:.2f}\n", pi);printx("Hex: {0:#x}, Again: {0:#08x}\n", hexv);printx("Swap order: {1}, {0}\n", "first", "second");printx("Char: {0}\n", (char)'A');printx("Repeat: {0} {0} {1:.1f} {}\n", age, pi, f);printx("1:{} 2:{} 3:{} 4:{} 5:{}, 6:{}, 7:{}, 8:{}, 9:{}, 10:{}\n", name, a,b, age, ui, l, ul, ll, ull, f);print(name, a, b, age, ui, l, ul, ll, ull, (char)'\n');return 0;
}

其运行结果为：

test
Name: {Witton}, Age: 25
Age: 25, Name: Witton  
Name: Witton, Age: 25  
Pi: 3.14
Hex: 0x2000, Again: 0x002000
Swap order: second, first
Char: A
Repeat: 25 25 3.1 25
1:Witton 2:A 3:130 4:25 5:123456, 6:12345678, 7:123456789, 8:98761234567890, 9:9998761234567890, 10:2.718280
Witton A 130 25 123456 12345678 123456789 98761234567890 9998761234567890

在这里插入图片描述

需要注意的是：C语言中字面字符的类型是int，而不是char，所以：

printx("Char: {0}\n", (char)'A');

中需要强制转换成char类型才能正常输出字母A。

在这里插入图片描述

二、统一类型

由于在调用的过程中传入的参数可能是各种数据类型，我们需要统一转换成一种自定义类型，在自定义类型中去标识实际的数据类型。

typedef enum {T_UNKNOWN,T_CHAR,T_BYTE,T_STRING,T_BYTES,T_INT,T_UINT,T_LONG,T_ULONG,T_LONGLONG,T_ULONGLONG,T_FLOAT,T_DOUBLE,
} EDataType;typedef struct {EDataType type;union {char c;unsigned char b;int i;unsigned int u;long l;unsigned long ul;long long ll;unsigned long long ull;float f;double d;const char* s;const unsigned char* bs;} v;
} FmtArg;static inline FmtArg make_char(char v) {return (FmtArg){T_CHAR, {.c = v}};
}static inline FmtArg make_uchar(unsigned char v) {return (FmtArg){T_BYTE, {.b = v}};
}static inline FmtArg make_string(const char* s) {return (FmtArg){T_STRING, {.s = s}};
}static inline FmtArg make_bytes(const unsigned char* s) {return (FmtArg){T_BYTES, {.bs = s}};
}static inline FmtArg make_int(int v) {return (FmtArg){T_INT, {.i = v}};
}
static inline FmtArg make_uint(unsigned int v) {return (FmtArg){T_UINT, {.u = v}};
}static inline FmtArg make_long(long v) {return (FmtArg){T_LONG, {.l = v}};
}static inline FmtArg make_ulong(unsigned long v) {return (FmtArg){T_ULONG, {.ul = v}};
}static inline FmtArg make_longlong(long long v) {return (FmtArg){T_LONGLONG, {.ll = v}};
}static inline FmtArg make_ulonglong(unsigned long long v) {return (FmtArg){T_ULONGLONG, {.ull = v}};
}static inline FmtArg make_float(float v) {return (FmtArg){T_FLOAT, {.f = v}};
}static inline FmtArg make_double(double v) {return (FmtArg){T_DOUBLE, {.d = v}};
}static inline FmtArg make_unknown(void) {return (FmtArg){T_UNKNOWN};
}

有了自定义类型了，就可以声明具体实现的C函数了：

void printx_impl(const char* fmt, int arg_count, FmtArg* argv);

前面的fmt就是类似C#的格式符，也可以是nullptr，表明不需要格式字符串，自动依次使用参数；arg_count表明有几个参数，决定着后面参数argv的个数；argv为实际的参数信息。

而给用户调用的API，printx和print其实是一个宏，它类似如下声明：

#define printx(fmt, ...)
#define print(...)

我们需要在宏中调用实际工作的C函数printx_impl，在调用前需要将传入的参数转换成自定义数据类型FmtArg，并且准备好printx_impl函数需要的参数。

三、计算参数个数

如何计算宏参数...中包含的参数个数？
在C/C++中参数... 可能包含0个到多个参数，我们假定最多支持10个参数。为了计算宏参数个数，需要定义一个匹配或者说是取宏参数的宏：

#define GET_MACRO(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, n, ...) n

GET_MACRO的参数列表是：_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, n, ...，这里的...表示剩余参数，但在宏定义中，我们只取n）

然后定义计算宏参数个数的宏：

#define COUNT_ARGS(...) \GET_MACRO(0, ##__VA_ARGS__, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0)

__VA_ARGS__中可能是0个参数，C/C++编译器有一种写法：##__VA_ARGS__，当是0个时，会把前面的逗号去掉，变为：

GET_MACRO(0, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0)

GET_MACRO取第12个参数，结果为0。

如果有多个参数，则依次填充。比如，参数1,2,3，变为：

GET_MACRO(0, 1, 2, 3, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0)

GET_MACRO取第12个参数，结果为3。

四、转换参数

通过前面的方法，我们知道了参数个数，接下来就是实现参数类型的转换了，要实现类型转换就需要知道是什么类型，C11提供了_Generic关键字，只有它才能识别类型，实现泛型。其语法参见：https://cppreference.cn/w/c/language/generic

定义如下宏来将参数转换成自定义类型FmtArg：

#define MAKE_FMTARG(x)                    \_Generic((x),                           \char: make_char,                    \unsigned char: make_uchar,          \const char*: make_string,           \char*: make_string,                 \const unsigned char*: make_bytes,   \unsigned char*: make_bytes,         \int: make_int,                      \unsigned int: make_uint,            \long: make_long,                    \unsigned long: make_ulong,          \long long: make_longlong,           \unsigned long long: make_ulonglong, \float: make_float,                  \double: make_double,                \default: make_unknown)(x)

使用获取参数个数一样的方法，我们也可以逐个取参数，然后调用MAKE_FMTARG进行转换，先定义一组宏：

#define APPLY0(m, a) 0 // 这里定义为0，避免编译器警告
#define APPLY1(m, a) m(a)
#define APPLY2(m, a, ...) m(a), APPLY1(m, __VA_ARGS__)
#define APPLY3(m, a, ...) m(a), APPLY2(m, __VA_ARGS__)
#define APPLY4(m, a, ...) m(a), APPLY3(m, __VA_ARGS__)
#define APPLY5(m, a, ...) m(a), APPLY4(m, __VA_ARGS__)
#define APPLY6(m, a, ...) m(a), APPLY5(m, __VA_ARGS__)
#define APPLY7(m, a, ...) m(a), APPLY6(m, __VA_ARGS__)
#define APPLY8(m, a, ...) m(a), APPLY7(m, __VA_ARGS__)
#define APPLY9(m, a, ...) m(a), APPLY8(m, __VA_ARGS__)
#define APPLY10(m, a, ...) m(a), APPLY9(m, __VA_ARGS__)#define APPLY(m, ...)                                                          \GET_MACRO(0, ##__VA_ARGS__, APPLY10, APPLY9, APPLY8, APPLY7, APPLY6, APPLY5, \APPLY4, APPLY3, APPLY2, APPLY1, APPLY0)(m, __VA_ARGS__)

这组宏支持0~10个参数，对每个参数调用m，m可以是宏，也可以是函数。我们这里需要调用的是MAKE_FMTARG宏。

五、实现printx和print宏

现在可以写出printx和print宏的实现了：

#define printx(fmt, ...)                            \printx_impl(fmt, COUNT_ARGS(__VA_ARGS__), \(FmtArg[]){APPLY(MAKE_FMTARG, ##__VA_ARGS__)})#define print(...)                                \printx_impl(0, COUNT_ARGS(__VA_ARGS__), \(FmtArg[]){APPLY(MAKE_FMTARG, ##__VA_ARGS__)})

(FmtArg[]){APPLY(MAKE_FMTARG, ##__VA_ARGS__)}构建了一个FmtArg的数组，如果参数个数为0，则是(FmtArg[]){0}。

六、扩展实现fprintx和fprint宏

目前的API还只支持输出到标准输出设备stdout，无法输出到文件，比如想输出到日志文件，只需要添加一个FILE* fp参数即可，相应修改如下：

void printx_impl(FILE* fp, const char* fmt, int arg_count, FmtArg* argv);#define printx(fmt, ...)                            \printx_impl(stdout, fmt, COUNT_ARGS(__VA_ARGS__), \(FmtArg[]){APPLY(MAKE_FMTARG, ##__VA_ARGS__)})#define print(...)                                \printx_impl(stdout, 0, COUNT_ARGS(__VA_ARGS__), \(FmtArg[]){APPLY(MAKE_FMTARG, ##__VA_ARGS__)})

实现fprintx和fprint宏：

#define fprintx(fp, fmt, ...)                   \printx_impl(fp, fmt, COUNT_ARGS(__VA_ARGS__), \(FmtArg[]){APPLY(MAKE_FMTARG, ##__VA_ARGS__)})#define fprint(fp, ...)                       \printx_impl(fp, 0, COUNT_ARGS(__VA_ARGS__), \(FmtArg[]){APPLY(MAKE_FMTARG, ##__VA_ARGS__)})

七、源码

printx.h：

// copyright(C), author: Witton
// email: witton@163.com#ifndef _PRINT_X_H_INCLUDE_
#define _PRINT_X_H_INCLUDE_#include <stdio.h>typedef enum {T_UNKNOWN,T_CHAR,T_BYTE,T_STRING,T_BYTES,T_INT,T_UINT,T_LONG,T_ULONG,T_LONGLONG,T_ULONGLONG,T_FLOAT,T_DOUBLE,
} EDataType;typedef struct {EDataType type;union {char c;unsigned char b;int i;unsigned int u;long l;unsigned long ul;long long ll;unsigned long long ull;float f;double d;const char* s;const unsigned char* bs;} v;
} FmtArg;static inline FmtArg make_char(char v) {return (FmtArg){T_CHAR, {.c = v}};
}static inline FmtArg make_byte(unsigned char v) {return (FmtArg){T_BYTE, {.b = v}};
}static inline FmtArg make_string(const char* s) {return (FmtArg){T_STRING, {.s = s}};
}static inline FmtArg make_bytes(const unsigned char* s) {return (FmtArg){T_BYTES, {.bs = s}};
}static inline FmtArg make_int(int v) {return (FmtArg){T_INT, {.i = v}};
}
static inline FmtArg make_uint(unsigned int v) {return (FmtArg){T_UINT, {.u = v}};
}static inline FmtArg make_long(long v) {return (FmtArg){T_LONG, {.l = v}};
}static inline FmtArg make_ulong(unsigned long v) {return (FmtArg){T_ULONG, {.ul = v}};
}static inline FmtArg make_longlong(long long v) {return (FmtArg){T_LONGLONG, {.ll = v}};
}static inline FmtArg make_ulonglong(unsigned long long v) {return (FmtArg){T_ULONGLONG, {.ull = v}};
}static inline FmtArg make_float(float v) {return (FmtArg){T_FLOAT, {.f = v}};
}static inline FmtArg make_double(double v) {return (FmtArg){T_DOUBLE, {.d = v}};
}static inline FmtArg make_unknown(void) {return (FmtArg){T_UNKNOWN};
}#define MAKE_FMTARG(x)                    \_Generic((x),                           \char: make_char,                    \unsigned char: make_byte,          \const char*: make_string,           \char*: make_string,                 \const unsigned char*: make_bytes,   \unsigned char*: make_bytes,         \int: make_int,                      \unsigned int: make_uint,            \long: make_long,                    \unsigned long: make_ulong,          \long long: make_longlong,           \unsigned long long: make_ulonglong, \float: make_float,                  \double: make_double,                \default: make_unknown)(x)#define GET_MACRO(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, n, ...) n#define COUNT_ARGS(...) \GET_MACRO(0, ##__VA_ARGS__, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0)#define APPLY0(m, a) 0  // 这里定义为0，避免编译器警告
#define APPLY1(m, a) m(a)
#define APPLY2(m, a, ...) m(a), APPLY1(m, __VA_ARGS__)
#define APPLY3(m, a, ...) m(a), APPLY2(m, __VA_ARGS__)
#define APPLY4(m, a, ...) m(a), APPLY3(m, __VA_ARGS__)
#define APPLY5(m, a, ...) m(a), APPLY4(m, __VA_ARGS__)
#define APPLY6(m, a, ...) m(a), APPLY5(m, __VA_ARGS__)
#define APPLY7(m, a, ...) m(a), APPLY6(m, __VA_ARGS__)
#define APPLY8(m, a, ...) m(a), APPLY7(m, __VA_ARGS__)
#define APPLY9(m, a, ...) m(a), APPLY8(m, __VA_ARGS__)
#define APPLY10(m, a, ...) m(a), APPLY9(m, __VA_ARGS__)#define APPLY(m, ...)                                                          \GET_MACRO(0, ##__VA_ARGS__, APPLY10, APPLY9, APPLY8, APPLY7, APPLY6, APPLY5, \APPLY4, APPLY3, APPLY2, APPLY1, APPLY0)(m, __VA_ARGS__)#define printx(fmt, ...)                            \printx_impl(stdout, fmt, COUNT_ARGS(__VA_ARGS__), \(FmtArg[]){APPLY(MAKE_FMTARG, ##__VA_ARGS__)})#define print(...)                                \printx_impl(stdout, 0, COUNT_ARGS(__VA_ARGS__), \(FmtArg[]){APPLY(MAKE_FMTARG, ##__VA_ARGS__)})#define fprintx(fp, fmt, ...)                   \printx_impl(fp, fmt, COUNT_ARGS(__VA_ARGS__), \(FmtArg[]){APPLY(MAKE_FMTARG, ##__VA_ARGS__)})#define fprint(fp, ...)                       \printx_impl(fp, 0, COUNT_ARGS(__VA_ARGS__), \(FmtArg[]){APPLY(MAKE_FMTARG, ##__VA_ARGS__)})void printx_impl(FILE* fp, const char* fmt, int arg_count, FmtArg* argv);#endif

printx.c：

// copyright(C), author: Witton
// email: witton@163.com#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>#include "printx.h"#if __STDC_VERSION__ >= 202311L
#ifdef NULL
#undef NULL
#define NULL nullptr
#endif
#endifstatic void print_one_arg(FILE* fp, const char* fmt_spec, FmtArg arg) {if (!fmt_spec[0]) {switch (arg.type) {case T_CHAR:(void)fprintf(fp,"%c", arg.v.c);break;case T_BYTE:(void)fprintf(fp,"%hhu", arg.v.b);break;case T_INT:(void)fprintf(fp,"%d", arg.v.i);break;case T_UINT:(void)fprintf(fp,"%u", arg.v.u);break;case T_LONG:(void)fprintf(fp,"%ld", arg.v.l);break;case T_LONGLONG:(void)fprintf(fp,"%lld", arg.v.ll);break;case T_ULONGLONG:(void)fprintf(fp,"%llu", arg.v.ull);break;case T_FLOAT:(void)fprintf(fp,"%f", arg.v.f);break;case T_DOUBLE:(void)fprintf(fp,"%lf", arg.v.d);break;case T_STRING:(void)fprintf(fp,"%s", arg.v.s);break;default:(void)fprintf(fp,"<?(by witton)>");break;}return;}char real_fmt[64];(void)snprintf(real_fmt, sizeof(real_fmt), "%%%s", fmt_spec);switch (arg.type) {case T_CHAR:(void)fprintf(fp,real_fmt, arg.v.c);break;case T_BYTE:(void)fprintf(fp,real_fmt, arg.v.b);break;case T_INT:(void)fprintf(fp,real_fmt, arg.v.i);break;case T_UINT:(void)fprintf(fp,real_fmt, arg.v.u);break;case T_LONG:(void)fprintf(fp,real_fmt, arg.v.l);break;case T_LONGLONG:(void)fprintf(fp,real_fmt, arg.v.ll);break;case T_ULONGLONG:(void)fprintf(fp,real_fmt, arg.v.ull);break;case T_FLOAT:(void)fprintf(fp,real_fmt, arg.v.f);break;case T_DOUBLE:(void)fprintf(fp,real_fmt, arg.v.d);break;case T_STRING:(void)fprintf(fp,real_fmt, arg.v.s);break;default:(void)fprintf(fp,"<?(by witton)>");break;}
}static inline void handle_printx_fmt(FILE* fp, const char* p,const char* end,int arg_count,FmtArg* argv) {char index_str[16] = {0};char spec[32] = {0};int idx = 0;const char* colon = memchr(p + 1, ':', end - (p + 1));if (colon) {size_t len_idx = colon - (p + 1);strncpy(index_str, p + 1, len_idx);strncpy(spec, colon + 1, end - (colon + 1));} else {strncpy(index_str, p + 1, end - (p + 1));}if (isdigit((unsigned char)index_str[0])) {idx = strtol(index_str, NULL, 10);if (idx >= 0 && idx < arg_count) {print_one_arg(fp, spec, argv[idx]);} else {(void)fprintf(fp, "<BAD_INDEX(by witton)>");}} else {(void)fprintf(fp, "<BAD_FORMAT(by witton)>");}
}void printx_impl(FILE* fp, const char* fmt, int arg_count, FmtArg* argv) {if (NULL == fmt) {for (int i = 0; i < arg_count; ++i) {print_one_arg(fp, "", argv[i]);(void)putc(' ', fp);}return;}int used_args = 0;const char* p = fmt;while (*p) {if (p[0] == '{' && p[1] == '}' && used_args < arg_count) {print_one_arg(fp, "", argv[used_args++]);p += 2;  // 跳过 '}'} else if (*p == '{' && *(p + 1) != '{') {const char* end = strchr(p, '}');if (!end) {(void)putc(*p++, fp);continue;}handle_printx_fmt(fp, p, end, arg_count, argv);p = end + 1;} else if (*p == '{' && *(p + 1) == '{') {(void)putc('{', fp);p += 2;} else if (*p == '}' && *(p + 1) == '}') {(void)putc('}', fp);p += 2;} else {(void)putc(*p++, fp);}}
}

至此，我们可以像C#一样写格式化输出代码了，可以不担心格式符写错了。但是如果了使用自定义格式符，即类似{1:.1f}中有冒号后面标准C格式符，则依旧需要小心格式符是否写正确！

如果本文对你有帮助，欢迎点赞收藏！

http://www.dtcms.com/a/333404.html

相关文章：

  • Kubernetes（3）控制器的应用详解
  • 【Linux应用】V4L2的摄像头配置、获取等操作，并进行视频录制
  • 准直太阳光模拟器 | HUD 光照角度和强度的测试应用
  • 论文解读：从工具人到永动机，AI代理（AI Agent、智能体）如何跨越静态到自进化的鸿沟？
  • Effective Java笔记：类层次优于标签类
  • k8s单master部署
  • 用 Enigma Virtual Box 将 Qt 程序打包成单 exe
  • QT|windwos桌面端应用程序开发，当连接多个显示器的时候，如何获取屏幕编号？
  • 【C#补全计划】委托
  • 基于RobustVideoMatting（RVM）进行视频人像分割（torch、onnx版本）
  • 【opencv-Python学习笔记（5）：几何变换】
  • 补充日志之-配置文件解析指南(Centos7)
  • 容器内部再运行Docker（DinD和DooD）
  • CUDA中的基本概念
  • Linux软件编程：进程线程（线程）
  • 结构体（Struct）、枚举（Enum）的使用
  • 基于SpringBoot的房产销售系统
  • 护栏卫士碰撞报警系统如何实时监测护栏的状态
  • 系统时钟配置
  • 38 C++ STL模板库7-迭代器
  • 用ICO图标拼成汉字
  • BFS和codetop复习
  • 复杂度扫尾+链表经典算法题
  • Klipper-probe模块
  • H5449G降压恒流无人机照明驱动芯片方案24V/36V/48V/72V降6V12V9V /8A替换NCL30160
  • 探索无人机图传技术：创新视野与无限可能
  • C#WPF实战出真汁06--【系统设置】--餐桌类型设置
  • Linux 系统中， LANG 和 LC_ALL变量有什么区别与联系？
  • 文档对比(java-diff-utils)
  • lidar2imu/auto_caliban以及manual_calib安装过程