C++ Interview Questions

The decltype keyword in C++ is used for type deduction, which allows the compiler to deduce the type of an expression. Introduced in C++11, decltype is particularly useful in templates and situations where the type of an expression needs to be inferred without explicitly specifying it. This feature enhances the flexibility and expressiveness of the language, making it easier to write generic and reusable code.

Syntax:
The syntax for decltype is straightforward. It takes an expression as an argument and produces a type that matches the type of the expression.

decltype(expression)

The resulting type is the exact type of the expression, including any const-qualification and reference-qualification.

Basic Usage:
One of the simplest uses of decltype is to deduce the type of a variable or a function return type.

int x = 10;
decltype(x) y = 20; // y is of type int
std::cout << "Type of y: " << typeid(y).name() << std::endl; // Outputs: int

In this example, decltype(x) deduces the type of x (which is int) and assigns it to y.

Using with Functions:
decltype can also be used to deduce the return type of a function.

int add(int a, int b) { return a + b; }
decltype(add(1, 2)) sum = add(3, 4); // sum is of type int
std::cout << "Sum: " << sum << std::endl; // Outputs: Sum: 7

Here, decltype(add(1, 2)) deduces the return type of the add function, which is int.

Using with Auto:
decltype is often used in conjunction with auto to deduce complex types.

auto getValue = [](int n) -> double { return n * 2.5; };
decltype(getValue(10)) value = getValue(5); // value is of type double
std::cout << "Value: " << value << std::endl; // Outputs: Value: 12.5

In this example, decltype(getValue(10)) deduces the return type of the lambda function, which is double.

Templates and decltype:
decltype is particularly useful in templates to deduce the type of expressions involving template parameters.

template <typename T1, typename T2>
auto add(T1 a, T2 b) -> decltype(a + b) {
    return a + b;
}

int main() {
    auto result = add(3, 4.5); // result is of type double
    std::cout << "Result: " << result << std::endl; // Outputs: Result: 7.5
    return 0;
}

In this template function, decltype(a + b) deduces the type of the expression a + b, which is used as the return type of the function.

Combining with Const and References:
decltype can accurately deduce types with const-qualification and reference-qualification.

int x = 5;
const int& ref = x;
decltype(ref) y = x; // y is of type const int&
std::cout << "Type of y: " << typeid(y).name() << std::endl; // Outputs: int const&

In this example, decltype(ref) deduces the type const int&, accurately reflecting the type of ref.

Advanced Example:
Using decltype with lambda expressions and templates to perform complex type deductions.

#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    std::vector<int> vec = {1, 2, 3, 4, 5};
    auto lambda = [](int a, int b) { return a + b; };
    decltype(lambda) anotherLambda = lambda;
    int sum = anotherLambda(3, 4);
    std::cout << "Sum: " << sum << std::endl; // Outputs: Sum: 7

    // Using decltype in a template
    auto multiply = [](auto a, auto b) -> decltype(a * b) { return a * b; };
    auto result = multiply(3, 4.5);
    std::cout << "Result: " << result << std::endl; // Outputs: Result: 13.5

    return 0;
}

In this example, decltype is used to deduce the type of a lambda expression and a template function's return type, demonstrating its power in handling complex type deductions in modern C++.

Summary:
The decltype keyword in C++ provides a powerful way to deduce the type of an expression at compile time. It is particularly useful in templates, generic programming, and situations where the exact type of an expression needs to be inferred. By using decltype, developers can write more flexible and maintainable code, leveraging the power of C++'s type system. This feature enhances the expressiveness of the language, making it easier to create generic and reusable components.