Encapsulation preserving operator= overloading in C++
Design
I think it obfuscates the code with no real advantage.
// This adds an object `x` to the class `example` that
// when assigned a double will forward the
// value to the private method `setx()`
OPEQ_SETTER_GETTER( example, double, setx, x );

I think it would be easier to add a public function that forwards the value.
public:
void publicSetX(double v) {setx(v);}  // ? easier to read.

Also I add my usual rant about getters/setters breaking encapsulation by exposing internal implementation details.
Code Review
Make sure this is noted as a non-owning pointer.
Owner *owner;

When you construct the object. Owner should never be nullptr
accessor ( Owner* o, Setter &amp;&amp;f ): owner( o ), setter( f ) { }

So pass owner by reference to indicate this. Its OK to store as a pointer (as its hard to copy objects with references without additional work). But your interface should be as clean as possible so there is no misunderstanding. Pass by reference to indicate it can't be nullptr and that this object is NOT taking ownership.
The setter value f can be bound to an r-value reference. But the parameter f will not pass it on as an r-value reference. Named objects can not be r-value references. So you need to use std::forward to activate perfect forwarding. Otherwise you are just activating the copy constructor (not the move constructor).
accessor ( Owner&amp; o, Setter &amp;&amp;f ): owner( &amp;o ), setter( std::forward&lt;Setter&gt;(f) ) { }

OK. For doubles passing a reference around is fine. But this is supposed to be generic. You also need to allow for move assignment.
// What if T is big.
// I would want to move the `value` into the object using assignment.
accessor &amp;operator=( const T &amp;value ) { setter( owner, data, value ); return *this; }

Reading the value generates a copy. This is not usually desirable. Especially if T is large.
operator T() const { return data; }

I would do:
operator T const&amp;() const { return data; }