隐藏 C++ 模板语法

Question

There is a class Particle with a method template property , which represents a reference to a primitive type.

particle.template property<velocity>() = 0.0;

The syntax should be more readable. The goal is something like:

particle.velocity = 0.0;

I think this could be possible using pre-processor macros or TMP libraries like Boost.Hana. But I didn't manage to make it work, yet.

Context: I am working on an embedded C++ DSL and want to make it easier to use for people unfamiliar with programming.

Answer 1

I have not worked with Boost.Hana but I can suggest this idea. Maybe useful.

#include <iostream>

#define DECL(type, name)    \
  struct name##_t           \
  {                         \
      Practice* p;          \
      operator type&();     \
      Practice::name##_t& operator= (type);\
  } name;           

#define IMPL(type, name)                        \
Practice::name##_t::operator type&()            \
{                                               \
    return p->property<type, name##_t>();       \
}                                               \
Practice::name##_t& Practice::name##_t::operator= (type x)\
{                                               \
    p->property<type, name##_t>() = x;          \
    return *this;                               \
}

struct Practice 
{
  template<class D, class T> D& property();
 
  Practice(): velocity{ this }
  {
    
  }
 
  DECL(double, velocity);
//   struct velocity_t
//   {
//       Practice* p;
//       operator double&();
//       void operator= (double);
//   } velocity;
};

template <>
double& Practice::property<double, Practice::velocity_t>()
{
    static double v;
    return v;
}

IMPL(double, velocity);
// Practice::velocity_t::operator double&()
// {
//     return p->property<double, velocity_t>();
// }
// Practice::velocity_t& Practice::velocity_t::operator= (double x)
// {
//     p->property<double, velocity_t>() = x;
//     return *this;
// }

int main()
{
    Practice practice; 
    practice.velocity = 4.8;
    
    std::cout << practice.velocity;
    return 0;
}

The solution has clear disadvantages:

1. Each pseudo field (as velocity) must have a pointer to Practice .
2. Minimum one macro definition in a header.
3. Potential difficultness if you are going to use user-defined types.

UPD: I developed the idea.

Now you have not to write more then you need. Just declare your fields and specialize property for them. But it works since C++17.

#include <iostream>
#include <string>

struct Practice;

template<class Field, class T = typename Field::type>
struct PseudoField           
{             
    using type = T;
    Practice& p;  
    
    operator type&  ();  
    decltype(auto) get() { return static_cast<type&>(*this); }
    type* operator->() { return &get(); }

    template<class D>
    PseudoField& operator= (D &&);
};

#define DECL(type, name)                        \
  struct name##_t : PseudoField<name##_t, type> \
  {                                             \
      using PseudoField::operator=;             \
  } name { *this }

struct Practice 
{
  template<class T, class D> D& property();

  DECL(double       , velocity);
  DECL(std::string  , name);
};

template<class Field, class T> 
PseudoField<Field, T>::operator T&()
{
    return p.property<Field, T>();
}

template<class Field, class T> template<class D>
PseudoField<Field, T>& 
PseudoField<Field, T>::operator= (D && x)
{
    p.property<Field, T>() = std::forward<D>(x);
    return *this;
}

template <>
Practice::velocity_t::type& 
Practice::property<Practice::velocity_t>()
{
    static double v;
    return v;
}

template <>
Practice::name_t::type& 
Practice::property<Practice::name_t>()
{
    static std::string v;
    return v;
}

int main()
{
    Practice practice; 
    practice.velocity = 4.8;
    practice.name = "hello!";
    
    auto moved = std::move(practice.name.get());
    
    std::cout   << "velocity: "         << practice.velocity    << std::endl
                << "moved name: "       << moved                << std::endl
                << "src name length: "  << practice.name->size()<< std::endl;
    return 0;
}