A proxy replacement for getters and setters
It's always going to be ugly
Getters and setters are never going to be as pretty in C++ as in some other languages that natively support them. Maybe something nice will be possible in a future C++ standard, but certainly not if you are stuck with C++11.
If you are going to use this to proxy member variables of a class, then the best syntax I can come up with is:
class foo {
    int x{123};
    static int getter(foo *self) { return self-&gt;x; }
    static void setter(foo *self, int val) { self-&gt;x = val; }
public:
    auto datum() { return make_proxy(this, getter, setter); }
};

The above allows the getter and setter access to the whole class, in case it wants to update multiple variables, or if the getter returns some function of multiple member variables. But unless you can reuse getters and setters, there is really not much point to it in my opinion.
The main reason is that either you have to write my_foo.datum() = 456, which has the added parentheses that make it not look like you are setting a regular member variable, or you have to declare datum like so:
class foo {
    ...
public:
    proxy&lt;foo *, decltype(getter), decltype(setter)&gt; datum{this, getter, setter};
};

That will allow you to write my_foo.datum = 456.
The former doesn't even work with C++11, since auto return type deduction doesn't work in that situation. You could add a trailing return type, but it will be ugly and repetetive. The latter has the overhead of storing three pointers for each proxy variable in your class.
It doesn't handle const instances
Your proxy class doesn't work if you create a const instance of a class that uses proxy member variables, for example:
const foo my_foo;
return my_foo.datum();

You could probably create a class const_proxy that only has a getter, and which ensures const is used in the right places, and then overload the proxy member like so:
class foo {
    ...
public:
     auto datum() { return make_proxy(this, getter, setter); }
     auto datum() const { return make_const_proxy(this, getter); }
};

But that adds even more noise.