Store or reflect on the "reference level" of a variable - c++

Question

Is there a way in C++ to reflect on the "number of levels of pointer" of a variable, (for example, int* a is 1 level, int** b is 2 levels, and int c is 0 levels)
..Other than using typeid and parsing the string that comes out of that?
The reason I'm asking is I am using pointers to member functions, and I need to know whether to invoke the member function as obj->func() or obj.func(), at compile time really.

Answer 1

If obj is a T**, doing obj.*foo is ill-formed. So you only need to figure out whether it is a pointer or a non-pointer. You can use overloading for this.
template<typename T, typename M> void f(T *obj, M m) { // pointer
(obj->*m)();
}
template<typename T, typename M> void f(T &obj, M m) { // not a pointer
(obj.*m)();
}
This has the drawback that it only works with zero-parameter member function pointers, and it won't return the value (if any) that those functions return. You cannot do the following (which can easily be implemented), because both branches will be type-checked
if(is_pointer(obj)) v = (obj->*m)(arg...); else v = (obj.*m)(args...);
What you can do is to just call a function to dereference your object, if it is a pointer
template<typename T> T &deref(T *t) { return *t; }
template<typename T> T &deref(T &t) { return t; }
Then you can say
v = (deref(obj).*m)(args...);

Answer 2

You could use std::is_pointer from the type_traits header in TR1 (which uses partial specialization to produce an answer), but it might be simpler to just use overload resolution.
Here's an example, assuming void return, no arguments, and no need to handle more than one level of indirection:
template <typename T, typename F>
inline void invoke(T& obj, F func)
{
(obj.*func)();
}
template <typename T, typename F>
inline void invoke(T* obj, F func)
{
(obj->*func)();
}
If you need to handle more than one level of indirection, you can replace the second function with this:
template <typename T, typename F>
inline void invoke(T* obj, F func)
{
invoke(*obj, func);
}
This will recursively strip off levels of indirection until you end up with something that you can invoke your member function on.

Answer 3

Partial template specialization will tell you quite easily:
template<typename T>
struct PtrLevel
{
enum { value = 0 };
};
template<typename TTarget>
struct PtrLevel<TTarget*>
{
enum { value = PtrLevel<TTarget>::value + 1 };
};
Demonstration: http://ideone.com/ZPH8X
In C++0x, you could probably use decltype and SFINAE to handle smart pointers in such a way that they are reported as having a non-zero pointer level.

Answer 4

A bit of template magic to the rescue:
template<typename T>
struct Depth { enum DepthEnum { value = 0 };};
template<typename T>
struct Depth<T*> { enum DepthEnum{ value = Depth<T>::value +1 };};
template<typename T>
size_t getDepth(T const& o)
{
return Depth<T>::value;
}
int main()
{
int a0;
int* a1;
int** a2;
int*** a3;
int**** a4;
int***** a5;
int****** a6;
std::cout << getDepth(a0) << std::endl;
std::cout << getDepth(a1) << std::endl;
std::cout << getDepth(a2) << std::endl;
std::cout << getDepth(a3) << std::endl;
std::cout << getDepth(a4) << std::endl;
std::cout << getDepth(a5) << std::endl;
std::cout << getDepth(a6) << std::endl;
}
Output:
> g++ test.cpp
> ./a.out
0
1
2
3
4
5
6
Going back to the reason you want it. That seems a bit suspect. Your compiler already knows what version to sue at compile time. Remember C++ is very strict on its typing and this information is known at compile time thus if you use the wrong version you will get a compiler error.

Answer 5

I am not aware of any built in way to do this, but you could implement a small template class that simulates a "counting pointer" in the sense that you can easily determine your "pointer depth" like this:
template <typename T> class Ptr {
private:
T* ptr;
int d;
public:
// overload all meaningful operators, like * etc.
// e.g.
T& operator*() {
return *T;
}
int depth() const {
return d;
}
}

Answer 6

as long as your pointer is valid you can use the following code: it'll give you refrence level to the object you pass to it (and just by a little change you can change it to return the object pointers refer to, just use comments instead of acual code and directly use countPartial):
template <class T> int countPartial(T *x,int depth)
//use template <class T> T& countPartial(T *x)
{
return countPartial(*x,depth+1);
//return countPartial(*x);
}
template <class T> int countPartial(T &x,int depth)
//use template <class T> T& countPartial(T &x)
{
return depth;
//return x;
}
template <class T> int count(T x)
{
return countPartial(x,0);
}

Answer 7

probably this shud solve ur trouble
T is template.
funcptr the ptr to function.
int callfunc( T ptr)
{
depth = 0;
if ( typeof(ptr)!= typeof(funcptr))
{
depth++;
depth = depth + callfunc(*ptr);
}
return depth;
}