cppinsights.io

What is C++ Insights?

C++ Insights is an online tool that shows how a C++ compiler interprets your source code. You paste code into the Source panel, and the Insight panel displays a transformed version that makes implicit compiler behavior explicit. A Console panel shows program output, and you can pick a language standard from C++98 through C++23 and C++2c.

It is aimed at people who want to understand what the language actually does before or beneath the surface syntax. Typical uses:

• Seeing how range-based for loops become ordinary while loops.
• Watching implicit casts appear where the compiler inserts them.
• Expanding template parameters of a call expression so you can see what was deduced.
• Inspecting noexcept internals, object lifetime, or padding information.
• Viewing coroutine transformations and a C++ to C transformation.

The toggles are the point. You can turn individual transformations on or off, so you can isolate one behavior at a time instead of reading a wall of generated code. That makes it useful for teaching, for debugging surprising overload or conversion results, and for preparing examples when explaining C++ to someone else.

A practical next step: paste a small snippet that confuses you — say, a lambda, a structured binding, or a template call — and enable only the transformation relevant to your question. Compare the Insight output with the original Source line by line. If you want a second perspective on the same code, Compiler Explorer lets you inspect actual assembly and compiler diagnostics, while cppreference.com is the reference for the underlying rules. C++ Insights is made by Andreas Fertig; the site lists GitHub, Patreon and GitHub Sponsor links, plus a YouTube channel and examples.

How do I use C++ Insights to see the compiler's view of my C++ code?

Paste your C++ into the Source: panel on C++ Insights and read the transformed code in the Insight: panel. It rewrites your source as a compiler would after desugaring, so you see what the language actually does rather than what the surface syntax suggests. The Console: panel shows output when you enable transformation options that produce runnable code.

A practical first run

1. Choose your standard in the version selector (C++98 through C++23 and C++2c are listed) so templates and features expand the way your toolchain would.
2. Start with a small snippet: a range-based for loop, a lambda, an auto variable, or a class with a constructor.
3. Read the insight top to bottom. Range-for becomes an iterator loop; lambdas become closure classes with an operator(); auto becomes the deduced type; implicit conversions appear as explicit casts.
4. Toggle one option at a time so you can attribute each change to a specific setting.

Options worth knowing

The page exposes toggles such as for-loops as while-loops, array subscription, show all implicit casts, show all template parameters of a CallExpr, show noexcept internals, show padding information, show coroutine transformation, show C++ to C transformation, show object lifetime, and transform std::initializer_list. A Use libc++ option changes which standard library is used for expansion, and there is an option to include examples.

Who gets the most from it

• Learners working through move semantics, value categories, or template deduction, who benefit from seeing the desugared form next to the original.
• Interview preparation, where "what does the compiler generate for this lambda?" is a common question.
• Debugging surprises: unexpected copies, hidden conversions, or padding you did not anticipate.
• Teaching and writing: producing a before/after pair that shows a mechanism instead of describing it.

Trade-offs

The insight is a teaching transformation, not a disassembly or an exact record of one compiler's output. It will not show your optimizer's decisions, inlining, register allocation, or the machine code your build actually emits. Treat it as a model of language-level rewriting: excellent for semantics, not a substitute for inspecting real generated assembly when performance is the question. Very large translation units also become hard to read once everything is expanded, so isolate the construct you care about.

Next step

Take one construct that confuses you, reduce it to the smallest snippet that still shows the behaviour, and expand it with a single relevant option enabled. Then compare the insight against the standard's description of that construct, so you learn the rule rather than one rendering of it.

What does the 'Show all implicit casts' option reveal about my code?

The "Show all implicit casts" option makes the compiler's invisible work visible. When you enable it, C++ Insights rewrites your source so that every conversion the compiler performs silently — a float promoted to double, an int narrowed to char, a user-defined type converted through a constructor, a derived pointer adjusted to a base pointer — appears as an explicit cast in the generated "Insight" pane. You keep writing the same code; the tool shows you what the compiler actually did with it.

What it is useful for

• Tracking down surprising overloads. If f(42) calls an overload you did not expect, the explicit cast in the insight view shows which conversion won and why.
• Finding hidden constructor calls. Implicit conversions via non-explicit constructors become visible, which is often where accidental temporaries and copies come from.
• Teaching and code review. It is a fast way to show a colleague or a class why a line is less obvious than it looks.
• Deciding where to add explicit. Seeing the implicit conversion in print is a good prompt to ask whether the constructor should have been marked explicit.

Trade-offs

The output gets noisier. Every arithmetic promotion and every standard conversion is spelled out, so on a large function the insight pane can become harder to scan than the original. It works best on a small, focused snippet rather than a whole file. It also shows what the compiler does with your code, not what you should have written — it is a diagnostic lens, not a style guide.

A concrete scenario

Suppose you write void log(std::string); and call log("hello"). Turn the option on and the insight view shows the const char* being turned into a std::string temporary — a heap allocation you may not have been thinking about at the call site. That is the kind of thing this option surfaces.

Next step

Paste a short function into C++ Insights, toggle "Show all implicit casts," and compare the Source and Insight panes side by side. If one line produces more casts than you expected, that line is your candidate for an explicit constructor, a matching overload, or a direct-initialization change.

How can I use C++ Insights to understand template parameter deduction?

Paste a snippet that calls a template function, then read the "Insight" panel. C++ Insights rewrites your code into what the compiler effectively sees: template arguments become explicit, auto is replaced by its deduced type, and implicit conversions, casts, and lambda closures are spelled out. For template deduction, this turns guesswork into reading — you can see exactly which type was bound to each parameter, and where a deduction failed to match your expectation.

On C++ Insights, the useful controls sit above the panes:

• C++ standard selector (C++98 through C++23/2c) — deduction rules changed across versions, especially around auto, class template argument deduction (C++17), and abbreviated function templates (C++20). Switch standards to see the same code transform differently.
• Show all template parameters of a CallExpr — the key toggle for your question. It exposes the arguments the compiler supplied to each instantiated call.
• Show all implicit casts — reveals conversions applied to arguments before binding, which often explain why a parameter deduced a different type than you wrote.
• Show C++ to C transformation and Show coroutine transformation — deeper rewrites, useful later but noisy for a first look at deduction.

A concrete scenario: write a forwarding-reference overload template <class T> void f(T&& x) and call it with an lvalue and an rvalue. The insight panel shows T deduced as int& in one case and int in the other, with the reference collapsing made explicit. That is the classic case where reading the transformed output beats reasoning about the rules from memory. Do the same for a function taking std::vector<T> and pass a std::vector<int> — you see T = int directly rather than inferring it.

Two trade-offs worth knowing. First, this is a teaching view, not the compiler's internal AST: the output is a readable approximation, so treat surprising results as a prompt to test with your real compiler. Second, the transformation is verbose — for heavily templated code the insight pane can be long, so isolate one call per experiment rather than pasting a whole file.

Next step: take a deduction you find confusing, reduce it to a single function call, and toggle "Show all template parameters of a CallExpr" on and off to compare. If you want a second opinion on the same snippet, Compiler Explorer shows real compiler errors and instantiation traces alongside the assembly, which complements rather than replaces this view.

What is the difference between the Source, Insight, and Console panels in C++ Insights?

C++ Insights shows three linked panes when you paste code into the editor: Source, Insight, and Console. They serve different purposes in the same transformation workflow.

Source is your original input — the C++ code you write or paste, using the language standard and transformation options you select.

Insight is the compiler's-eye view. It shows the transformed version of your code after C++ Insights applies its expansions, such as turning range-based for loops into ordinary loops, making implicit casts explicit, or expanding template parameters. This is the pane you read to understand what the compiler effectively sees.

Console is for program output and diagnostics. If your code produces runtime output, or if the transformation hits an error or warning, that feedback appears here rather than mixed into the transformed code.

A practical way to use them together: put a short snippet with a range-based for loop in Source, pick a language standard, then read Insight to see the equivalent loop form. If you add something that prints, check Console for the result. For broader background, see C++ Insights.

Can C++ Insights show me how my code looks after C++ to C transformation?

Yes. C++ Insights includes a transformation view that shows how your code could look when translated toward C, alongside its usual compiler-eye expansions.

The page lists "Show C++ to C transformation" among its display options, so you can enable it for a given snippet and compare the original source in the Source pane with the transformed result in the Insight pane. It sits next to related options such as showing implicit casts, template parameters, noexcept internals, object lifetime, and coroutine transformation — all of which serve the same purpose: making compiler-generated structure visible instead of hidden.

What this is good for

• Learning how high-level constructs lower. Classes, member functions, references, range-for, and similar features get rewritten into more explicit forms, which helps when a C++ concept feels abstract.
• Debugging surprising behavior. If a value is copied, a temporary is created, or an overload resolves unexpectedly, seeing the lowered form often explains it faster than reading the standard.
• Teaching and code review. A lowered view is a concrete artifact to point at in a lecture, a study group, or a pull request discussion.

What it is not

The output is an illustrative transformation, not a C compiler's real output and not a guarantee of what any particular compiler emits. It is meant for understanding, not for producing buildable C or for measuring performance. Treat it as a didactic model, and verify anything performance- or ABI-critical with your actual toolchain.

A practical workflow

1. Paste the smallest snippet that still shows the behavior you care about.
2. Select the C++ standard version you target, since lowering differs across C++98 through C++23 and beyond.
3. Turn on the "Show C++ to C transformation" option and read the Insight pane next to the Source pane.
4. If output is noisy, disable other options (implicit casts, padding, template parameters) so only the transformation you want remains.

For background on the tool, its examples, and the author's explanations, see C++ Insights. If you want to reason about what a real compiler does with the same code, pair this with a compiler explorer such as Compiler Explorer, which shows actual generated assembly and diagnostics rather than a pedagogical lowering.