Editing C preprocessor (section)

==Phase out==
Due to its limitations and lack of type safety (as the preprocessor is completely oblivious to C/C++ grammar, performing only text substitutions), C and C++ language features have been added over the years to minimize the value and need for the preprocessor. 

;Constant
For a long time, a preprocessor macro provided the preferred way to define a constant value. An alternative has always been to define a <code>const</code> variable, but that results in consuming runtime memory. A newer language construct (since C++11 and C23), <code>constexpr</code> allows for declaring a compile-time constant value that need not consume runtime memory.<ref>{{cite web |author1=Gabriel Dos Reis |author2=Bjarne Stroustrup |date=22 March 2010 |title=General Constant Expressions for System Programming Languages, Proceedings SAC '10 |url=http://www.stroustrup.com/sac10-constexpr.pdf |url-status=live |archive-url=https://web.archive.org/web/20180613125602/http://www.stroustrup.com/sac10-constexpr.pdf |archive-date=13 June 2018 |access-date=8 July 2024}}</ref>

;Inline function
For a long time, a function-like macro was the only way to define function-like behavior that did not incur runtime function call overhead. Via the <code>inline</code> keyword and [[optimizing compiler]]s that inline automatically, some functions can be invoked without call overhead.

;Import
The include directive limits code structure since it only allows including the content of one file into another. More modern languages support a [[modular programming|module]] concept that has public symbols that other modules import {{endash}} instead of including file content. Many contend that resulting code has reduced boilerplate and is easier to maintain since there is only one file for a module; not both a header and a body. [[C++20]] adds [[Precompiled header#Modules|modules]], and an <code>import</code> statement that is not handled via preprocessing.<ref>{{cite web|url=https://isocpp.org/files/papers/n4720.pdf|title=N4720: Working Draft, Extensions to C++ for Modules|archive-date=2019-04-30|archive-url=https://web.archive.org/web/20190430095053/https://isocpp.org/files/papers/n4720.pdf|url-status=live}}</ref><ref>{{cite web|url=https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2019/p1857r1.html|title=P1857R1 – Modules Dependency Discovery}}
</ref> Modules in C++ compile faster and link faster than traditional headers,<ref>{{cite web|url=https://learn.microsoft.com/en-us/cpp/build/compare-inclusion-methods?view=msvc-170|title=Overview of modules in C++|date=12 February 2022 |publisher=Microsoft}}</ref> and eliminate the necessity of [[include guard|{{mono|#include}} guards]] or [[pragma once|{{mono|#pragma once}}]]. Until C++26, <code>import</code>, <code>export</code>, and <code>module</code> keywords were partially handled by the preprocessor.

For code bases that cannot migrate to modules immediately, C++ also offers "header units" as a feature, which allows header files to be imported in the same way a module would. Unlike modules, header units may emit macros, offering minimal breakage between migration. Header units are designed to be a transitional solution before totally migrating to modules.<ref>{{cite web|url=https://learn.microsoft.com/en-us/cpp/build/walkthrough-header-units?view=msvc-170|title=Walkthrough: Build and import header units in Microsoft Visual C++|date=12 April 2022 |publisher=Microsoft}}</ref> For instance, one may write <syntaxhighlight lang="C++" inline>import <string>;</syntaxhighlight> instead of <syntaxhighlight lang="C++" inline>#include <string></syntaxhighlight>, or <syntaxhighlight lang="C++" inline>import "MyHeader.hpp";</syntaxhighlight> instead of <syntaxhighlight lang="C++" inline>#include "MyHeader.hpp"</syntaxhighlight>. Most build systems, such as [[CMake]], do not currently support this feature.