Is there a way to do this using templated functions in c++ - c++

Question

I'm currently writing some code to convert java code to c++ code and consequently ending up with some pretty hairy issues. My question is, is it possible to have an overloaded operator that returns the templated value from the containing class?
Ie: I want to be able to do the following with the following classes.
SmartPointer<ArrayClass<bool>*> boolArray = new ArrayClass<bool>(true, true, false, false);
bool b = boolArray[1];
template <typename T> class SmartPointer
{
T data;
template <typename U>
U operator [](int i) const
{
return ((*T)(*data))[index];
}
}
template ArrayClass<U>
{
// Various constructors...
U operator [](int i) const
{
// Implementation here
}
}
The problem I get (understandably) is:
error C2783: 'U SmartPointer::operator const' : could not deduce template argument for 'U'
The compiler doesn't know what U is and I want to be able to tell it that it's bool - because this is what the ArrayClass will be returning. The SmartPointer might not contain an array, in which case the [] operator wouldn't make sense. However I want to be able to pass it through to the object inside the smart pointer in case it does... ?
I don't know what to do to make this work. Perhaps it's not possible??
ANSWER:
Thanks to everyone for responding. There are 3 solutions provided that are essentially the same, but I've award this to Oktalist as he got in first.
I still have a difficulty with this solution though, as I'm passing pointers into my SmartPointer class to allow me to use forward declared classes. This prevented me from using T::value_type as my return type, but that appears to be the right way to do it. It looks like I'm asking to much of the compiler and it looks like I'll have to revert back to simply dereferencing the smartpointer in order to do the array access!

Answer 1

The traditional C++03 way is to use a typedef, typically named value_type. In C++11 we can improve upon this with auto and decltype. Here is your example modified to use both:
SmartPointerCPP03<ArrayClass<bool>> boolArray = new ArrayClass<bool>(true, true, false, false);
SmartPointerCPP11<ArrayClass<bool>> boolArray = new ArrayClass<bool>(true, true, false, false);
bool b = boolArray[1];
template <typename T> class SmartPointerCPP03
{
T* data;
typename T::value_type operator [](int i) const
{
return (*data)[i];
}
}
template <typename T> class SmartPointerCPP11
{
T* data;
auto operator [](int i) const -> decltype(std::declval<T>()[i])
{
return (*data)[i];
}
}
template <typename T> class SmartPointerCPP14
{
T* data;
auto operator [](int i) const
{
return (*data)[i];
}
}
template <typename U> ArrayClass
{
// Various constructors...
typedef U value_type;
U operator [](int i) const
{
// Implementation here
}
}
I also took the liberty of changing T data to T* data and removing the * from the parameter in the instantiation. By the way, your (T*) cast was wrong, and I removed that too.

Answer 2

To start with, make the SmartPointer accept the non-pointer type:
SmartPointer<ArrayClass<bool> > boolArray = new ArrayClass<bool>(true, true, false, false);
Add a typedef to the ArrayClass:
template <typename U> class ArrayClass
{
typedef U value_type;
...
};
Then write a metafunction to get the type:
template <typename T> struct ValueTypeOf {
typedef typename T::value_type type;
};
Then use this in the SmartPointer:
template <typename T>
class SmartPointer
{
typedef typename ValueTypeOf<T>::type value_type;
T* data;
value_type operator [](int i) const
{
return ((*data))[index];
}
};
By using the ValueTypeOf metafunction, you can specialize it based upon the type, so if your type does not have a value_type member, you can do something different to get at it.
Edit: to specialize for a pointer type example:
struct A {
typedef int value_type;
};
template <typename T>
struct ValueTypeOf
{
typedef typename T::value_type type;
};
template <typename T>
struct ValueTypeOf<T*>
{
typedef typename T::value_type type;
};
int main()
{
ValueTypeOf<A>::type foo = 0; // foo is an int
ValueTypeOf<A*>::type bar = 0; // bar is an int
return 0;
}

Answer 3

It's been a while, but I used to do a lot of this. Something like the following should work:
Define a typedef in ArrayClass called value_type, and typedef U to that. Then use T::value_type as the return type of operator [] in SmartPointer.