#include <iostream>
#include <regex>

template <typename T, T& var>
std::string get_variable_name() {
  std::string str(__PRETTY_FUNCTION__);
  std::smatch match;
  std::regex pattern("T& var = (\\w+)");
  std::regex_search(str, match, pattern);
  return match[1];
}

char char_1;
int int_2;
double double_3;
float float_4;
std::string string_5;

int main()
{
   std::cout << get_variable_name<decltype(char_1), char_1>() << std::endl;
   std::cout << get_variable_name<decltype(int_2), int_2>() << std::endl;
   std::cout << get_variable_name<decltype(double_3), double_3>() << std::endl;
   std::cout << get_variable_name<decltype(float_4), float_4>() << std::endl;
   std::cout << get_variable_name<decltype(string_5), string_5>() << std::endl;
}

char_1
int_2
double_3
float_4
string_5

X>int var;
X>constexpr const char *varname = get_var_name(var);
X>

#define get_var_name(var) #var

int var;
constexpr const char *varname = get_var_name(var);

#define NAMEOF(variable) ((decltype(&variable))nullptr, #variable)

struct my_struct
{
  inline void my_func(int arg1, int arg2);
};

template <typename C, typename R, typename ...Args>
auto std::bind(R C::*fptr func) 
{
#   pragma message (get_arg_identifier<1, decltype(func)>())
    return bind_impl(func);
}

template <typename Arg>
inline auto foo (Arg arg)
{
   expr_of<decltype(arg)>::type 
    expr;

   do_something_with_expression<decltype(arg)>();

   return expr(1, 2, 3);
}

void foomain() {
   int x0 = 0, x1 = 1, x2 = 2;
   foo(x0 * (x2 + x1));          
}

The first of these is __func__, which is part of the C99 standard:

#include <iostream>

template <char const* c>
struct cmpval
{
  ~cmpval() { std::cout << c <<std::endl; }
};

char string_value[] = "string value";

int main()
{
  cmpval<string_value> s_type;

# pragma message __PRETTY_FUNCTION__
  return 1;
}

ust as a heads up for those here in Jacksonville...

Our evening session tonight (2018-03-14) will actually cover *all* the reflection material this week. Unless we run out of time with substantial unfinished work, we will avoid the Friday evening session.

The discussion will focus on, in order:
http://wg21.link/p0953 — constexpr reflexpr
http://wg21.link/p0954 — what do we want to do with reflection?
http://wg21.link/p0707 — metaclasses (just a brief update)

We will also briefly discuss a plan for offline feedback for p0957.

There are also late papers on implementation experience attached to the wiki (p0992, p0993). While we won't explicitly cover them as they arrived during the week and talking to folks I don't think people have had time to dig into them at all. But I want to draw folks' attention to this.

struct mystruct
{
   int f0_; 
   std::string f1_;
   int foo(int a0, int a1, std::string const& a2);
};

METACLASS(mystruct, f0_, f1_, foo);

int main() {
   
   myserializer() << mystruct { 0, "1" };

   auto r = cast<int>(callbyname(mystruct{0, "1"}, "foo", 1, 2, "3"));

   static_assert(metaclass_find_func<mystruct, foo_tag>::value, "Func not found.");
   
   int r = call_by_tag<foo_tag>(mystruct{0, "1"}, 1, 2, "3");

   //This a problem 
   make_json_call<foo_tag>(mystruct{0, "1"}, 1, 2, "3");

}

Expanding __func__ at preprocessing time requires the preprocessor to know which function it's processing. The preprocessor generally doesn't know that, because parsing happens after the preprocessor is already done. Some implementations combine the preprocessing and the parsing, and in those implementations, it would have been possible for __func__ to work the way you'd like it to. In fact, if I recall correctly, MSVC's __FUNCTION__ works like that. It's an unreasonable demand on implementations that separate the phases of translation though.

У майкрософта свой вэй

#include <iostream>

template <typename T>
constexpr size_t get_pretty_function_size()
{
  return sizeof(__PRETTY_FUNCTION__);
}

static_assert(87 == get_pretty_function_size<int>(), "invalid size");
static_assert(90 == get_pretty_function_size<double>(), "invalid size");
static_assert(116 == get_pretty_function_size<std::string>(), "invalid size");

R>#include <iostream>

R>template <typename T>
R>constexpr size_t get_pretty_function_size()
R>{
R>  return sizeof(__PRETTY_FUNCTION__);
R>}

R>static_assert(87 == get_pretty_function_size<int>(), "invalid size");
R>static_assert(90 == get_pretty_function_size<double>(), "invalid size");
R>static_assert(116 == get_pretty_function_size<std::string>(), "invalid size");
R>

template <int SS> struct sizeof_struct { char a__[SS]; };

template <typename T, int Size>
inline sizeof_struct<Size> count_of_array(T (&a)[Size]) {}

int main()
{
   static_assert(sizeof(count_of_array("")) == 1, "It is not a compiletime array");
}

template <typename T, size_t I>
constexpr char get_pretty_function_at()
{
  return __PRETTY_FUNCTION__[I];
}

static_assert('i' == get_pretty_function_at<int, 42>(), "invalid symbol");
static_assert('e' == get_pretty_function_at<double, 55>(), "invalid symbol");
static_assert('b' == get_pretty_function_at<std::string, 64>(), "invalid symbol");

R>template <typename T, size_t I>
R>constexpr char get_pretty_function_at()
R>{
R>  return __PRETTY_FUNCTION__[I];
R>}

R>static_assert('i' == get_pretty_function_at<int, 42>(), "invalid symbol");
R>static_assert('e' == get_pretty_function_at<double, 55>(), "invalid symbol");
R>static_assert('b' == get_pretty_function_at<std::string, 64>(), "invalid symbol");
R>

  static_assert("1"[0] == '1', "It is not a compiletime array");

static_assert("1"[0] == '1', "no ");

static_assert(std::is_same<search<STR("w++"), STR("[\+]+")>::value, STR("++")>::value, "Not matched");