Advanced Template question

[AdrianH]

Hi all,

I am working on some specialty template library, trying to write a template class that will not allow a constant type.

I've only come up with the following:

template <class T>
class X
{
  private:
    T* pObj;
  public:
    X(T* pObj)
    : pObj(pObj)
    {
#ifndef NDEBUG
      *(this->pObj)=*pObj;
#endif
    }
};
 

But this has the drawback that if T's copy constructor is private, this will not work. Is there a way of making T not be a constant. Also, if the writer of class T made the constructor wrong, it could do bad things like cause a memory leak if the copy constructor doesn’t check to see if the object it is about to copy is itself.

Is there a simpler way?


Adrian

[Motoma]

Very good questions, I'm responding only so I can see the answer.

[AdrianH]

I figured it out. Just used the idea of the assignment operator, which is similar to memcpy(void *, void const *, size_t). So what was needed was to have a function that was similar to that, as I don't really need to copy anything, I made a dummy function that took a void * and a void const *. This is the result:

template <class T>
class X
{
  private:
    T* pObj;
    void noConstTTest(void *, void const *)
    {
      // If I don't put something here, compiler warns me that this doesn't do
      // anything.  It still doesn't do anything but it shuts the compiler up. :)
      (void)0;
    }
 
  public:
    X(T* pObj)
    : pObj(pObj)
    {
      noConstTTest(this->pObj, pObj);
    }
};
 

I don't even need the pre-processor if/endif statements as the compiler should be able to optimise the call out.

Sneaky eh? ;)


Adrian

[AdrianH]

Doh, I didn't even need to make it as complicated as I did. All I want to check is if the type is a constant. Here is simpler the result:

template <class T>
class X
{
  private:
    T* pObj;
 
  public:
    X(T* pObj)
    : pObj(pObj)
    {
      // Keep T from being constant
      void * noConstTTest;
      noConstTTest = reinterpret_cast<T*>(NULL);
    }
};
 

The way this works is that all pointers upcast to constant void pointers, but do not upcast to void pointers unless the original pointer was not pointing at a constant type.

Interesting eh?


Adrian

[Motoma]

Interesting eh?
Adrian

Quite! Thanks for posting back!