背景

fmt 库是一个开源的 C++ 格式化库，它提供了一种简洁、安全和高效的方式来进行字符串格式化。
该库的设计目标是提供与 Python 的字符串格式化语法类似的功能，同时保持 C++ 的类型安全性和性能。

下载与安装

官网下载

fmt 官网地址：https://fmt.dev/latest/index.html。
可以从官网或者 GitHub 存储库 (https://github.com/fmtlib/fmt) 下载源代码并手动构建。

使用 vcpkg 安装

fmt 也可以通过 vcpkg 包管工具进行下载安装：

header-only

fmt 库也支持 header-only 方式使用，需要设置 FMT_HEADER_ONLY 宏。

#define FMT_HEADER_ONLY 
#include "fmt/core.h"

hello world

下面是一个使用C++fmt库的简单示例：

#include "fmt/core.h"

int main()
{
	fmt::print("hello {}", "world");
	return 0;
}

运行上述代码，将输出以下结果：

基本格式化语法

参数替换

类似于 printf 的 % 占位符输出，fmt 使用大括号替代参数，且和参数类型无关：

#include "fmt/core.h"

int main()
{
	fmt::print("hello {}", 123);
	return 0;
}

运行上述代码，将输出以下结果：

按位置替换参数

参数位置默认从 0 开始：

#include "fmt/core.h"

int main()
{
	fmt::print("{0}+{1}={2}", 1,2,3);
	return 0;
}

运行上述代码，将输出以下结果：

如果没有指定位置，默认从 0 往后依次替换：

fmt::print("{}+{}={}", 1,2,3);

运行上述代码，将输出以下结果：

参数格式化

可以要按指定格式替换指定位置的参数，用 {位置:格式} 的形式表示替换内容。

指定填充字符

可以指定字符串长度，若长度不够则使用指定的字符进行填充。

右侧填充

使用 < 表示右填充，即文本居左：

fmt::print("{0:*<10}", "hello");

运行结果如下：

左侧填充

使用 > 表示左填充，即文本居右：

fmt::print("{0:*>10}", "hello");

运行结果如下：

两边填充

使用 ^ 表示在两层填充，即文本居中：

fmt::print("{0:*^10}", "hello");

运行结果如下：

默认填充字符

可以指定填充字符时，默认使用空格进行填充：

fmt::print("{0:>10}\n{1:>10}", "hello","world");

运行结果如下：

动态设置字符串长度

字符串的长度也可以用参数指定：

fmt::print("{0:>{1}}\n{2:>10}", "hello",20,"world");

运行结果如下：

按精度格式化

使用 . 表示精度格式化。

格式化字符串长度

使用 .n 表示把字符串的长度格式为 n :

fmt::print("{0:.4}", "abcdefg");

运行结果如下：

格式化浮点数长度

使用 .n 也可以用来表示把浮点数长度为 n :

fmt::print("{0:.3}", 1.23456);

运行结果如下：

格式化小数位数

使用 .nf 表示把浮点数小数位数格式化为 n：

动态设置精度

精度值也可以通过参数动态设置：

fmt::print("{0:.{1}f}", 3.141596,2);

运行结果如下：

数字正负号格式化

用于格式化数字正负符号显示。

仅负数显示符号

使用 - 表示仅负数显示符号：

fmt::print("正数:{0:}\n负数:{1:}", 30,-20);

运行结果如下：

正负数都显示符号：

使用 + 表示正负数字都显示符号：

fmt::print("正数:{0:+}\n负数:{1:+}", 30,-20);

运行结果如下：

数字进制格式化

格式化为10进制

使用 d 表示格式化数字为10进制进行显示：

fmt::print("10进制:{0:d}", 10);

运行结果如下：

格式化为2进制

使用 b 表示格式化数字为2进制进行显示：

fmt::print("2进制:{0:b}", 10);

运行结果如下：

格式化为16进制

使用 x 表示格式化数字为16进制进行显示：

fmt::print("16进制:{0:x}", 10);

运行结果如下：

显示进制符号

在进制符号前加 # 可以在进制格式化时增加符号标记：

fmt::print("16进制:{0:#x}", 10);

运行结果如下：

格式化数字长度

在进制符号前可以增加长度表示，长度不够补 0 ：

fmt::print("{0:08d}", 10);

运行结果如下：

fmt 库使用

格式化内容到字符串

fmt::format 方法会把格式化的结果转为字符串：

#include <iostream>
#include "fmt/core.h"

int main()
{
      auto res = fmt::format("hello {}", "world");
      std::cout << res << std::endl;
      return 0;
}

运行结果如下：

格式化内容到迭代器

fmt::format_to 方法可以把内容格式化到指定的迭代器：

#include "fmt/core.h"

int main()
{
      std::string s;
      fmt::format_to(std::back_inserter(s), "hello {}", "world");
      std::cout << s << std::endl;
      return 0;
}

运行结果如下：

格式化内容到控制台

fmt::print 方法把格式化结果输出到控制台显示：

fmt::print("hello {}", "world");

fmt 库使用进阶

使用参数格式化

命名参数

使用 fmt::arg 可以构建一个命名参数：

fmt::print("{a:*<10}{b:#x}", fmt::arg("a", "hello"), fmt::arg("b", 100));

运行结果如下：

参数列表

fmt::vformat 支持使用参数列表进行格式化：

#include <iostream>
#include "fmt/core.h"

int main()
{
      const fmt::format_args args = fmt::make_format_args(
            fmt::arg("a", "hello"),
            fmt::arg("b", 100)
      );
      const auto s = fmt::vformat("{a:*<10}{b:#x}", args);
      std::cout << s << std::endl;
      return 0;
}

运行结果如下：

同样 fmt::vprint 也支持传入参数列表进行格式化。

自定义类型格式化

特例化 formatter< T > 方式

特例化 fmt::formatter< T > 并且实现其 parse 和 format 方法，可以实现对自定义类型的格式化。

自定义数据类型

使用以下自定义类型作为示例：

struct my_struct
{
      int id;
      std::string name;
};

特例化 fmt::formatter< T >

特例化 fmt::formatter< T > 并实现其 parse 和 format 方法：

template <>
struct fmt::formatter<my_struct>
{
      char presentation = 'f';
      auto parse(fmt::format_parse_context &ctx) -> decltype(ctx.begin())
      {
          auto it = ctx.begin(), end = ctx.end();
          if (it != end && (*it == 'f' || *it == 'i')) presentation = *it++;
          if (it != end && *it != '}') throw "invalid format";
          return it;
      }
      template <typename FormatContext>
      auto format(const my_struct & ms, FormatContext &ctx) const -> decltype(ctx.out())
      {
          return presentation == 'f'
              ? fmt::format_to(ctx.out(), "[my_struct]id={},name= {}", ms.id, ms.name)
              : fmt::format_to(ctx.out(), "[my_struct]id={}", ms.id);
      }
};

使用示例

int main()
{
      my_struct ms{ 0,"hello" };
      fmt::print("my_struct f 格式化:{0:f}\nmy_struct i 格式化:{0:i}", ms);
      return 0;
}

运行结果如下：

继承现有 formatter 类

也可以通过继承现有的 formatter 实现自定义类的格式化：

#include "fmt/core.h"
#include "fmt/format.h"

struct my_struct
{
      int id;
      std::string name;
};
template <>
struct fmt::formatter<my_struct> : formatter<string_view>
{
      auto format(my_struct ms, format_context &ctx) const
      {
            const auto fmt_str = fmt::format("[my_struct]id={}", ms.id);
            const fmt::string_view sv(fmt_str.data(),fmt_str.size());
            return formatter<string_view>::format(sv, ctx);
      }
};
int main()
{
      my_struct ms{ 0,"hello" };
      fmt::print("{}", ms);

      return 0;
}

运行结果如下：

枚举类型格式化

对于枚举类型 fmt 提供了 format_as 接口用于类型转换。

转底层数据类型

使用 fmt::underlying 可以把枚举值转为底层数据类型：

#include "fmt/core.h"
#include "fmt/format.h"

enum class my_enum
{
      red = 0,
      green,
      blue
};
auto format_as(my_enum e)
{
	  return	fmt::underlying(e);
}
int main()
{
      fmt::print("{}", my_enum::green);
      return 0;
}

运行结果如下：

转其他类型

也可以在 format_as 把枚举值转为其他类型：

#include "fmt/core.h"
#include "fmt/format.h"

enum class my_enum
{
      red = 0,
      green,
      blue
};
auto format_as(my_enum e)
{
      switch (e)
      {
      case my_enum::red:
          return "red";
      case my_enum::green:
          return "green";
      case my_enum::blue:
          return "blue";
      }
}
int main()
{
      fmt::print("{}", my_enum::green);
      return 0;
}

运行结果如下：

容器元素格式化

fmt::join 可以定义分隔符对容器中的元素进行格式化：

int main()
{
      std::string s = "1234567";
      fmt::print("{}", fmt::join(s, ", "));
      return 0;
}

运行结果如下：

对于 std::tuple 可以直接进行格式化操作：

#include "fmt/core.h"
#include <fmt/ranges.h>
int main()
{
      std::tuple<int, char> t = { 1, 'a' };
      fmt::print("{}", t);
      return 0;
}

运行结果如下：

微信搜索“编程猿来如此”关注公众号获取更多内容。