How to Get and Print a Variable Type in Standard C++

By the end of this page, you will understand how C++ handles type information at compile time and runtime, why there is no standard typeof operator that directly prints int, and how tools like typeid, type traits, and compiler-specific name demangling are commonly used instead.

C++ does not provide a standard feature that guarantees you can write code like this:

std::cout << typeof(a);

and get a clean human-readable type name such as int.

The core idea is that types in C++ are mainly a compile-time concept. The compiler uses type information to check correctness, choose overloads, generate code, and optimize programs. But once the program runs, that exact source-level type name is not always preserved in a portable, readable form.

What standard C++ does provide

Standard C++ provides runtime type information through typeid:

#include <iostream>
#include <typeinfo>

int main() {
    int a = 12;
    std::cout << typeid(a).name() << '\n';
}

This gives you a type name string, but there is an important limitation:

• typeid(...).name() is implementation-defined
• That means the output depends on the compiler
• It may print int, or it may print something cryptic like

Think of a C++ type like a label on a package while it is being sorted in a warehouse.

• During sorting, the label is extremely important
• Workers use it to send the package to the right place
• But after shipping, the warehouse system may not keep the original label in a neat, human-friendly form

In the same way, the C++ compiler depends heavily on type information while building your program. But at runtime, you are not guaranteed to get the exact source-code name back as a clean string.

So:

• compiler stage = types are rich and important
• runtime stage = some type info may exist, but readable names are limited

Standard approach with typeid

#include <iostream>
#include <typeinfo>

int main() {
    int a = 12;
    std::cout << typeid(a).name() << '\n';
}

What this does

• typeid(a) returns a std::type_info object describing the type
• .name() returns a C-style string representing that type
• The exact string is compiler-dependent

Example with multiple types

#include <iostream>
#include <string>
#include <typeinfo>

int main() {
    int a = 12;
     b = ;
    std::string c = ;

    std::cout << (a).() << ;
    std::cout << (b).() << ;
    std::cout << (c).() << ;
}

Consider this example:

#include <iostream>
#include <typeinfo>

int main() {
    int a = 12;
    std::cout << typeid(a).name() << '\n';
}

Step-by-step

1. int a = 12;

A variable named a is created with type int and value 12.

2. typeid(a)

The expression typeid(a) asks C++ for type information about a.

This produces a std::type_info object representing the type.

3. .name()

Calling .name() on that object returns a string-like C-style name for the type.

Debugging template code

When working with templates, developers often want to inspect what type the compiler deduced:

template <typename T>
void printType(const T& value) {
    std::cout << typeid(value).name() << '\n';
}

This can help during development, especially when generic code becomes hard to follow.

Logging unexpected values

In serialization, parsing, or generic utility code, you may log the type of a value when debugging behavior.

Verifying polymorphic behavior

With base-class references or pointers, typeid can help inspect the dynamic type when runtime type information is enabled and polymorphism is involved.

Unit testing generic utilities

Developers sometimes check that a helper produces the expected type using decltype and type traits instead of printing names.

static_assert(std::is_same_v<decltype(1 + 2), int>);

This is more reliable than printing type names.

In real C++ projects, developers usually do not rely on printing raw type names for core logic.

Common patterns

Guarding behavior with type traits

#include <type_traits>

template <typename T>
void process(const T& value) {
    if constexpr (std::is_integral_v<T>) {
        // handle integers
    } else {
        // handle other types
    }
}

This is common in template-heavy code.

Using decltype for deduced types

auto x = 10;
decltype(x) y = 20;

Developers use this to keep types consistent without manually repeating them.

Debug-only type inspection

std::cerr << "Type: " << typeid(value).name() << '\n';

This is often used temporarily while debugging.

Mistake 1: Expecting typeof to be standard C++

int a = 12;
std::cout << typeof(a) << '\n';

This is not standard C++.

Fix

Use decltype for type deduction in code, or typeid for runtime inspection.

std::cout << typeid(a).name() << '\n';

Mistake 2: Assuming typeid(...).name() always prints int

int a = 12;
std::cout << typeid(a).name() << '\n';

You might expect:

int

But some compilers may print encoded names.

Fix

Treat .name() as useful for debugging, not as a portable user-facing string.

Quick reference

Print a type name candidate

#include <typeinfo>
std::cout << typeid(x).name() << '\n';

• Standard C++: yes
• Exact string output: not portable

Compare a variable's type

if (typeid(x) == typeid(int)) {
    // x is int
}

Get a type in code

decltype(x) y = x;

• decltype(x) is a type, not a string

Compile-time type check

#include <type_traits>

if constexpr (std::is_same_v<decltype(x), int>) {
    // x is int
}

Rules to remember

Can I print int exactly in standard C++?

Not portably. typeid(x).name() is standard, but the exact text it returns is implementation-defined.

Is typeof valid in C++?

Not in standard C++. Some compilers support it as an extension, but portable C++ should not rely on it.

What should I use instead of typeof in standard C++?

Use decltype to refer to a type in code, and typeid if you need runtime type information.

Why does typeid(a).name() print i instead of int?

Because the format of the returned name depends on the compiler implementation. Some compilers return mangled or abbreviated names.

How do I check whether a variable is an int?

Use typeid(a) == typeid(int) at runtime, or std::is_same_v<decltype(a), int> at compile time.

Is decltype(a) the same as typeid(a)?

No. gives you a type in code at compile time. gives type information at runtime.

• decltype — used to obtain the type of an expression in standard C++.
• typeid — provides runtime type information for expressions and objects.
• std::type_info — the type returned by typeid, including the .name() member.
• Type traits — tools like std::is_same and std::is_integral for compile-time type checks.
• auto — lets the compiler deduce a variable's type automatically.
• Templates — generic programming often makes type inspection and type checks important.
• RTTI — runtime type information is the broader feature behind typeid.
• static_assert — useful for enforcing compile-time type expectations.