<!doctype html><html lang=en-US dir=ltr class="docs-wrapper plugin-docs plugin-id-default docs-version-1.3.0 docs-doc-page docs-doc-id-guide/cpp/serialization_index" data-has-hydrated=false><head><meta charset=UTF-8><meta name=generator content="Docusaurus v3.10.1"><title data-rh=true>C++ Serialization Guide | Apache Fory™</title><meta data-rh=true name=viewport content="width=device-width, initial-scale=1.0"/><meta data-rh=true property=og:url content=https://fory.apache.org/docs/guide/cpp/ /><meta data-rh=true property=og:locale content=en_US /><meta data-rh=true property=og:locale:alternate content=zh_CN /><meta data-rh=true name=docusaurus_locale content=en-US /><meta data-rh=true name=docsearch:language content=en-US /><meta data-rh=true http-equiv=Content-Security-Policy content="frame-src 'self' https://ghbtns.com/;"/><meta data-rh=true property=og:image content=https://fory.apache.org/img/logo.png /><meta data-rh=true property=og:image:width content=1500 /><meta data-rh=true property=og:image:height content=1500 /><meta data-rh=true name=twitter:card content=summary_large_image /><meta data-rh=true name=twitter:image content=https://fory.apache.org/img/logo.png /><meta data-rh=true name=docusaurus_version content=1.3.0 /><meta data-rh=true name=docusaurus_tag content=docs-default-1.3.0 /><meta data-rh=true name=docsearch:version content=1.3.0 /><meta data-rh=true name=docsearch:docusaurus_tag content=docs-default-1.3.0 /><meta data-rh=true property=og:title content="C++ Serialization Guide | Apache Fory™"/><meta data-rh=true name=description content="Apache Fory™ is a blazing fast multi-language serialization framework powered by JIT compilation and zero-copy techniques, providing up to ultra-fast performance while maintaining ease of use and safety."/><meta data-rh=true property=og:description content="Apache Fory™ is a blazing fast multi-language serialization framework powered by JIT compilation and zero-copy techniques, providing up to ultra-fast performance while maintaining ease of use and safety."/><link data-rh=true rel=icon href=/img/favicon.ico /><link data-rh=true rel=canonical href=https://fory.apache.org/docs/guide/cpp/ /><link data-rh=true rel=alternate href=https://fory.apache.org/docs/guide/cpp/ hreflang=en-US /><link data-rh=true rel=alternate href=https://fory.apache.org/zh-CN/docs/guide/cpp/ hreflang=zh-CN /><link data-rh=true rel=alternate href=https://fory.apache.org/docs/guide/cpp/ hreflang=x-default /><script data-rh=true type=application/ld+json>{"@context":"https://schema.org","@type":"BreadcrumbList","itemListElement":[{"@type":"ListItem","item":"https://fory.apache.org/docs/guide/cpp/","name":"C++","position":1}]}</script><link rel=alternate type=application/rss+xml href=/blog/rss.xml title="Apache Fory™ RSS Feed"><link rel=alternate type=application/atom+xml href=/blog/atom.xml title="Apache Fory™ Atom Feed"><script type=text/javascript>"fury.apache.org"===window.location.host&&(window.location.href="https://fory.apache.org"),function(){for(var o=window.location.pathname,a=["guide","introduction","start"],n=0;n<a.length;n++){var t=a[n],i=RegExp("^((?:/[a-z]{2}-[A-Z]{2})?/docs(?:/(?:next|[0-9]+.[0-9]+))?)/docs/"+t+"(/.*)?$"),c=o.match(i);if(c){var r=c[1]+"/"+t+(c[2]||"");window.location.replace(r+window.location.search+window.location.hash);return}}}()</script><link rel=stylesheet href=/assets/css/styles.3a1edaa1.css /><script src=/assets/js/runtime~main.1599a3d2.js defer></script><script src=/assets/js/main.be4bfea5.js defer></script></head><body><svg style="display: none;"><defs>
<symbol id=theme-svg-external-link viewBox="0 0 24 24"><path fill=currentColor d="M21 13v10h-21v-19h12v2h-10v15h17v-8h2zm3-12h-10.988l4.035 4-6.977 7.07 2.828 2.828 6.977-7.07 4.125 4.172v-11z"/></symbol>
</defs></svg>
<script>!function(){var t=function(){try{return new URLSearchParams(window.location.search).get("docusaurus-theme")}catch(t){}}()||function(){try{return window.localStorage.getItem("theme")}catch(t){}}();document.documentElement.setAttribute("data-theme",t||"light"),document.documentElement.setAttribute("data-theme-choice",t||"light")}(),function(){try{for(var[t,e]of new URLSearchParams(window.location.search).entries())if(t.startsWith("docusaurus-data-")){var a=t.replace("docusaurus-data-","data-");document.documentElement.setAttribute(a,e)}}catch(t){}}()</script><div id=__docusaurus><div role=region aria-label="Skip to main content"><a class=skipToContent_fXgn href=#__docusaurus_skipToContent_fallback>Skip to main content</a></div><nav aria-label=Main class="theme-layout-navbar navbar navbar--fixed-top"><div class=navbar__inner><div class="theme-layout-navbar-left navbar__items"><button aria-label="Toggle navigation bar" aria-expanded=false class="navbar__toggle clean-btn" type=button><svg width=30 height=30 viewBox="0 0 30 30" aria-hidden=true><path stroke=currentColor stroke-linecap=round stroke-miterlimit=10 stroke-width=2 d="M4 7h22M4 15h22M4 23h22"/></svg></button><a class=navbar__brand href=/><div class=navbar__logo><img src=/img/fory-logo-light.png alt="Apache Fory™ Logo" class="themedComponent_mlkZ themedComponent--light_NVdE"/><img src=/img/fory-logo-dark.png alt="Apache Fory™ Logo" class="themedComponent_mlkZ themedComponent--dark_xIcU"/></div><b class="navbar__title text--truncate"></b></a><a aria-current=page class="navbar__item navbar__link navbar__link--active" href=/docs/introduction/overview>Docs</a><a class="navbar__item navbar__link" href=/docs/specification/xlang_serialization_spec>Specification</a><a class="navbar__item navbar__link" href=/docs/community/>Community</a><a class="navbar__item navbar__link" href=/user>Users</a><a class="navbar__item navbar__link" href=/download>Download</a><a class="navbar__item navbar__link" href=/blog>Blog</a></div><div class="theme-layout-navbar-right navbar__items navbar__items--right"><div class="navbar__item dropdown dropdown--hoverable dropdown--right"><a href=# aria-haspopup=true aria-expanded=false role=button class=navbar__link>ASF</a><ul class=dropdown__menu><li><a href=https://www.apache.org/ target=_blank rel="noopener noreferrer" class=dropdown__link>Foundation</a><li><a href=https://www.apache.org/licenses/ target=_blank rel="noopener noreferrer" class=dropdown__link>License</a><li><a href=https://www.apache.org/events/current-event.html target=_blank rel="noopener noreferrer" class=dropdown__link>Events</a><li><a href=https://privacy.apache.org/policies/privacy-policy-public.html target=_blank rel="noopener noreferrer" class=dropdown__link>Privacy</a><li><a href=https://www.apache.org/security/ target=_blank rel="noopener noreferrer" class=dropdown__link>Security</a><li><a href=https://www.apache.org/foundation/sponsorship.html target=_blank rel="noopener noreferrer" class=dropdown__link>Sponsorship</a><li><a href=https://www.apache.org/foundation/thanks.html target=_blank rel="noopener noreferrer" class=dropdown__link>Thanks</a><li><a href=https://www.apache.org/foundation/policies/conduct.html target=_blank rel="noopener noreferrer" class=dropdown__link>Code of Conduct</a></ul></div><div class="navbar__item dropdown dropdown--hoverable dropdown--right"><a class=navbar__link aria-haspopup=true aria-expanded=false role=button href=/docs/guide/cpp/>1.3.0</a><ul class=dropdown__menu><li><a class=dropdown__link href=/docs/next/guide/cpp/>dev</a><li><a aria-current=page class="dropdown__link dropdown__link--active" href=/docs/guide/cpp/>1.3.0</a><li><a class=dropdown__link href=/docs/1.2.0/guide/cpp/>1.2.0</a><li><a class=dropdown__link href=/docs/1.1.0/guide/cpp/>1.1.0</a><li><a class=dropdown__link href=/docs/1.0.0/guide/cpp/>1.0.0</a><li><a class=dropdown__link href=/docs/0.17/guide/cpp/>0.17</a><li><a class=dropdown__link href=/docs/0.16/guide/cpp/>0.16</a><li><a class=dropdown__link href=/docs/0.15/guide/cpp/>0.15</a><li><a class=dropdown__link href=/docs/0.14/guide/cpp/>0.14</a><li><a class=dropdown__link href=/docs/0.13/introduction/overview>0.13</a><li><a class=dropdown__link href=/docs/0.12/introduction/overview>0.12</a><li><a class=dropdown__link href=/docs/0.11/introduction/overview>0.11</a><li><a class=dropdown__link href=/docs/0.10/introduction/overview>0.10</a></ul></div><a href=https://github.com/apache/fory target=_blank rel="noopener noreferrer" class="navbar__item navbar__link header-github-link" aria-label="GitHub repository"></a><div class="navbar__item dropdown dropdown--hoverable dropdown--right"><a href=# aria-haspopup=true aria-expanded=false role=button class=navbar__link><svg viewBox="0 0 24 24" width=20 height=20 aria-hidden=true class=iconLanguage_nlXk><path fill=currentColor d="M12.87 15.07l-2.54-2.51.03-.03c1.74-1.94 2.98-4.17 3.71-6.53H17V4h-7V2H8v2H1v1.99h11.17C11.5 7.92 10.44 9.75 9 11.35 8.07 10.32 7.3 9.19 6.69 8h-2c.73 1.63 1.73 3.17 2.98 4.56l-5.09 5.02L4 19l5-5 3.11 3.11.76-2.04zM18.5 10h-2L12 22h2l1.12-3h4.75L21 22h2l-4.5-12zm-2.62 7l1.62-4.33L19.12 17h-3.24z"/></svg>English</a><ul class=dropdown__menu><li><a href=/docs/guide/cpp/ target=_self rel="noopener noreferrer" class="dropdown__link dropdown__link--active" lang=en-US>English</a><li><a href=/zh-CN/docs/guide/cpp/ target=_self rel="noopener noreferrer" class=dropdown__link lang=zh-CN>简体中文</a></ul></div><div class="toggle_vylO colorModeToggle_DEke"><button class="clean-btn toggleButton_gllP toggleButtonDisabled_aARS" type=button disabled title="system mode" aria-label="Switch between dark and light mode (currently system mode)"><svg viewBox="0 0 24 24" width=24 height=24 aria-hidden=true class="toggleIcon_g3eP lightToggleIcon_pyhR"><path fill=currentColor d="M12,9c1.65,0,3,1.35,3,3s-1.35,3-3,3s-3-1.35-3-3S10.35,9,12,9 M12,7c-2.76,0-5,2.24-5,5s2.24,5,5,5s5-2.24,5-5 S14.76,7,12,7L12,7z M2,13l2,0c0.55,0,1-0.45,1-1s-0.45-1-1-1l-2,0c-0.55,0-1,0.45-1,1S1.45,13,2,13z M20,13l2,0c0.55,0,1-0.45,1-1 s-0.45-1-1-1l-2,0c-0.55,0-1,0.45-1,1S19.45,13,20,13z M11,2v2c0,0.55,0.45,1,1,1s1-0.45,1-1V2c0-0.55-0.45-1-1-1S11,1.45,11,2z M11,20v2c0,0.55,0.45,1,1,1s1-0.45,1-1v-2c0-0.55-0.45-1-1-1C11.45,19,11,19.45,11,20z M5.99,4.58c-0.39-0.39-1.03-0.39-1.41,0 c-0.39,0.39-0.39,1.03,0,1.41l1.06,1.06c0.39,0.39,1.03,0.39,1.41,0s0.39-1.03,0-1.41L5.99,4.58z M18.36,16.95 c-0.39-0.39-1.03-0.39-1.41,0c-0.39,0.39-0.39,1.03,0,1.41l1.06,1.06c0.39,0.39,1.03,0.39,1.41,0c0.39-0.39,0.39-1.03,0-1.41 L18.36,16.95z M19.42,5.99c0.39-0.39,0.39-1.03,0-1.41c-0.39-0.39-1.03-0.39-1.41,0l-1.06,1.06c-0.39,0.39-0.39,1.03,0,1.41 s1.03,0.39,1.41,0L19.42,5.99z M7.05,18.36c0.39-0.39,0.39-1.03,0-1.41c-0.39-0.39-1.03-0.39-1.41,0l-1.06,1.06 c-0.39,0.39-0.39,1.03,0,1.41s1.03,0.39,1.41,0L7.05,18.36z"/></svg><svg viewBox="0 0 24 24" width=24 height=24 aria-hidden=true class="toggleIcon_g3eP darkToggleIcon_wfgR"><path fill=currentColor d="M9.37,5.51C9.19,6.15,9.1,6.82,9.1,7.5c0,4.08,3.32,7.4,7.4,7.4c0.68,0,1.35-0.09,1.99-0.27C17.45,17.19,14.93,19,12,19 c-3.86,0-7-3.14-7-7C5,9.07,6.81,6.55,9.37,5.51z M12,3c-4.97,0-9,4.03-9,9s4.03,9,9,9s9-4.03,9-9c0-0.46-0.04-0.92-0.1-1.36 c-0.98,1.37-2.58,2.26-4.4,2.26c-2.98,0-5.4-2.42-5.4-5.4c0-1.81,0.89-3.42,2.26-4.4C12.92,3.04,12.46,3,12,3L12,3z"/></svg><svg viewBox="0 0 24 24" width=24 height=24 aria-hidden=true class="toggleIcon_g3eP systemToggleIcon_QzmC"><path fill=currentColor d="m12 21c4.971 0 9-4.029 9-9s-4.029-9-9-9-9 4.029-9 9 4.029 9 9 9zm4.95-13.95c1.313 1.313 2.05 3.093 2.05 4.95s-0.738 3.637-2.05 4.95c-1.313 1.313-3.093 2.05-4.95 2.05v-14c1.857 0 3.637 0.737 4.95 2.05z"/></svg></button></div><div class=navbarSearchContainer_Bca1><div class=navbar__search><span aria-label="expand searchbar" role=button class=search-icon tabindex=0></span><input id=search_input_react type=search placeholder=Loading... aria-label=Search class="navbar__search-input search-bar" disabled/></div></div></div></div><div role=presentation class=navbar-sidebar__backdrop></div></nav><div id=__docusaurus_skipToContent_fallback class="theme-layout-main main-wrapper mainWrapper_z2l0"><div class=docsWrapper_hBAB><button aria-label="Scroll back to top" class="clean-btn theme-back-to-top-button backToTopButton_sjWU" type=button></button><div class=docRoot_UBD9><aside class="theme-doc-sidebar-container docSidebarContainer_YfHR"><div class=sidebarViewport_aRkj><div class=sidebar_njMd><nav aria-label="Docs sidebar" class="menu thin-scrollbar menu_SIkG"><ul class="theme-doc-sidebar-menu menu__list"><li class="theme-doc-sidebar-item-category theme-doc-sidebar-item-category-level-1 menu__list-item"><div class=menu__list-item-collapsible><a class="categoryLink_byQd menu__link menu__link--sublist menu__link--sublist-caret" role=button aria-expanded=true href=/docs/introduction/overview><span title=Introduction class=categoryLinkLabel_W154>Introduction</span></a></div><ul class=menu__list><li class="theme-doc-sidebar-item-link theme-doc-sidebar-item-link-level-2 menu__list-item"><a class=menu__link tabindex=0 href=/docs/introduction/overview><span title=Overview class=linkLabel_WmDU>Overview</span></a><li class="theme-doc-sidebar-item-link theme-doc-sidebar-item-link-level-2 menu__list-item"><a class=menu__link tabindex=0 href=/docs/introduction/features><span title=Features class=linkLabel_WmDU>Features</span></a><li class="theme-doc-sidebar-item-link theme-doc-sidebar-item-link-level-2 menu__list-item"><a class=menu__link tabindex=0 href=/docs/introduction/benchmark><span title=Benchmark class=linkLabel_WmDU>Benchmark</span></a></ul><li class="theme-doc-sidebar-item-category theme-doc-sidebar-item-category-level-1 menu__list-item"><div class=menu__list-item-collapsible><a class="categoryLink_byQd menu__link menu__link--sublist menu__link--sublist-caret" role=button aria-expanded=true href=/docs/start/install><span title=Start class=categoryLinkLabel_W154>Start</span></a></div><ul class=menu__list><li class="theme-doc-sidebar-item-link theme-doc-sidebar-item-link-level-2 menu__list-item"><a class=menu__link tabindex=0 href=/docs/start/install><span title=Install class=linkLabel_WmDU>Install</span></a><li class="theme-doc-sidebar-item-link theme-doc-sidebar-item-link-level-2 menu__list-item"><a class=menu__link tabindex=0 href=/docs/start/usage><span title=Usage class=linkLabel_WmDU>Usage</span></a></ul><li class="theme-doc-sidebar-item-category theme-doc-sidebar-item-category-level-1 menu__list-item menu__list-item--collapsed"><div class=menu__list-item-collapsible><a class="categoryLink_byQd menu__link menu__link--sublist menu__link--sublist-caret" role=button aria-expanded=false href=/docs/compiler/><span title="Schema IDL & Compiler" class=categoryLinkLabel_W154>Schema IDL & Compiler</span></a></div><li class="theme-doc-sidebar-item-category theme-doc-sidebar-item-category-level-1 menu__list-item"><div class=menu__list-item-collapsible><a class="categoryLink_byQd menu__link menu__link--sublist menu__link--sublist-caret menu__link--active" role=button aria-expanded=true href=/docs/guide/java/><span title=Guide class=categoryLinkLabel_W154>Guide</span></a></div><ul class=menu__list><li class="theme-doc-sidebar-item-category theme-doc-sidebar-item-category-level-2 menu__list-item menu__list-item--collapsed"><div class=menu__list-item-collapsible><a class="categoryLink_byQd menu__link menu__link--sublist" tabindex=0 href=/docs/guide/java/><span title=Java class=categoryLinkLabel_W154>Java</span></a><button aria-label="Expand sidebar category 'Java'" aria-expanded=false type=button class="clean-btn menu__caret"></button></div><li class="theme-doc-sidebar-item-category theme-doc-sidebar-item-category-level-2 menu__list-item menu__list-item--collapsed"><div class=menu__list-item-collapsible><a class="categoryLink_byQd menu__link menu__link--sublist" tabindex=0 href=/docs/guide/python/><span title=Python class=categoryLinkLabel_W154>Python</span></a><button aria-label="Expand sidebar category 'Python'" aria-expanded=false type=button class="clean-btn menu__caret"></button></div><li class="theme-doc-sidebar-item-category theme-doc-sidebar-item-category-level-2 menu__list-item menu__list-item--collapsed"><div class=menu__list-item-collapsible><a class="categoryLink_byQd menu__link menu__link--sublist" tabindex=0 href=/docs/guide/rust/><span title=Rust class=categoryLinkLabel_W154>Rust</span></a><button aria-label="Expand sidebar category 'Rust'" aria-expanded=false type=button class="clean-btn menu__caret"></button></div><li class="theme-doc-sidebar-item-category theme-doc-sidebar-item-category-level-2 menu__list-item"><div class="menu__list-item-collapsible menu__list-item-collapsible--active"><a class="categoryLink_byQd menu__link menu__link--sublist menu__link--active" aria-current=page tabindex=0 href=/docs/guide/cpp/><span title=C++ class=categoryLinkLabel_W154>C++</span></a><button aria-label="Collapse sidebar category 'C++'" aria-expanded=true type=button class="clean-btn menu__caret"></button></div><ul class=menu__list><li class="theme-doc-sidebar-item-link theme-doc-sidebar-item-link-level-3 menu__list-item"><a class=menu__link tabindex=0 href=/docs/guide/cpp/basic_serialization><span title="Basic Serialization" class=linkLabel_WmDU>Basic Serialization</span></a><li class="theme-doc-sidebar-item-link theme-doc-sidebar-item-link-level-3 menu__list-item"><a class=menu__link tabindex=0 href=/docs/guide/cpp/xlang_serialization><span title="Xlang Serialization" class=linkLabel_WmDU>Xlang Serialization</span></a><li class="theme-doc-sidebar-item-link theme-doc-sidebar-item-link-level-3 menu__list-item"><a class=menu__link tabindex=0 href=/docs/guide/cpp/native_serialization><span title="Native Serialization" class=linkLabel_WmDU>Native Serialization</span></a><li class="theme-doc-sidebar-item-link theme-doc-sidebar-item-link-level-3 menu__list-item"><a class=menu__link tabindex=0 href=/docs/guide/cpp/configuration><span title=Configuration class=linkLabel_WmDU>Configuration</span></a><li class="theme-doc-sidebar-item-link theme-doc-sidebar-item-link-level-3 menu__list-item"><a class=menu__link tabindex=0 href=/docs/guide/cpp/schema_metadata><span title="Schema Metadata" class=linkLabel_WmDU>Schema Metadata</span></a><li class="theme-doc-sidebar-item-link theme-doc-sidebar-item-link-level-3 menu__list-item"><a class=menu__link tabindex=0 href=/docs/guide/cpp/schema_evolution><span title="Schema Evolution" class=linkLabel_WmDU>Schema Evolution</span></a><li class="theme-doc-sidebar-item-link theme-doc-sidebar-item-link-level-3 menu__list-item"><a class=menu__link tabindex=0 href=/docs/guide/cpp/type_registration><span title="Type Registration" class=linkLabel_WmDU>Type Registration</span></a><li class="theme-doc-sidebar-item-link theme-doc-sidebar-item-link-level-3 menu__list-item"><a class=menu__link tabindex=0 href=/docs/guide/cpp/polymorphism><span title="Polymorphic Serialization" class=linkLabel_WmDU>Polymorphic Serialization</span></a><li class="theme-doc-sidebar-item-link theme-doc-sidebar-item-link-level-3 menu__list-item"><a class=menu__link tabindex=0 href=/docs/guide/cpp/supported_types><span title="Supported Types" class=linkLabel_WmDU>Supported Types</span></a><li class="theme-doc-sidebar-item-link theme-doc-sidebar-item-link-level-3 menu__list-item"><a class=menu__link tabindex=0 href=/docs/guide/cpp/custom_serializers><span title="Custom Serializers" class=linkLabel_WmDU>Custom Serializers</span></a><li class="theme-doc-sidebar-item-link theme-doc-sidebar-item-link-level-3 menu__list-item"><a class=menu__link tabindex=0 href=/docs/guide/cpp/row_format><span title="Row Format" class=linkLabel_WmDU>Row Format</span></a></ul><li class="theme-doc-sidebar-item-category theme-doc-sidebar-item-category-level-2 menu__list-item menu__list-item--collapsed"><div class=menu__list-item-collapsible><a class="categoryLink_byQd menu__link menu__link--sublist" tabindex=0 href=/docs/guide/go/><span title=Go class=categoryLinkLabel_W154>Go</span></a><button aria-label="Expand sidebar category 'Go'" aria-expanded=false type=button class="clean-btn menu__caret"></button></div><li class="theme-doc-sidebar-item-category theme-doc-sidebar-item-category-level-2 menu__list-item menu__list-item--collapsed"><div class=menu__list-item-collapsible><a class="categoryLink_byQd menu__link menu__link--sublist" tabindex=0 href=/docs/guide/javascript/><span title=JavaScript class=categoryLinkLabel_W154>JavaScript</span></a><button aria-label="Expand sidebar category 'JavaScript'" aria-expanded=false type=button class="clean-btn menu__caret"></button></div><li class="theme-doc-sidebar-item-category theme-doc-sidebar-item-category-level-2 menu__list-item menu__list-item--collapsed"><div class=menu__list-item-collapsible><a class="categoryLink_byQd menu__link menu__link--sublist" tabindex=0 href=/docs/guide/csharp/><span title=C# class=categoryLinkLabel_W154>C#</span></a><button aria-label="Expand sidebar category 'C#'" aria-expanded=false type=button class="clean-btn menu__caret"></button></div><li class="theme-doc-sidebar-item-category theme-doc-sidebar-item-category-level-2 menu__list-item menu__list-item--collapsed"><div class=menu__list-item-collapsible><a class="categoryLink_byQd menu__link menu__link--sublist" tabindex=0 href=/docs/guide/swift/><span title=Swift class=categoryLinkLabel_W154>Swift</span></a><button aria-label="Expand sidebar category 'Swift'" aria-expanded=false type=button class="clean-btn menu__caret"></button></div><li class="theme-doc-sidebar-item-category theme-doc-sidebar-item-category-level-2 menu__list-item menu__list-item--collapsed"><div class=menu__list-item-collapsible><a class="categoryLink_byQd menu__link menu__link--sublist" tabindex=0 href=/docs/guide/dart/><span title=Dart class=categoryLinkLabel_W154>Dart</span></a><button aria-label="Expand sidebar category 'Dart'" aria-expanded=false type=button class="clean-btn menu__caret"></button></div><li class="theme-doc-sidebar-item-category theme-doc-sidebar-item-category-level-2 menu__list-item menu__list-item--collapsed"><div class=menu__list-item-collapsible><a class="categoryLink_byQd menu__link menu__link--sublist" tabindex=0 href=/docs/guide/scala/><span title=Scala class=categoryLinkLabel_W154>Scala</span></a><button aria-label="Expand sidebar category 'Scala'" aria-expanded=false type=button class="clean-btn menu__caret"></button></div><li class="theme-doc-sidebar-item-category theme-doc-sidebar-item-category-level-2 menu__list-item menu__list-item--collapsed"><div class=menu__list-item-collapsible><a class="categoryLink_byQd menu__link menu__link--sublist" tabindex=0 href=/docs/guide/kotlin/><span title=Kotlin class=categoryLinkLabel_W154>Kotlin</span></a><button aria-label="Expand sidebar category 'Kotlin'" aria-expanded=false type=button class="clean-btn menu__caret"></button></div><li class="theme-doc-sidebar-item-category theme-doc-sidebar-item-category-level-2 menu__list-item menu__list-item--collapsed"><div class=menu__list-item-collapsible><a class="categoryLink_byQd menu__link menu__link--sublist" tabindex=0 href=/docs/guide/xlang/><span title="Cross Language" class=categoryLinkLabel_W154>Cross Language</span></a><button aria-label="Expand sidebar category 'Cross Language'" aria-expanded=false type=button class="clean-btn menu__caret"></button></div></ul></ul></nav></div></div></aside><main class=docMainContainer_TBSr><div class="container padding-top--md padding-bottom--lg"><div class=row><div class="col docItemCol_VOVn"><div class=docItemContainer_Djhp><article><nav class="theme-doc-breadcrumbs breadcrumbsContainer_Z_bl" aria-label=Breadcrumbs><ul class=breadcrumbs><li class=breadcrumbs__item><a aria-label="Home page" class=breadcrumbs__link href=/><svg viewBox="0 0 24 24" class=breadcrumbHomeIcon_YNFT><path d="M10 19v-5h4v5c0 .55.45 1 1 1h3c.55 0 1-.45 1-1v-7h1.7c.46 0 .68-.57.33-.87L12.67 3.6c-.38-.34-.96-.34-1.34 0l-8.36 7.53c-.34.3-.13.87.33.87H5v7c0 .55.45 1 1 1h3c.55 0 1-.45 1-1z" fill=currentColor /></svg></a><li class=breadcrumbs__item><span class=breadcrumbs__link>Guide</span><li class="breadcrumbs__item breadcrumbs__item--active"><span class=breadcrumbs__link>C++</span></ul></nav><span class="theme-doc-version-badge badge badge--secondary">Version: 1.3.0</span><div class="tocCollapsible_ETCw theme-doc-toc-mobile tocMobile_ITEo"><button type=button class="clean-btn tocCollapsibleButton_TO0P">On this page</button></div><div class="theme-doc-markdown markdown"><header><h1>C++ Serialization Guide</h1></header><p><strong>Apache Fory™</strong> is a blazing fast multi-language serialization framework powered by <strong>JIT compilation</strong> and <strong>zero-copy</strong> techniques, providing up to <strong>ultra-fast performance</strong> while maintaining ease of use and safety.</p>
<p>The C++ implementation provides high-performance serialization with compile-time type safety using modern C++17 features and template metaprogramming. It supports both xlang mode for cross-language payloads and native mode for C++-only payloads.</p>
<h2 class="anchor anchorTargetStickyNavbar_Vzrq" id=why-apache-fory-c>Why Apache Fory™ C++?<a href=#why-apache-fory-c class=hash-link aria-label="Direct link to Why Apache Fory™ C++?" title="Direct link to Why Apache Fory™ C++?" translate=no>​</a></h2>
<ul>
<li class=""><strong>Fast binary encoding</strong>: Fast serialization and optimized binary protocols</li>
<li class=""><strong>Xlang</strong>: Seamlessly serialize/deserialize data across Java, Python, C++, Go,
Rust, JavaScript/TypeScript, C#, Swift, Dart, Scala, and Kotlin</li>
<li class=""><strong>Type-safe</strong>: Compile-time type checking with macro-based struct registration</li>
<li class=""><strong>Reference tracking</strong>: Automatic tracking of shared and circular references</li>
<li class=""><strong>Schema evolution</strong>: Compatible mode for independent schema changes</li>
<li class=""><strong>Two formats</strong>: Object graph serialization and zero-copy row-based format</li>
<li class=""><strong>Thread safety</strong>: Both single-threaded and thread-safe variants</li>
</ul>
<h2 class="anchor anchorTargetStickyNavbar_Vzrq" id=installation>Installation<a href=#installation class=hash-link aria-label="Direct link to Installation" title="Direct link to Installation" translate=no>​</a></h2>
<p>The C++ implementation supports both CMake and Bazel build systems.</p>
<h3 class="anchor anchorTargetStickyNavbar_Vzrq" id=prerequisites>Prerequisites<a href=#prerequisites class=hash-link aria-label="Direct link to Prerequisites" title="Direct link to Prerequisites" translate=no>​</a></h3>
<ul>
<li class="">CMake 3.16+ (for CMake build) or Bazel 8+ (for Bazel build)</li>
<li class="">C++17 compatible compiler (GCC 7+, Clang 5+, MSVC 2017+)</li>
</ul>
<p>When building with MSVC, configure your build system to pass
<code>/Zc:preprocessor</code>.</p>
<h3 class="anchor anchorTargetStickyNavbar_Vzrq" id=using-cmake-recommended>Using CMake (Recommended)<a href=#using-cmake-recommended class=hash-link aria-label="Direct link to Using CMake (Recommended)" title="Direct link to Using CMake (Recommended)" translate=no>​</a></h3>
<p>The easiest way to use Fory is with CMake's <code>FetchContent</code> module:</p>
<div class="language-cmake codeBlockContainer_Ckt0 theme-code-block" style=--prism-color:#393A34;--prism-background-color:#f6f8fa><div class=codeBlockContent_QJqH><pre tabindex=0 class="prism-code language-cmake codeBlock_bY9V thin-scrollbar" style=color:#393A34;background-color:#f6f8fa><code class=codeBlockLines_e6Vv><div class=token-line style=color:#393A34><span class="token plain">cmake_minimum_required(VERSION 3.16)</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">project(my_project LANGUAGES CXX)</span><br/></div><div class=token-line style=color:#393A34><span class="token plain" style=display:inline-block></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">set(CMAKE_CXX_STANDARD 17)</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">set(CMAKE_CXX_STANDARD_REQUIRED ON)</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">if(MSVC)</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">    add_compile_options(/Zc:preprocessor)</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">endif()</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">include(FetchContent)</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">FetchContent_Declare(</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">    fory</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">    GIT_REPOSITORY https://github.com/apache/fory.git</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">    GIT_TAG        v1.3.0</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">    SOURCE_SUBDIR  cpp</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">)</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">FetchContent_MakeAvailable(fory)</span><br/></div><div class=token-line style=color:#393A34><span class="token plain" style=display:inline-block></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">add_executable(my_app main.cc)</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">target_link_libraries(my_app PRIVATE fory::serialization)</span><br/></div></code></pre></div></div>
<p>Then build and run:</p>
<div class="language-bash codeBlockContainer_Ckt0 theme-code-block" style=--prism-color:#393A34;--prism-background-color:#f6f8fa><div class=codeBlockContent_QJqH><pre tabindex=0 class="prism-code language-bash codeBlock_bY9V thin-scrollbar" style=color:#393A34;background-color:#f6f8fa><code class=codeBlockLines_e6Vv><div class=token-line style=color:#393A34><span class="token function" style=color:#d73a49>mkdir</span><span class="token plain"> build </span><span class="token operator" style=color:#393A34>&&</span><span class="token plain"> </span><span class="token builtin class-name">cd</span><span class="token plain"> build</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">cmake </span><span class="token punctuation" style=color:#393A34>..</span><span class="token plain"> </span><span class="token parameter variable" style=color:#36acaa>-DCMAKE_BUILD_TYPE</span><span class="token operator" style=color:#393A34>=</span><span class="token plain">Release</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">cmake </span><span class="token parameter variable" style=color:#36acaa>--build</span><span class="token plain"> </span><span class="token builtin class-name">.</span><span class="token plain"> </span><span class="token parameter variable" style=color:#36acaa>--parallel</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">./my_app</span><br/></div></code></pre></div></div>
<h3 class="anchor anchorTargetStickyNavbar_Vzrq" id=using-bazel>Using Bazel<a href=#using-bazel class=hash-link aria-label="Direct link to Using Bazel" title="Direct link to Using Bazel" translate=no>​</a></h3>
<p>Create a <code>MODULE.bazel</code> file in your project root:</p>
<div class="language-bazel codeBlockContainer_Ckt0 theme-code-block" style=--prism-color:#393A34;--prism-background-color:#f6f8fa><div class=codeBlockContent_QJqH><pre tabindex=0 class="prism-code language-bazel codeBlock_bY9V thin-scrollbar" style=color:#393A34;background-color:#f6f8fa><code class=codeBlockLines_e6Vv><div class=token-line style=color:#393A34><span class="token plain">module(</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">    name = "my_project",</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">    version = "1.0.0",</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">)</span><br/></div><div class=token-line style=color:#393A34><span class="token plain" style=display:inline-block></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">bazel_dep(name = "rules_cc", version = "0.1.1")</span><br/></div><div class=token-line style=color:#393A34><span class="token plain" style=display:inline-block></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">bazel_dep(name = "fory", version = "1.3.0")</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">git_override(</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">    module_name = "fory",</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">    remote = "https://github.com/apache/fory.git",</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">    commit = "v1.3.0",  # Or use a specific commit hash for reproducibility</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">)</span><br/></div></code></pre></div></div>
<p>Create a <code>BUILD</code> file for your application:</p>
<div class="language-bazel codeBlockContainer_Ckt0 theme-code-block" style=--prism-color:#393A34;--prism-background-color:#f6f8fa><div class=codeBlockContent_QJqH><pre tabindex=0 class="prism-code language-bazel codeBlock_bY9V thin-scrollbar" style=color:#393A34;background-color:#f6f8fa><code class=codeBlockLines_e6Vv><div class=token-line style=color:#393A34><span class="token plain">cc_binary(</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">    name = "my_app",</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">    srcs = ["main.cc"],</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">    deps = ["@fory//cpp/fory/serialization:fory_serialization"],</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">)</span><br/></div></code></pre></div></div>
<p>When building with MSVC, add the conforming preprocessor option to your Bazel
configuration:</p>
<div class="language-bazel codeBlockContainer_Ckt0 theme-code-block" style=--prism-color:#393A34;--prism-background-color:#f6f8fa><div class=codeBlockContent_QJqH><pre tabindex=0 class="prism-code language-bazel codeBlock_bY9V thin-scrollbar" style=color:#393A34;background-color:#f6f8fa><code class=codeBlockLines_e6Vv><div class=token-line style=color:#393A34><span class="token plain"># .bazelrc</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">build --cxxopt=/Zc:preprocessor</span><br/></div></code></pre></div></div>
<p>Then build and run:</p>
<div class="language-bash codeBlockContainer_Ckt0 theme-code-block" style=--prism-color:#393A34;--prism-background-color:#f6f8fa><div class=codeBlockContent_QJqH><pre tabindex=0 class="prism-code language-bash codeBlock_bY9V thin-scrollbar" style=color:#393A34;background-color:#f6f8fa><code class=codeBlockLines_e6Vv><div class=token-line style=color:#393A34><span class="token plain">bazel build //:my_app</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">bazel run //:my_app</span><br/></div></code></pre></div></div>
<p>For local development, you can use <code>local_path_override</code> instead:</p>
<div class="language-bazel codeBlockContainer_Ckt0 theme-code-block" style=--prism-color:#393A34;--prism-background-color:#f6f8fa><div class=codeBlockContent_QJqH><pre tabindex=0 class="prism-code language-bazel codeBlock_bY9V thin-scrollbar" style=color:#393A34;background-color:#f6f8fa><code class=codeBlockLines_e6Vv><div class=token-line style=color:#393A34><span class="token plain">bazel_dep(name = "fory", version = "1.3.0")</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">local_path_override(</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">    module_name = "fory",</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">    path = "/path/to/fory",</span><br/></div><div class=token-line style=color:#393A34><span class="token plain">)</span><br/></div></code></pre></div></div>
<h3 class="anchor anchorTargetStickyNavbar_Vzrq" id=examples>Examples<a href=#examples class=hash-link aria-label="Direct link to Examples" title="Direct link to Examples" translate=no>​</a></h3>
<p>See the <a href=https://github.com/apache/fory/tree/main/examples/cpp target=_blank rel="noopener noreferrer" class="">examples/cpp</a> directory for complete working examples:</p>
<ul>
<li class=""><a href=https://github.com/apache/fory/tree/main/examples/cpp/hello_world target=_blank rel="noopener noreferrer" class="">hello_world</a> - Object graph serialization</li>
<li class=""><a href=https://github.com/apache/fory/tree/main/examples/cpp/hello_row target=_blank rel="noopener noreferrer" class="">hello_row</a> - Row format encoding</li>
</ul>
<h2 class="anchor anchorTargetStickyNavbar_Vzrq" id=quick-start>Quick Start<a href=#quick-start class=hash-link aria-label="Direct link to Quick Start" title="Direct link to Quick Start" translate=no>​</a></h2>
<h3 class="anchor anchorTargetStickyNavbar_Vzrq" id=basic-example>Basic Example<a href=#basic-example class=hash-link aria-label="Direct link to Basic Example" title="Direct link to Basic Example" translate=no>​</a></h3>
<div class="language-cpp codeBlockContainer_Ckt0 theme-code-block" style=--prism-color:#393A34;--prism-background-color:#f6f8fa><div class=codeBlockContent_QJqH><pre tabindex=0 class="prism-code language-cpp codeBlock_bY9V thin-scrollbar" style=color:#393A34;background-color:#f6f8fa><code class=codeBlockLines_e6Vv><div class=token-line style=color:#393A34><span class="token macro property directive-hash" style=color:#36acaa>#</span><span class="token macro property directive keyword" style=color:#00009f>include</span><span class="token macro property" style=color:#36acaa> </span><span class="token macro property string" style=color:#e3116c>"fory/serialization/fory.h"</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain"></span><span class="token macro property directive-hash" style=color:#36acaa>#</span><span class="token macro property directive keyword" style=color:#00009f>include</span><span class="token macro property" style=color:#36acaa> </span><span class="token macro property string" style=color:#e3116c>&lt;string></span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain"></span><span class="token macro property directive-hash" style=color:#36acaa>#</span><span class="token macro property directive keyword" style=color:#00009f>include</span><span class="token macro property" style=color:#36acaa> </span><span class="token macro property string" style=color:#e3116c>&lt;vector></span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain" style=display:inline-block></span><br/></div><div class=token-line style=color:#393A34><span class="token plain"></span><span class="token keyword" style=color:#00009f>using</span><span class="token plain"> </span><span class="token keyword" style=color:#00009f>namespace</span><span class="token plain"> fory</span><span class="token double-colon punctuation" style=color:#393A34>::</span><span class="token plain">serialization</span><span class="token punctuation" style=color:#393A34>;</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain" style=display:inline-block></span><br/></div><div class=token-line style=color:#393A34><span class="token plain"></span><span class="token comment" style=color:#999988;font-style:italic>// Define a struct</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain"></span><span class="token keyword" style=color:#00009f>struct</span><span class="token plain"> </span><span class="token class-name">Person</span><span class="token plain"> </span><span class="token punctuation" style=color:#393A34>{</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">  std</span><span class="token double-colon punctuation" style=color:#393A34>::</span><span class="token plain">string name</span><span class="token punctuation" style=color:#393A34>;</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">  </span><span class="token keyword" style=color:#00009f>int32_t</span><span class="token plain"> age</span><span class="token punctuation" style=color:#393A34>;</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">  std</span><span class="token double-colon punctuation" style=color:#393A34>::</span><span class="token plain">vector</span><span class="token operator" style=color:#393A34>&lt;</span><span class="token plain">std</span><span class="token double-colon punctuation" style=color:#393A34>::</span><span class="token plain">string</span><span class="token operator" style=color:#393A34>></span><span class="token plain"> hobbies</span><span class="token punctuation" style=color:#393A34>;</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain" style=display:inline-block></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">  </span><span class="token keyword" style=color:#00009f>bool</span><span class="token plain"> </span><span class="token keyword" style=color:#00009f>operator</span><span class="token operator" style=color:#393A34>==</span><span class="token punctuation" style=color:#393A34>(</span><span class="token keyword" style=color:#00009f>const</span><span class="token plain"> Person </span><span class="token operator" style=color:#393A34>&</span><span class="token plain">other</span><span class="token punctuation" style=color:#393A34>)</span><span class="token plain"> </span><span class="token keyword" style=color:#00009f>const</span><span class="token plain"> </span><span class="token punctuation" style=color:#393A34>{</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">    </span><span class="token keyword" style=color:#00009f>return</span><span class="token plain"> name </span><span class="token operator" style=color:#393A34>==</span><span class="token plain"> other</span><span class="token punctuation" style=color:#393A34>.</span><span class="token plain">name </span><span class="token operator" style=color:#393A34>&&</span><span class="token plain"> age </span><span class="token operator" style=color:#393A34>==</span><span class="token plain"> other</span><span class="token punctuation" style=color:#393A34>.</span><span class="token plain">age </span><span class="token operator" style=color:#393A34>&&</span><span class="token plain"> hobbies </span><span class="token operator" style=color:#393A34>==</span><span class="token plain"> other</span><span class="token punctuation" style=color:#393A34>.</span><span class="token plain">hobbies</span><span class="token punctuation" style=color:#393A34>;</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">  </span><span class="token punctuation" style=color:#393A34>}</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain"></span><span class="token punctuation" style=color:#393A34>}</span><span class="token punctuation" style=color:#393A34>;</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain"></span><span class="token function" style=color:#d73a49>FORY_STRUCT</span><span class="token punctuation" style=color:#393A34>(</span><span class="token plain">Person</span><span class="token punctuation" style=color:#393A34>,</span><span class="token plain"> name</span><span class="token punctuation" style=color:#393A34>,</span><span class="token plain"> age</span><span class="token punctuation" style=color:#393A34>,</span><span class="token plain"> hobbies</span><span class="token punctuation" style=color:#393A34>)</span><span class="token punctuation" style=color:#393A34>;</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain" style=display:inline-block></span><br/></div><div class=token-line style=color:#393A34><span class="token plain"></span><span class="token keyword" style=color:#00009f>int</span><span class="token plain"> </span><span class="token function" style=color:#d73a49>main</span><span class="token punctuation" style=color:#393A34>(</span><span class="token punctuation" style=color:#393A34>)</span><span class="token plain"> </span><span class="token punctuation" style=color:#393A34>{</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">  </span><span class="token comment" style=color:#999988;font-style:italic>// Create an xlang Fory instance</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">  </span><span class="token keyword" style=color:#00009f>auto</span><span class="token plain"> fory </span><span class="token operator" style=color:#393A34>=</span><span class="token plain"> </span><span class="token class-name">Fory</span><span class="token double-colon punctuation" style=color:#393A34>::</span><span class="token function" style=color:#d73a49>builder</span><span class="token punctuation" style=color:#393A34>(</span><span class="token punctuation" style=color:#393A34>)</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">      </span><span class="token punctuation" style=color:#393A34>.</span><span class="token function" style=color:#d73a49>xlang</span><span class="token punctuation" style=color:#393A34>(</span><span class="token boolean" style=color:#36acaa>true</span><span class="token punctuation" style=color:#393A34>)</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">      </span><span class="token punctuation" style=color:#393A34>.</span><span class="token function" style=color:#d73a49>track_ref</span><span class="token punctuation" style=color:#393A34>(</span><span class="token boolean" style=color:#36acaa>false</span><span class="token punctuation" style=color:#393A34>)</span><span class="token plain">     </span><span class="token comment" style=color:#999988;font-style:italic>// Disable reference tracking for simple types</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">      </span><span class="token punctuation" style=color:#393A34>.</span><span class="token function" style=color:#d73a49>build</span><span class="token punctuation" style=color:#393A34>(</span><span class="token punctuation" style=color:#393A34>)</span><span class="token punctuation" style=color:#393A34>;</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain" style=display:inline-block></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">  </span><span class="token comment" style=color:#999988;font-style:italic>// Register the type with a unique ID</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">  fory</span><span class="token punctuation" style=color:#393A34>.</span><span class="token generic-function function" style=color:#d73a49>register_struct</span><span class="token generic-function generic class-name operator" style=color:#393A34>&lt;</span><span class="token generic-function generic class-name">Person</span><span class="token generic-function generic class-name operator" style=color:#393A34>></span><span class="token punctuation" style=color:#393A34>(</span><span class="token number" style=color:#36acaa>1</span><span class="token punctuation" style=color:#393A34>)</span><span class="token punctuation" style=color:#393A34>;</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain" style=display:inline-block></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">  </span><span class="token comment" style=color:#999988;font-style:italic>// Create an object</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">  Person person</span><span class="token punctuation" style=color:#393A34>{</span><span class="token string" style=color:#e3116c>"Alice"</span><span class="token punctuation" style=color:#393A34>,</span><span class="token plain"> </span><span class="token number" style=color:#36acaa>30</span><span class="token punctuation" style=color:#393A34>,</span><span class="token plain"> </span><span class="token punctuation" style=color:#393A34>{</span><span class="token string" style=color:#e3116c>"reading"</span><span class="token punctuation" style=color:#393A34>,</span><span class="token plain"> </span><span class="token string" style=color:#e3116c>"coding"</span><span class="token punctuation" style=color:#393A34>}</span><span class="token punctuation" style=color:#393A34>}</span><span class="token punctuation" style=color:#393A34>;</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain" style=display:inline-block></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">  </span><span class="token comment" style=color:#999988;font-style:italic>// Serialize</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">  </span><span class="token keyword" style=color:#00009f>auto</span><span class="token plain"> result </span><span class="token operator" style=color:#393A34>=</span><span class="token plain"> fory</span><span class="token punctuation" style=color:#393A34>.</span><span class="token function" style=color:#d73a49>serialize</span><span class="token punctuation" style=color:#393A34>(</span><span class="token plain">person</span><span class="token punctuation" style=color:#393A34>)</span><span class="token punctuation" style=color:#393A34>;</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">  </span><span class="token keyword" style=color:#00009f>if</span><span class="token plain"> </span><span class="token punctuation" style=color:#393A34>(</span><span class="token operator" style=color:#393A34>!</span><span class="token plain">result</span><span class="token punctuation" style=color:#393A34>.</span><span class="token function" style=color:#d73a49>ok</span><span class="token punctuation" style=color:#393A34>(</span><span class="token punctuation" style=color:#393A34>)</span><span class="token punctuation" style=color:#393A34>)</span><span class="token plain"> </span><span class="token punctuation" style=color:#393A34>{</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">    </span><span class="token comment" style=color:#999988;font-style:italic>// Handle error</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">    </span><span class="token keyword" style=color:#00009f>return</span><span class="token plain"> </span><span class="token number" style=color:#36acaa>1</span><span class="token punctuation" style=color:#393A34>;</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">  </span><span class="token punctuation" style=color:#393A34>}</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">  std</span><span class="token double-colon punctuation" style=color:#393A34>::</span><span class="token plain">vector</span><span class="token operator" style=color:#393A34>&lt;</span><span class="token keyword" style=color:#00009f>uint8_t</span><span class="token operator" style=color:#393A34>></span><span class="token plain"> bytes </span><span class="token operator" style=color:#393A34>=</span><span class="token plain"> std</span><span class="token double-colon punctuation" style=color:#393A34>::</span><span class="token function" style=color:#d73a49>move</span><span class="token punctuation" style=color:#393A34>(</span><span class="token plain">result</span><span class="token punctuation" style=color:#393A34>)</span><span class="token punctuation" style=color:#393A34>.</span><span class="token function" style=color:#d73a49>value</span><span class="token punctuation" style=color:#393A34>(</span><span class="token punctuation" style=color:#393A34>)</span><span class="token punctuation" style=color:#393A34>;</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain" style=display:inline-block></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">  </span><span class="token comment" style=color:#999988;font-style:italic>// Deserialize</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">  </span><span class="token keyword" style=color:#00009f>auto</span><span class="token plain"> deser_result </span><span class="token operator" style=color:#393A34>=</span><span class="token plain"> fory</span><span class="token punctuation" style=color:#393A34>.</span><span class="token generic-function function" style=color:#d73a49>deserialize</span><span class="token generic-function generic class-name operator" style=color:#393A34>&lt;</span><span class="token generic-function generic class-name">Person</span><span class="token generic-function generic class-name operator" style=color:#393A34>></span><span class="token punctuation" style=color:#393A34>(</span><span class="token plain">bytes</span><span class="token punctuation" style=color:#393A34>)</span><span class="token punctuation" style=color:#393A34>;</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">  </span><span class="token keyword" style=color:#00009f>if</span><span class="token plain"> </span><span class="token punctuation" style=color:#393A34>(</span><span class="token operator" style=color:#393A34>!</span><span class="token plain">deser_result</span><span class="token punctuation" style=color:#393A34>.</span><span class="token function" style=color:#d73a49>ok</span><span class="token punctuation" style=color:#393A34>(</span><span class="token punctuation" style=color:#393A34>)</span><span class="token punctuation" style=color:#393A34>)</span><span class="token plain"> </span><span class="token punctuation" style=color:#393A34>{</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">    </span><span class="token comment" style=color:#999988;font-style:italic>// Handle error</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">    </span><span class="token keyword" style=color:#00009f>return</span><span class="token plain"> </span><span class="token number" style=color:#36acaa>1</span><span class="token punctuation" style=color:#393A34>;</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">  </span><span class="token punctuation" style=color:#393A34>}</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">  Person decoded </span><span class="token operator" style=color:#393A34>=</span><span class="token plain"> std</span><span class="token double-colon punctuation" style=color:#393A34>::</span><span class="token function" style=color:#d73a49>move</span><span class="token punctuation" style=color:#393A34>(</span><span class="token plain">deser_result</span><span class="token punctuation" style=color:#393A34>)</span><span class="token punctuation" style=color:#393A34>.</span><span class="token function" style=color:#d73a49>value</span><span class="token punctuation" style=color:#393A34>(</span><span class="token punctuation" style=color:#393A34>)</span><span class="token punctuation" style=color:#393A34>;</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain" style=display:inline-block></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">  </span><span class="token function" style=color:#d73a49>assert</span><span class="token punctuation" style=color:#393A34>(</span><span class="token plain">person </span><span class="token operator" style=color:#393A34>==</span><span class="token plain"> decoded</span><span class="token punctuation" style=color:#393A34>)</span><span class="token punctuation" style=color:#393A34>;</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">  </span><span class="token keyword" style=color:#00009f>return</span><span class="token plain"> </span><span class="token number" style=color:#36acaa>0</span><span class="token punctuation" style=color:#393A34>;</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain"></span><span class="token punctuation" style=color:#393A34>}</span><br/></div></code></pre></div></div>
<h3 class="anchor anchorTargetStickyNavbar_Vzrq" id=inherited-fields>Inherited Fields<a href=#inherited-fields class=hash-link aria-label="Direct link to Inherited Fields" title="Direct link to Inherited Fields" translate=no>​</a></h3>
<p>To include base-class fields in a derived type, list <code>FORY_BASE(Base)</code> inside
<code>FORY_STRUCT</code>. The base must define its own <code>FORY_STRUCT</code> so its fields can be
referenced.</p>
<div class="language-cpp codeBlockContainer_Ckt0 theme-code-block" style=--prism-color:#393A34;--prism-background-color:#f6f8fa><div class=codeBlockContent_QJqH><pre tabindex=0 class="prism-code language-cpp codeBlock_bY9V thin-scrollbar" style=color:#393A34;background-color:#f6f8fa><code class=codeBlockLines_e6Vv><div class=token-line style=color:#393A34><span class="token keyword" style=color:#00009f>struct</span><span class="token plain"> </span><span class="token class-name">Base</span><span class="token plain"> </span><span class="token punctuation" style=color:#393A34>{</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">  </span><span class="token keyword" style=color:#00009f>int32_t</span><span class="token plain"> id</span><span class="token punctuation" style=color:#393A34>;</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">  </span><span class="token function" style=color:#d73a49>FORY_STRUCT</span><span class="token punctuation" style=color:#393A34>(</span><span class="token plain">Base</span><span class="token punctuation" style=color:#393A34>,</span><span class="token plain"> id</span><span class="token punctuation" style=color:#393A34>)</span><span class="token punctuation" style=color:#393A34>;</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain"></span><span class="token punctuation" style=color:#393A34>}</span><span class="token punctuation" style=color:#393A34>;</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain" style=display:inline-block></span><br/></div><div class=token-line style=color:#393A34><span class="token plain"></span><span class="token keyword" style=color:#00009f>struct</span><span class="token plain"> </span><span class="token class-name">Derived</span><span class="token plain"> </span><span class="token operator" style=color:#393A34>:</span><span class="token plain"> </span><span class="token base-clause class-name">Base</span><span class="token plain"> </span><span class="token punctuation" style=color:#393A34>{</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">  std</span><span class="token double-colon punctuation" style=color:#393A34>::</span><span class="token plain">string name</span><span class="token punctuation" style=color:#393A34>;</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">  </span><span class="token function" style=color:#d73a49>FORY_STRUCT</span><span class="token punctuation" style=color:#393A34>(</span><span class="token plain">Derived</span><span class="token punctuation" style=color:#393A34>,</span><span class="token plain"> </span><span class="token function" style=color:#d73a49>FORY_BASE</span><span class="token punctuation" style=color:#393A34>(</span><span class="token plain">Base</span><span class="token punctuation" style=color:#393A34>)</span><span class="token punctuation" style=color:#393A34>,</span><span class="token plain"> name</span><span class="token punctuation" style=color:#393A34>)</span><span class="token punctuation" style=color:#393A34>;</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain"></span><span class="token punctuation" style=color:#393A34>}</span><span class="token punctuation" style=color:#393A34>;</span><br/></div></code></pre></div></div>
<h2 class="anchor anchorTargetStickyNavbar_Vzrq" id=xlang-mode-and-native-mode>Xlang Mode And Native Mode<a href=#xlang-mode-and-native-mode class=hash-link aria-label="Direct link to Xlang Mode And Native Mode" title="Direct link to Xlang Mode And Native Mode" translate=no>​</a></h2>
<p>Use xlang mode for cross-language payloads and schemas shared with other Fory implementations. Xlang mode is the default C++ wire mode, and C++ examples that use it set <code>.xlang(true)</code> explicitly so the mode choice is visible.</p>
<p>Use native mode for C++-only traffic. Native mode is selected with <code>.xlang(false)</code> and keeps C++ object serialization in C++-native form. It is optimized for C++ types and avoids portable xlang type-mapping constraints when the payload never leaves C++. Compatible mode is enabled by default. Set <code>.compatible(false)</code> only when every reader and writer uses the same C++ schema and you want faster serialization and smaller size.</p>
<p>See <a class="" href=/docs/guide/cpp/xlang_serialization>Xlang Serialization</a> for C++ xlang registration and interoperability rules, and <a class="" href=/docs/guide/cpp/native_serialization>Native Serialization</a> for C++-only payloads.</p>
<h2 class="anchor anchorTargetStickyNavbar_Vzrq" id=thread-safety>Thread Safety<a href=#thread-safety class=hash-link aria-label="Direct link to Thread Safety" title="Direct link to Thread Safety" translate=no>​</a></h2>
<p>Apache Fory™ C++ provides two variants for different threading needs:</p>
<h3 class="anchor anchorTargetStickyNavbar_Vzrq" id=single-threaded-fastest>Single-Threaded (Fastest)<a href=#single-threaded-fastest class=hash-link aria-label="Direct link to Single-Threaded (Fastest)" title="Direct link to Single-Threaded (Fastest)" translate=no>​</a></h3>
<div class="language-cpp codeBlockContainer_Ckt0 theme-code-block" style=--prism-color:#393A34;--prism-background-color:#f6f8fa><div class=codeBlockContent_QJqH><pre tabindex=0 class="prism-code language-cpp codeBlock_bY9V thin-scrollbar" style=color:#393A34;background-color:#f6f8fa><code class=codeBlockLines_e6Vv><div class=token-line style=color:#393A34><span class="token comment" style=color:#999988;font-style:italic>// Single-threaded Fory - fastest, NOT thread-safe</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain"></span><span class="token keyword" style=color:#00009f>auto</span><span class="token plain"> fory </span><span class="token operator" style=color:#393A34>=</span><span class="token plain"> </span><span class="token class-name">Fory</span><span class="token double-colon punctuation" style=color:#393A34>::</span><span class="token function" style=color:#d73a49>builder</span><span class="token punctuation" style=color:#393A34>(</span><span class="token punctuation" style=color:#393A34>)</span><span class="token punctuation" style=color:#393A34>.</span><span class="token function" style=color:#d73a49>xlang</span><span class="token punctuation" style=color:#393A34>(</span><span class="token boolean" style=color:#36acaa>true</span><span class="token punctuation" style=color:#393A34>)</span><span class="token punctuation" style=color:#393A34>.</span><span class="token function" style=color:#d73a49>build</span><span class="token punctuation" style=color:#393A34>(</span><span class="token punctuation" style=color:#393A34>)</span><span class="token punctuation" style=color:#393A34>;</span><br/></div></code></pre></div></div>
<h3 class="anchor anchorTargetStickyNavbar_Vzrq" id=thread-safe>Thread-Safe<a href=#thread-safe class=hash-link aria-label="Direct link to Thread-Safe" title="Direct link to Thread-Safe" translate=no>​</a></h3>
<div class="language-cpp codeBlockContainer_Ckt0 theme-code-block" style=--prism-color:#393A34;--prism-background-color:#f6f8fa><div class=codeBlockContent_QJqH><pre tabindex=0 class="prism-code language-cpp codeBlock_bY9V thin-scrollbar" style=color:#393A34;background-color:#f6f8fa><code class=codeBlockLines_e6Vv><div class=token-line style=color:#393A34><span class="token comment" style=color:#999988;font-style:italic>// Thread-safe Fory - uses context pools</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain"></span><span class="token keyword" style=color:#00009f>auto</span><span class="token plain"> fory </span><span class="token operator" style=color:#393A34>=</span><span class="token plain"> </span><span class="token class-name">Fory</span><span class="token double-colon punctuation" style=color:#393A34>::</span><span class="token function" style=color:#d73a49>builder</span><span class="token punctuation" style=color:#393A34>(</span><span class="token punctuation" style=color:#393A34>)</span><span class="token punctuation" style=color:#393A34>.</span><span class="token function" style=color:#d73a49>xlang</span><span class="token punctuation" style=color:#393A34>(</span><span class="token boolean" style=color:#36acaa>true</span><span class="token punctuation" style=color:#393A34>)</span><span class="token punctuation" style=color:#393A34>.</span><span class="token function" style=color:#d73a49>build_thread_safe</span><span class="token punctuation" style=color:#393A34>(</span><span class="token punctuation" style=color:#393A34>)</span><span class="token punctuation" style=color:#393A34>;</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain" style=display:inline-block></span><br/></div><div class=token-line style=color:#393A34><span class="token plain"></span><span class="token comment" style=color:#999988;font-style:italic>// Can be used from multiple threads safely</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">std</span><span class="token double-colon punctuation" style=color:#393A34>::</span><span class="token plain">thread </span><span class="token function" style=color:#d73a49>t1</span><span class="token punctuation" style=color:#393A34>(</span><span class="token punctuation" style=color:#393A34>[</span><span class="token operator" style=color:#393A34>&</span><span class="token punctuation" style=color:#393A34>]</span><span class="token punctuation" style=color:#393A34>(</span><span class="token punctuation" style=color:#393A34>)</span><span class="token plain"> </span><span class="token punctuation" style=color:#393A34>{</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">  </span><span class="token keyword" style=color:#00009f>auto</span><span class="token plain"> result </span><span class="token operator" style=color:#393A34>=</span><span class="token plain"> fory</span><span class="token punctuation" style=color:#393A34>.</span><span class="token function" style=color:#d73a49>serialize</span><span class="token punctuation" style=color:#393A34>(</span><span class="token plain">obj1</span><span class="token punctuation" style=color:#393A34>)</span><span class="token punctuation" style=color:#393A34>;</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain"></span><span class="token punctuation" style=color:#393A34>}</span><span class="token punctuation" style=color:#393A34>)</span><span class="token punctuation" style=color:#393A34>;</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">std</span><span class="token double-colon punctuation" style=color:#393A34>::</span><span class="token plain">thread </span><span class="token function" style=color:#d73a49>t2</span><span class="token punctuation" style=color:#393A34>(</span><span class="token punctuation" style=color:#393A34>[</span><span class="token operator" style=color:#393A34>&</span><span class="token punctuation" style=color:#393A34>]</span><span class="token punctuation" style=color:#393A34>(</span><span class="token punctuation" style=color:#393A34>)</span><span class="token plain"> </span><span class="token punctuation" style=color:#393A34>{</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain">  </span><span class="token keyword" style=color:#00009f>auto</span><span class="token plain"> result </span><span class="token operator" style=color:#393A34>=</span><span class="token plain"> fory</span><span class="token punctuation" style=color:#393A34>.</span><span class="token function" style=color:#d73a49>serialize</span><span class="token punctuation" style=color:#393A34>(</span><span class="token plain">obj2</span><span class="token punctuation" style=color:#393A34>)</span><span class="token punctuation" style=color:#393A34>;</span><span class="token plain"></span><br/></div><div class=token-line style=color:#393A34><span class="token plain"></span><span class="token punctuation" style=color:#393A34>}</span><span class="token punctuation" style=color:#393A34>)</span><span class="token punctuation" style=color:#393A34>;</span><br/></div></code></pre></div></div>
<p><strong>Tip:</strong> Perform type registrations before spawning threads so every worker sees the same metadata.</p>
<h2 class="anchor anchorTargetStickyNavbar_Vzrq" id=use-cases>Use Cases<a href=#use-cases class=hash-link aria-label="Direct link to Use Cases" title="Direct link to Use Cases" translate=no>​</a></h2>
<h3 class="anchor anchorTargetStickyNavbar_Vzrq" id=object-serialization>Object Serialization<a href=#object-serialization class=hash-link aria-label="Direct link to Object Serialization" title="Direct link to Object Serialization" translate=no>​</a></h3>
<ul>
<li class="">Complex data structures with nested objects and references</li>
<li class="">Cross-language communication in microservices</li>
<li class="">General-purpose serialization with full type safety</li>
<li class="">Schema evolution with compatible mode</li>
</ul>
<h3 class="anchor anchorTargetStickyNavbar_Vzrq" id=row-based-serialization>Row-Based Serialization<a href=#row-based-serialization class=hash-link aria-label="Direct link to Row-Based Serialization" title="Direct link to Row-Based Serialization" translate=no>​</a></h3>
<ul>
<li class="">High-throughput data processing</li>
<li class="">Analytics workloads requiring fast field access</li>
<li class="">Memory-constrained environments</li>
<li class="">Zero-copy scenarios</li>
</ul>
<h2 class="anchor anchorTargetStickyNavbar_Vzrq" id=next-steps>Next Steps<a href=#next-steps class=hash-link aria-label="Direct link to Next Steps" title="Direct link to Next Steps" translate=no>​</a></h2>
<ul>
<li class=""><a class="" href=/docs/guide/cpp/configuration>Configuration</a> - Builder options and modes</li>
<li class=""><a class="" href=/docs/guide/cpp/basic_serialization>Basic Serialization</a> - Object graph serialization</li>
<li class=""><a class="" href=/docs/guide/cpp/xlang_serialization>Xlang Serialization</a> - xlang mode and interoperability</li>
<li class=""><a class="" href=/docs/guide/cpp/native_serialization>Native Serialization</a> - C++-only serialization</li>
<li class=""><a class="" href=/docs/guide/cpp/schema_metadata>Schema Metadata</a> - Field-level metadata (nullable, ref tracking)</li>
<li class=""><a class="" href=/docs/guide/cpp/schema_evolution>Schema Evolution</a> - Compatible mode and schema changes</li>
<li class=""><a class="" href=/docs/guide/cpp/type_registration>Type Registration</a> - Registering types</li>
<li class=""><a class="" href=/docs/guide/cpp/supported_types>Supported Types</a> - All supported types</li>
<li class=""><a class="" href=/docs/guide/cpp/custom_serializers>Custom Serializers</a> - Extend serialization behavior</li>
<li class=""><a class="" href=/docs/guide/cpp/row_format>Row Format</a> - Zero-copy row-based format</li>
</ul></div><footer class="theme-doc-footer docusaurus-mt-lg"><div class="row margin-top--sm theme-doc-footer-edit-meta-row"><div class="col noPrint_WFHX"><a href=https://github.com/apache/fory-site/tree/main/docs/guide/cpp/index.md target=_blank rel="noopener noreferrer" class=theme-edit-this-page><svg fill=currentColor height=20 width=20 viewBox="0 0 40 40" class=iconEdit_Z9Sw aria-hidden=true><g><path d="m34.5 11.7l-3 3.1-6.3-6.3 3.1-3q0.5-0.5 1.2-0.5t1.1 0.5l3.9 3.9q0.5 0.4 0.5 1.1t-0.5 1.2z m-29.5 17.1l18.4-18.5 6.3 6.3-18.4 18.4h-6.3v-6.2z"/></g></svg>Edit this page</a></div><div class="col lastUpdated_JAkA"></div></div></footer></article><nav class="docusaurus-mt-lg pagination-nav" aria-label="Docs pages"><a class="pagination-nav__link pagination-nav__link--prev" href=/docs/guide/rust/troubleshooting><div class=pagination-nav__sublabel>Previous</div><div class=pagination-nav__label>Troubleshooting</div></a><a class="pagination-nav__link pagination-nav__link--next" href=/docs/guide/cpp/basic_serialization><div class=pagination-nav__sublabel>Next</div><div class=pagination-nav__label>Basic Serialization</div></a></nav></div></div><div class="col col--3"><div class="tableOfContents_bqdL thin-scrollbar theme-doc-toc-desktop"><ul class="table-of-contents table-of-contents__left-border"><li><a href=#why-apache-fory-c class="table-of-contents__link toc-highlight">Why Apache Fory™ C++?</a><li><a href=#installation class="table-of-contents__link toc-highlight">Installation</a><ul><li><a href=#prerequisites class="table-of-contents__link toc-highlight">Prerequisites</a><li><a href=#using-cmake-recommended class="table-of-contents__link toc-highlight">Using CMake (Recommended)</a><li><a href=#using-bazel class="table-of-contents__link toc-highlight">Using Bazel</a><li><a href=#examples class="table-of-contents__link toc-highlight">Examples</a></ul><li><a href=#quick-start class="table-of-contents__link toc-highlight">Quick Start</a><ul><li><a href=#basic-example class="table-of-contents__link toc-highlight">Basic Example</a><li><a href=#inherited-fields class="table-of-contents__link toc-highlight">Inherited Fields</a></ul><li><a href=#xlang-mode-and-native-mode class="table-of-contents__link toc-highlight">Xlang Mode And Native Mode</a><li><a href=#thread-safety class="table-of-contents__link toc-highlight">Thread Safety</a><ul><li><a href=#single-threaded-fastest class="table-of-contents__link toc-highlight">Single-Threaded (Fastest)</a><li><a href=#thread-safe class="table-of-contents__link toc-highlight">Thread-Safe</a></ul><li><a href=#use-cases class="table-of-contents__link toc-highlight">Use Cases</a><ul><li><a href=#object-serialization class="table-of-contents__link toc-highlight">Object Serialization</a><li><a href=#row-based-serialization class="table-of-contents__link toc-highlight">Row-Based Serialization</a></ul><li><a href=#next-steps class="table-of-contents__link toc-highlight">Next Steps</a></ul></div></div></div></div></main></div></div></div><footer class="theme-layout-footer footer footer--dark"><div class="container container-fluid"><div class="row footer__links"><div class="theme-layout-footer-column col footer__col"><div class=footer__title>Community</div><ul class="footer__items clean-list"><li class=footer__item><a href=https://lists.apache.org/list.html?dev@fory.apache.org target=_blank rel="noopener noreferrer" class=footer__link-item>Mailing list<svg width=13.5 height=13.5 aria-label="(opens in new tab)" class=iconExternalLink_nPIU><use href=#theme-svg-external-link /></svg></a><li class=footer__item><a href=https://join.slack.com/t/fory-project/shared_invite/zt-1u8soj4qc-ieYEu7ciHOqA2mo47llS8A target=_blank rel="noopener noreferrer" class=footer__link-item>Slack<svg width=13.5 height=13.5 aria-label="(opens in new tab)" class=iconExternalLink_nPIU><use href=#theme-svg-external-link /></svg></a><li class=footer__item><a href=https://twitter.com/ApacheFory target=_blank rel="noopener noreferrer" class=footer__link-item>Twitter<svg width=13.5 height=13.5 aria-label="(opens in new tab)" class=iconExternalLink_nPIU><use href=#theme-svg-external-link /></svg></a></ul></div><div class="theme-layout-footer-column col footer__col"><div class=footer__title>Docs</div><ul class="footer__items clean-list"><li class=footer__item><a class=footer__link-item href=/docs/start/install>Install</a><li class=footer__item><a class=footer__link-item href=/docs/start/usage>Usage</a><li class=footer__item><a class=footer__link-item href=/docs/introduction/benchmark>Benchmark</a></ul></div><div class="theme-layout-footer-column col footer__col"><div class=footer__title>Repositories</div><ul class="footer__items clean-list"><li class=footer__item><a href=https://github.com/apache/fory target=_blank rel="noopener noreferrer" class=footer__link-item>Apache Fory™<svg width=13.5 height=13.5 aria-label="(opens in new tab)" class=iconExternalLink_nPIU><use href=#theme-svg-external-link /></svg></a><li class=footer__item><a href=https://github.com/apache/fory-site target=_blank rel="noopener noreferrer" class=footer__link-item>Website<svg width=13.5 height=13.5 aria-label="(opens in new tab)" class=iconExternalLink_nPIU><use href=#theme-svg-external-link /></svg></a></ul></div></div><div class="footer__bottom text--center"><div class=margin-bottom--sm><a href=https://apache.org/ rel="noopener noreferrer" class=footerLogoLink_BH7S><img src=/img/asf_logo.svg alt="ASF Logo" class="footer__logo themedComponent_mlkZ themedComponent--light_NVdE" width=200 /><img src=/img/asf_logo.svg alt="ASF Logo" class="footer__logo themedComponent_mlkZ themedComponent--dark_xIcU" width=200 /></a></div><div class=footer__copyright><div>
      <p>
        Copyright © 2026 The Apache Software Foundation, Licensed under the Apache License, Version 2.0. <br/>
        Apache Fory, Fory, Apache, the Apache Logo and the Apache Fory logo are either registered trademarks or trademarks of the Apache Software Foundation in the United States and/or other countries.
      </p>
      </div></div></div></div></footer></div></body>