Typeof

C

As of C23 typeof is a part of the C standard. The operator typeof_unqual was also added which is the same as typeof, except it removes cvr-qualification and atomic qualification (differentiating it from decltype in C++).

typeof can be useful for binding to variables of unknown type in macros. In this example, max must use temporary variables to avoid the inputs being evaluated multiple times, and uses typeof to specify the type of these temporary variables. Note that this example uses a non-standard extension to the C language, namely the use of compound statements as expressions (supported e.g. by GNU GCC)

#define max(a, b) ({ \
    typeof (a) _a = (a); \
    typeof (b) _b = (b); \
    _a > _b ? _a : _b; \
})

C++

C++ provides the decltype and typeid operators. decltype, like C's typeof, is used to abbreviate types and to give types to variables that depend on the type of generic variables, whose type is unknown (e.g. in templates or macros). typeid provides a run-time representation of the type for dynamic dispatch.

struct Double {
    double value;
}

const Double* d;

// decltype can be used in type declarations
decltype(d->value) y; // equivalent to double y;

// decltype can be used in trailing return types
// This may be necessary for overloaded operators where, for instance,
// type T + type U may result in type V distinct from T and U
template <typename T, typename U>
auto add(T t, U u) -> decltype(t + u) {
    return t + u;
}

The ^^ reflection operator, introduced in C++26, can also be used to obtain a representation of a type as a value.

import std;

using std::string;
using std::meta::info;

struct User {
    string name;
    uint32_t id;
    int age;
};

int main() {
    // reflect the User class's type metadata
    constexpr info clazz = ^^User;

    // splice [:clazz:] into User
    typename [:clazz:] john = {
        .name = "John Doe",
        .id = 123456789,
        .age = 20,
    };
    std::println("The class of {} is {}", john.name, std::meta::identifier_of(clazz));
}

C#

In C#, System.Object's GetType() method returns a System.Type value representing the run-time type of a value. The typeof operator instead provides the runtime representation of a type and does not determine the type of a value.

// Given an object, returns if it is an integer.
// The "is" operator can be also used to determine this.
bool IsInteger(object o)
{
    return o.GetType() == typeof(int);
}

Java

java.lang.Object's getClass() method can be used to return the class of any object, which is always an instance of java.lang.Class<?>. All types can be converted into a run-time representation value by appending ".class"; for a type T, T.class produces a java.lang.Class<T>. Despite the name, this is possible even if they are not classes, such as primitives (int.class) or arrays (String[].class).

String s = "Hello, world!";
Class<?> sClass = s.getClass();

Class<String> stringClass = String.class;
Class<Integer> intClass = int.class;

Object obj = /* something here */;
System.out.printf("The class of %s is %s%n", obj, obj.getClass().getName());

JavaScript

The typeof operator in JavaScript returns a string representing the basic run-time type of a value.

function isNumber(n) {
    return typeof n === 'number';
}

TypeScript

TypeScript extends the JavaScript typeof operator, allowing its use in the type of another value, representing the static type of the value.

function someFunction(param: typeof existingObject): void { 
    // ...
}

let newObject: typeof existingObject;

Python

Python has the built-in function type().

print(type(123))
# prints: <class 'int'>

VB.NET

In VB.NET, the C# variant of typeof should be translated into the VB.NET's GetType() method. The TypeOf keyword in VB.NET is used to compare an object reference variable to a data type.

The following example uses TypeOf...Is expressions to test the type compatibility of two object reference variables with various data types.

Dim refInteger As Object = 2

MsgBox("TypeOf Object[Integer] Is Integer? " & TypeOf refInteger Is Integer)
MsgBox("TypeOf Object[Integer] Is Double? " & TypeOf refInteger Is Double)

Dim refForm As Object = New System.Windows.Forms.Form

MsgBox("TypeOf Object[Form] Is Form? " & TypeOf refForm Is System.Windows.Forms.Form)
MsgBox("TypeOf Object[Form] Is Label? " & TypeOf refForm Is System.Windows.Forms.Label)
MsgBox("TypeOf Object[Form] Is Control? " & TypeOf refForm Is System.Windows.Forms.Control)
MsgBox("TypeOf Object[Form] Is IComponent? " & TypeOf refForm Is System.ComponentModel.IComponent)