#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");