{"id":6252,"date":"2021-11-18T21:08:53","date_gmt":"2021-11-18T21:08:53","guid":{"rendered":"https:\/\/www.modernescpp.com\/index.php\/the-type-traits-library-type-checks\/"},"modified":"2023-06-26T09:22:14","modified_gmt":"2023-06-26T09:22:14","slug":"the-type-traits-library-type-checks","status":"publish","type":"post","link":"https:\/\/www.modernescpp.com\/index.php\/the-type-traits-library-type-checks\/","title":{"rendered":"The Type-Traits Library: Type Checks"},"content":{"rendered":"

The type-traits library is part of C++11 and supports type checks, type comparisons, and type modifications at compile time. The library has over 100 functions but grows with each new C++ standard release. Today, I present the type checks.<\/p>\n

<\/p>\n

 \"templatesTypeTraits\"<\/p>\n

Type Checks<\/h2>\n

Each type belongs precisely to one of the fourteen primary type categories.<\/p>\n

Primary Type Categories<\/h3>\n

Here are all of them:<\/p>\n

<\/p>\n

\n
template<\/span> <<\/span>class<\/span> T<\/span>><\/span> struct<\/span> is_void;\r\ntemplate<\/span> <<\/span>class<\/span> T<\/span>><\/span> struct<\/span> is_integral;\r\ntemplate<\/span> <<\/span>class<\/span> T<\/span>><\/span> struct<\/span> is_floating_point;\r\ntemplate<\/span> <<\/span>class<\/span> T<\/span>><\/span> struct<\/span> is_array;\r\ntemplate<\/span> <<\/span>class<\/span> T<\/span>><\/span> struct<\/span> is_pointer;\r\ntemplate<\/span> <<\/span>class<\/span> T<\/span>><\/span> struct<\/span> is_null_pointer;\r\ntemplate<\/span> <<\/span>class<\/span> T<\/span>><\/span> struct<\/span> is_member_object_pointer;\r\ntemplate<\/span> <<\/span>class<\/span> T<\/span>><\/span> struct<\/span> is_member_function_pointer;\r\ntemplate<\/span> <<\/span>class<\/span> T<\/span>><\/span> struct<\/span> is_enum;\r\ntemplate<\/span> <<\/span>class<\/span> T<\/span>><\/span> struct<\/span> is_union;\r\ntemplate<\/span> <<\/span>class<\/span> T<\/span>><\/span> struct<\/span> is_class;\r\ntemplate<\/span> <<\/span>class<\/span> T<\/span>><\/span> struct<\/span> is_function;\r\ntemplate<\/span> <<\/span>class<\/span> T<\/span>><\/span> struct<\/span> is_lvalue_reference;\r\ntemplate<\/span> <<\/span>class<\/span> T<\/span>><\/span> struct<\/span> is_rvalue_reference;\r\n<\/pre>\n<\/div>\n
 <\/p>\n
The following program gives an example of a type fulfilling the check for each one of these primary type categories.<\/p>\n
 <\/p>\n
<\/p>\n
\n
\/\/ primaryTypeCategories.cpp<\/span>

#include <iostream><\/span>\r\n#include <type_traits><\/span>\r\n\r\nstruct<\/span> A {\r\n  int<\/span> a;\r\n  int<\/span> f<\/span>(int<\/span>) { return<\/span> 2011<\/span>; }\r\n};\r\n\r\nenum<\/span> E {\r\n  e=<\/span> 1<\/span>,\r\n};\r\n\r\nunion<\/span> U {\r\n  int<\/span> u;\r\n};\r\n\r\n\r\nint<\/span> main<\/span>() {\r\n\r\n  using<\/span> namespace<\/span> std;\r\n  \r\n  cout <<<\/span>  boolalpha <<<\/span>  '\\n'<\/span>;\r\n\r\n  cout <<<\/span> is_void<<\/span>void<\/span>>::<\/span>value <<<\/span> '\\n'<\/span>;                               \/\/ true                           <\/span>\r\n  cout <<<\/span> is_integral<<\/span>short<\/span>>::<\/span>value <<<\/span> '\\n'<\/span>;                          \/\/ true<\/span>\r\n  cout <<<\/span> is_floating_point<<\/span>double<\/span>>::<\/span>value <<<\/span> '\\n'<\/span>;                   \/\/ true<\/span>\r\n  cout <<<\/span> is_array<<\/span>int<\/span> []>::<\/span>value <<<\/span> '\\n'<\/span>;                            \/\/ true<\/span>\r\n  cout <<<\/span> is_pointer<<\/span>int<\/span>*>::<\/span>value <<<\/span> '\\n'<\/span>;                            \/\/ true<\/span>\r\n  cout <<<\/span> is_null_pointer<<\/span>nullptr_t<\/span>>::<\/span>value <<<\/span> '\\n'<\/span>;                  \/\/ true<\/span>\r\n  cout <<<\/span> is_member_object_pointer<<\/span>int<\/span> A::*>::<\/span>value <<<\/span>  '\\n'<\/span>;         \/\/ true<\/span>\r\n  cout <<<\/span> is_member_function_pointer<<\/span>int<\/span> (A::*<\/span>)(int<\/span>)>::<\/span>value <<<\/span> '\\n'<\/span>; \/\/ true<\/span>\r\n  cout <<<\/span> is_enum<<\/span>E>::<\/span>value <<<\/span> '\\n'<\/span>;                                  \/\/ true<\/span>\r\n  cout <<<\/span> is_union<<\/span>U>::<\/span>value <<<\/span> '\\n'<\/span>;                                 \/\/ true <\/span>\r\n  cout <<<\/span> is_class<<\/span>string>::<\/span>value <<<\/span> '\\n'<\/span>;                            \/\/ true<\/span>\r\n  cout <<<\/span> is_function<<\/span>int<\/span> *<\/span> (double<\/span>)>::<\/span>value <<<\/span> '\\n'<\/span>;                 \/\/ true\t<\/span>\r\n  cout <<<\/span> is_lvalue_reference<<\/span>int<\/span>&>::<\/span>value <<<\/span> '\\n'<\/span>;                   \/\/ true<\/span>\r\n  cout <<<\/span> is_rvalue_reference<<\/span>int<\/span>&&>::<\/span>value <<<\/span> '\\n'<\/span>;                  \/\/ true<\/span>\r\n  \r\n}\r\n<\/pre>\n<\/div>\n
 <\/p>\n<\/p>\n
How Does this Magic Work?<\/h4>\n
This technique is based on templates and template specialization, a few conventions, and much typing. I wrote a simplified version of the function template std::integral. std::integral<\/code> to check if a given type is an integral type. I ignore const<\/code> or volatile<\/code> qualifiers.<\/p>\n
<\/p>\n
\n
\/\/ integral.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\n#include <type_traits><\/span>\r\n\r\nnamespace<\/span> rgr{\r\n\r\n  template<\/span><<\/span>class<\/span> T<\/span>, T v><\/span>\r\n  struct<\/span> integral_constant {\r\n      static<\/span> constexpr T value =<\/span> v;\r\n      typedef<\/span> T value_type;\r\n      typedef<\/span> integral_constant type;\r\n      constexpr operator<\/span> value_type() const<\/span> noexcept { return<\/span> value; }\r\n      constexpr value_type operator<\/span>()() const<\/span> noexcept { return<\/span> value; } \/\/since c++14<\/span>\r\n  };\r\n\r\n  typedef<\/span> integral_constant<<\/span>bool<\/span>, true<\/span>><\/span> true_type;                       \/\/ (2)<\/span>\r\n  typedef<\/span> integral_constant<<\/span>bool<\/span>, false<\/span>><\/span> false_type;\r\n\r\n  template<\/span> <<\/span>class<\/span> T<\/span>><\/span>\r\n  struct<\/span> is_integral :<\/span> public<\/span> false_type{};\r\n\r\n  template<\/span> <><\/span>\r\n  struct<\/span> is_integral<<\/span>bool<\/span>><\/span> :<\/span> public<\/span> true_type{};\r\n\r\n  template<\/span> <><\/span>\r\n  struct<\/span> is_integral<<\/span>char<\/span>><\/span> :<\/span> public<\/span> true_type{};\r\n\r\n  template<\/span> <><\/span>\r\n  struct<\/span> is_integral<<\/span>signed<\/span> char<\/span>><\/span> :<\/span> public<\/span> true_type{};\r\n\r\n  template<\/span> <><\/span>\r\n  struct<\/span> is_integral<<\/span>unsigned<\/span> char<\/span>><\/span> :<\/span> public<\/span> true_type{};\r\n\r\n  template<\/span> <><\/span>\r\n  struct<\/span> is_integral<<\/span>wchar_t<\/span>><\/span> :<\/span> public<\/span> true_type{};\r\n\r\n  template<\/span> <><\/span>\r\n  struct<\/span> is_integral<<\/span>short<\/span>><\/span> :<\/span> public<\/span> true_type{};\r\n\r\n  template<\/span> <><\/span>\r\n  struct<\/span> is_integral<<\/span>int<\/span>><\/span> :<\/span> public<\/span> true_type{};                              \/\/ (3)<\/span>\r\n\r\n  template<\/span> <><\/span>\r\n  struct<\/span> is_integral<<\/span>long<\/span>><\/span> :<\/span> public<\/span> true_type{};\r\n\r\n  template<\/span> <><\/span>\r\n  struct<\/span> is_integral<<\/span>long<\/span> long<\/span>><\/span> :<\/span> public<\/span> true_type{};\r\n\r\n  template<\/span> <><\/span>\r\n  struct<\/span> is_integral<<\/span>unsigned<\/span> short<\/span>><\/span> :<\/span> public<\/span> true_type{};\r\n\r\n  template<\/span> <><\/span>\r\n  struct<\/span> is_integral<<\/span>unsigned<\/span> int<\/span>><\/span> :<\/span> public<\/span> true_type{};\r\n\r\n  template<\/span> <><\/span>\r\n  struct<\/span> is_integral<<\/span>unsigned<\/span> long<\/span>><\/span> :<\/span> public<\/span> true_type{};\r\n\r\n  template<\/span> <><\/span>\r\n  struct<\/span> is_integral<<\/span>unsigned<\/span> long<\/span> long<\/span>><\/span> :<\/span> public<\/span> true_type{};\r\n  \r\n}\r\n\r\nint<\/span> main(){\r\n  \r\n  std::<\/span>cout <<<\/span> std::<\/span>boolalpha <<<\/span> '\\n'<\/span>;\r\n  \r\n  std::<\/span>cout <<<\/span> \"std::is_integral<int>::value: \"<\/span> <<<\/span> std::<\/span>is_integral<<\/span>int<\/span>>::<\/span>value <<<\/span> '\\n'<\/span>;\r\n  std::<\/span>cout <<<\/span> \"rgr::is_integral<int>::value: \"<\/span> <<<\/span> rgr::<\/span>is_integral<<\/span>int<\/span>>::<\/span>value <<<\/span> '\\n'<\/span>;    \/\/ (1)<\/span>\r\n  \r\n  std::<\/span>cout <<<\/span> \"std::is_integral<double>::value: \"<\/span> <<<\/span> std::<\/span>is_integral<<\/span>double<\/span>>::<\/span>value <<<\/span> '\\n'<\/span>;\r\n  std::<\/span>cout <<<\/span> \"rgr::is_integral<double>::value: \"<\/span> <<<\/span> rgr::<\/span>is_integral<<\/span>double<\/span>>::<\/span>value <<<\/span> '\\n'<\/span>;\r\n  \r\n  std::<\/span>cout <<<\/span> '\\n'<\/span>;\r\n  \r\n  std::<\/span>cout <<<\/span> \"std::true_type::value: \"<\/span> <<<\/span> std::<\/span>true_type::<\/span>value <<<\/span> '\\n'<\/span>;\r\n  std::<\/span>cout <<<\/span> \"rgr::true_type::value: \"<\/span> <<<\/span> rgr::<\/span>true_type::<\/span>value <<<\/span> '\\n'<\/span>;\r\n  \r\n  std::<\/span>cout <<<\/span> \"std::false_type::value: \"<\/span> <<<\/span> std::<\/span>false_type::<\/span>value <<<\/span> '\\n'<\/span>;\r\n  std::<\/span>cout <<<\/span> \"rgr::false_type::value: \"<\/span> <<<\/span> rgr::<\/span>false_type::<\/span>value <<<\/span> '\\n'<\/span>;\r\n  \r\n  std::<\/span>cout <<<\/span> '\\n'<\/span>;\r\n  \r\n  std::<\/span>cout <<<\/span> \"std::integral_constant<bool, true>::value: \"<\/span> <<<\/span> std::<\/span>integral_constant<<\/span>bool<\/span>, true<\/span>>::<\/span>value <<<\/span> '\\n'<\/span>;\r\n  std::<\/span>cout <<<\/span> \"rgr::integral_constant<bool, true>::value: \"<\/span> <<<\/span> rgr::<\/span>integral_constant<<\/span>bool<\/span>, true<\/span>>::<\/span>value <<<\/span> '\\n'<\/span>;\r\n  \r\n  std::<\/span>cout <<<\/span> \"std::integral_constant<bool, false>::value: \"<\/span> <<<\/span> std::<\/span>integral_constant<<\/span>bool<\/span>, false<\/span>>::<\/span>value <<<\/span> '\\n'<\/span>;\r\n  std::<\/span>cout <<<\/span> \"rgr::integral_constant<bool, false>::value: \"<\/span> <<<\/span> rgr::<\/span>integral_constant<<\/span>bool<\/span>, false<\/span>>::<\/span>value <<<\/span> '\\n'<\/span>;  \r\n  \r\n  std::<\/span>cout <<<\/span> '\\n'<\/span>;\r\n  \r\n}\r\n<\/pre>\n<\/div>\n
 <\/p>\n
I use in my implementation the namespace rgr<\/code> and compare it with type-traits functions in the namespace std<\/code>. The invocation of the function template rgr::is_integral<int>::value<\/code> (1) causes the invocation of the expression rgr::true_type::value<\/code> (2) because integral<int><\/code> is derived from true_type<\/code> (3). rgr::true_type::value<\/code> is an alias for rgr::integral_constant<bool, true>::value<\/code> (2). I use in the example the static constexpr<\/code> value of the class integral_constant<\/code>. integral_constant<\/code> is the base class of the type-traits functions.<\/p>\n
For completeness, here is the output of the program. My implementation gives the same results, such as functions from the type-traits library.<\/p>\n
 \"integral\"<\/p>\n
I use in my function templates rgr::is_integra<\/code>l ::value<\/code> as return. You maybe remember this convention from my previous post, “Template Metaprogramming – How it works<\/a>“? Right!  My function templates rgr::is_integral<\/code> are metafunctions and use template metaprogramming’s naming conventions. Since C++17, there is, for conventions, a helper class for ::value<\/code>. This helper class is based on variable templates.<\/p>\n
<\/p>\n
\n
template<\/span><<\/span> class<\/span> T<\/span> ><\/span>\r\ninline<\/span> constexpr bool<\/span> is_integral_v =<\/span> is_integral<<\/span>T>::<\/span>value\r\n<\/pre>\n<\/div>\n
 <\/p>\n
Variable templates are essentially a family of variables. Due to this helper class, you can write std::integral_v<T><\/code> instead of std::integral<T>::value<\/code>.  This shortened notation works for all function templates of the type traits library.<\/p>\n
Composite type categories are then assembled from those primary type categories.<\/p>\n
Composite Type Categories<\/h3>\n
There are seven composite type categories. The following table shows them.<\/p>\n
\"CompositeTypeCategories\"<\/p>\n
In additionally, to the primary type categories and the composite type categories, the type traits library provides type properties and type property queries. For completeness, here are they.<\/p>\n
Type Properties<\/h3>\n
<\/p>\n
\n
template<\/span> <<\/span>class<\/span> T<\/span>><\/span> struct<\/span> is_const;\r\ntemplate<\/span> <<\/span>class<\/span> T<\/span>><\/span> struct<\/span> is_volatile;\r\ntemplate<\/span> <<\/span>class<\/span> T<\/span>><\/span> struct<\/span> is_trivial;\r\ntemplate<\/span> <<\/span>class<\/span> T<\/span>><\/span> struct<\/span> is_trivially_copyable;\r\ntemplate<\/span> <<\/span>class<\/span> T<\/span>><\/span> struct<\/span> is_standard_layout;\r\ntemplate<\/span> <<\/span>class<\/span> T<\/span>><\/span> struct<\/span> is_empty;\r\ntemplate<\/span> <<\/span>class<\/span> T<\/span>><\/span> struct<\/span> is_polymorphic;\r\ntemplate<\/span> <<\/span>class<\/span> T<\/span>><\/span> struct<\/span> is_abstract;\r\ntemplate<\/span> <<\/span>class<\/span> T<\/span>><\/span> struct<\/span> is_final;\r\ntemplate<\/span> <<\/span>class<\/span> T<\/span>><\/span> struct<\/span> is_aggregate;\r\n \r\ntemplate<\/span> <<\/span>class<\/span> T<\/span>><\/span> struct<\/span> is_signed;\r\ntemplate<\/span> <<\/span>class<\/span> T<\/span>><\/span> struct<\/span> is_unsigned;\r\ntemplate<\/span> <<\/span>class<\/span> T<\/span>><\/span> struct<\/span> is_bounded_array;\r\ntemplate<\/span> <<\/span>class<\/span> T<\/span>><\/span> struct<\/span> is_unbounded_array;\r\ntemplate<\/span> <<\/span>class<\/span> T<\/span>><\/span> struct<\/span> is_scoped_enum;\r\n \r\ntemplate<\/span> <<\/span>class<\/span> T<\/span>, class... Args><\/span> struct<\/span> is_constructible;\r\ntemplate<\/span> <<\/span>class<\/span> T<\/span>><\/span> struct<\/span> is_default_constructible;\r\ntemplate<\/span> <<\/span>class<\/span> T<\/span>><\/span> struct<\/span> is_copy_constructible;\r\ntemplate<\/span> <<\/span>class<\/span> T<\/span>><\/span> struct<\/span> is_move_constructible;\r\n \r\ntemplate<\/span> <<\/span>class<\/span> T<\/span>, class<\/span> U<\/span>><\/span> struct<\/span> is_assignable;\r\ntemplate<\/span> <<\/span>class<\/span> T<\/span>><\/span> struct<\/span> is_copy_assignable;\r\ntemplate<\/span> <<\/span>class<\/span> T<\/span>><\/span> struct<\/span> is_move_assignable;\r\n \r\ntemplate<\/span> <<\/span>class<\/span> T<\/span>, class<\/span> U<\/span>><\/span> struct<\/span> is_swappable_with;\r\ntemplate<\/span> <<\/span>class<\/span> T<\/span>><\/span> struct<\/span> is_swappable;\r\n \r\ntemplate<\/span> <<\/span>class<\/span> T<\/span>><\/span> struct<\/span> is_destructible;\r\n \r\ntemplate<\/span> <<\/span>class<\/span> T<\/span>, class... Args><\/span> struct<\/span> is_trivially_constructible;\r\ntemplate<\/span> <<\/span>class<\/span> T<\/span>><\/span> struct<\/span> is_trivially_default_constructible;\r\ntemplate<\/span> <<\/span>class<\/span> T<\/span>><\/span> struct<\/span> is_trivially_copy_constructible;\r\ntemplate<\/span> <<\/span>class<\/span> T<\/span>><\/span> struct<\/span> is_trivially_move_constructible;\r\n \r\ntemplate<\/span> <<\/span>class<\/span> T<\/span>, class<\/span> U<\/span>><\/span> struct<\/span> is_trivially_assignable;\r\ntemplate<\/span> <<\/span>class<\/span> T<\/span>><\/span> struct<\/span> is_trivially_copy_assignable;\r\ntemplate<\/span> <<\/span>class<\/span> T<\/span>><\/span> struct<\/span> is_trivially_move_assignable;\r\ntemplate<\/span> <<\/span>class<\/span> T<\/span>><\/span> struct<\/span> is_trivially_destructible;\r\n \r\ntemplate<\/span> <<\/span>class<\/span> T<\/span>, class... Args><\/span> struct<\/span> is_nothrow_constructible;\r\ntemplate<\/span> <<\/span>class<\/span> T<\/span>><\/span> struct<\/span> is_nothrow_default_constructible;\r\ntemplate<\/span> <<\/span>class<\/span> T<\/span>><\/span> struct<\/span> is_nothrow_copy_constructible;\r\ntemplate<\/span> <<\/span>class<\/span> T<\/span>><\/span> struct<\/span> is_nothrow_move_constructible;\r\n \r\ntemplate<\/span> <<\/span>class<\/span> T<\/span>, class<\/span> U<\/span>><\/span> struct<\/span> is_nothrow_assignable;\r\ntemplate<\/span> <<\/span>class<\/span> T<\/span>><\/span> struct<\/span> is_nothrow_copy_assignable;\r\ntemplate<\/span> <<\/span>class<\/span> T<\/span>><\/span> struct<\/span> is_nothrow_move_assignable;\r\n \r\ntemplate<\/span> <<\/span>class<\/span> T<\/span>, class<\/span> U<\/span>><\/span> struct<\/span> is_nothrow_swappable_with;\r\ntemplate<\/span> <<\/span>class<\/span> T<\/span>><\/span> struct<\/span> is_nothrow_swappable;\r\n \r\ntemplate<\/span> <<\/span>class<\/span> T<\/span>><\/span> struct<\/span> is_nothrow_destructible;\r\n \r\ntemplate<\/span> <<\/span>class<\/span> T<\/span>><\/span> struct<\/span> has_virtual_destructor;\r\n \r\ntemplate<\/span> <<\/span>class<\/span> T<\/span>><\/span> struct<\/span> has_unique_object_representations;\r\n<\/pre>\n<\/div>\n
 <\/p>\n
Many of the meta-functions like std::is_trivially_copyable<\/code> have trivially in their name. That means that the compiler provides this method. Requesting a method from the compiler with the keyword default<\/code> is also trivial.<\/p>\n
Type Property Queries<\/h3>\n
<\/p>\n
\n
template<\/span> <<\/span>class<\/span> T<\/span>><\/span> struct<\/span> alignment_of;\r\ntemplate<\/span> <<\/span>class<\/span> T<\/span>><\/span> struct<\/span> rank;\r\ntemplate<\/span> <<\/span>class<\/span> T<\/span>, unsigned<\/span> I =<\/span> 0<\/span>><\/span> struct<\/span> extent;\r\n<\/pre>\n<\/div>\n
 <\/p>\n
What’s next?<\/h2>\n
Did you notice the function std::is_same<\/code> in the composite type category std::is_fundamenta<\/code>l? std::is_same<\/code> is it special because it provides type comparisons at compile time? I will write about type comparison at compile time in my next post.<\/p>\n
 <\/p>\n<\/p>\n
 <\/p>\n
 <\/p>\n","protected":false},"excerpt":{"rendered":"
The type-traits library is part of C++11 and supports type checks, type comparisons, and type modifications at compile time. The library has over 100 functions but grows with each new C++ standard release. Today, I present the type checks.<\/p>\n","protected":false},"author":21,"featured_media":6251,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[376],"tags":[419],"class_list":["post-6252","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-templates","tag-type-traits"],"_links":{"self":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/6252","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/users\/21"}],"replies":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/comments?post=6252"}],"version-history":[{"count":1,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/6252\/revisions"}],"predecessor-version":[{"id":6691,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/6252\/revisions\/6691"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media\/6251"}],"wp:attachment":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media?parent=6252"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/categories?post=6252"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/tags?post=6252"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}