CODEWITHSUNDEEP
c++
Matthew G.
Matthew G.

Reputation: 1350

Recycling member functionality without inheritance

There is an interesting template presented on Wikipedia for Properties.

This template provides something interesting, in that it allows providing logic around member accesses. Building on this, we could easily build something like this: 

struct Ranged { 
  ranged_property<float,0,1> unit_property; 
};

Where the range of unit_property is enforced to be within [0,1].

How can we provide a similar functionality the depends on the hosting class' members? For example: 

struct AdjustableRanged { 
  float max; 
  ranged_property<float,0,max> influenceable_property; 
};

Where the range of influenceable_property is affected by the value of max. Keep in mind, the goal is for this kind of template to be recycled across many vastly different classes. Related concepts are mixins and decorators.

It can be done with macros... but I feel like there must be a better more idiomatic C++ solution.

Edited to add: I think this could be done by saving a reference to the member inside the ranged_property template... but that seems to be a complete waste of space for what would be effectively a constant value; ETA; A const reference may serve the purpose actually, however, I need to do the investigation.

Upvotes: 0

Views: 103

Answers (1)

Oguk
Oguk

Reputation: 1147

Following up on our discussion in the comments, it seems the functionality can be achieved with a pointer-to-member template parameter like this (but see the caveats below):

#include <iostream>

template<typename C, typename T, T C::*m>
struct PrintMember {
    C& obj;
    PrintMember(C& obj) : obj(obj) {};
    void print() { std::cout << "Member of containing class: " << obj.*m << std::endl; };
};

struct TestClass {
    int data;
    PrintMember<TestClass, int, &TestClass::data> pm;
    TestClass() : pm(*this){};
};

int main()
{
    TestClass tc;
    tc.data = 5;
    tc.pm.print();
}

This only demonstrates that it is possible to access members of the containing object. There are a few things that this approach doesn't solve:

  • If you really only want to access one member, it's not worth it, since you have to save a reference to *this in the PrintMember member to be able to dereference the pointer to member. So it doesn't actually solve the problem of having to store a reference. You could just as well pass a reference to the member variable itself in the constructor. However, if you need to access multiple members, this allows you to only store one reference (to *this) and still access all of them.

  • Specifying the template arguments of PrintMember and initializing the PrintMember member variable with *this in the constructor is tedious. Maybe, some clever template argument deduction can help here, but I haven't tried yet and I am not even sure it would get any simpler...

In some special cases, there might be dirty ways to get access to the "this" pointer of the enclosing class without saving it explicitly, like the answer using offsetof in this answer, but my feeling tells me you wanted something portable and less brittle...

Upvotes: 2

Related Questions