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

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

#define get_var_name(var) #var

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

#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

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: