Template overload of operator ++/--

I'd like to do an overlord of operator ++ and -- for my class with templates, like this:

Code:

---

template<typename T> CValueHandler& operator ++ ();

---

But the thing is, that while it compiles fine, I can't call that overloaded operator.

Code:

---

SomeClass myClass;
myClass++;

---

Compiler simply complains it can't find a suitable overload.
So, my question is, is it possible to overload ++/-- and use templates too? I can't seem to find a good place to fit in a template type either:

Code:

---

SomeClass myClass;
myClass<UINT64>++;

---

Doesn't work either.
Using Visual Studio 2005.

http://new-brunswick.net/workshop/c+...html#faq-13.14
You overloaded the prefix form, yet tried to use the postfix form.

Oh, I see. Thanks for the answer.
I refine it to

Code:

---

template<typename T> void operator ++ (int);

---

But it still won't let me compile since it can't determine the value of T:

Code:

---

Error        5        error C2783: 'void CSyncClass::CValueHandler::operator ++(int)' : could not deduce template argument for 'T'

---

Code:

---

rTemp<UINT64>++;

---

Still doesn't work.
So any more tips?

Returning void from an overloaded ++ function is neither of the options listed in the FAQ.

From what I see in the FAQ, either it's:

Code:

---

Number  operator++ (int); // postfix ++

---

or

Code:

---

void    operator++ (int);

---

So I changed it to:

Code:

---

template<typename T> CValueHandler& operator ++ (); // Prefix
template<typename T> CValueHandler& operator -- (); // Prefix
template<typename T> CValueHandler operator ++ (int); // Postfix
template<typename T> CValueHandler operator -- (int); // Postfix

---

Prefix returns a reference of itself; the new data is returned.
Postfix returns a copy of itself before the new data is acquired, so it returns old data.
That's how it's supposed to work, from what I understand.

For that matter, I just want to be able to get the code actually compiling since I can't deduce the template T argument.

If you want it to return void.
Try like this

Code:

---

#include <iostream>
using namespace std;

template <class T>
class Number {
public:
    Number():data() {}
    void operator ++ ()  { data ++; }
    T & get() { return data; }
    template <class U> friend  ostream & operator << ( ostream &, const Number<U> & );
private:
    T data;
};

template <class U>
ostream & operator << ( ostream &str , const Number<U> & u ) {
    str << u.data;
    return str;
}

int main() {
    Number<int> n;
    cout << n << endl;
    ++n;
    cout << n << endl;
}

---

Kurt

Let's forget about the operators for now... I need, or want, to know if it's possible to call the overloaded operators when there's no argument that takes T. Which is my main problem; the code won't compile because it can't deduce T.

Quote:

---

Originally Posted by Elysia

Let's forget about the operators for now... I need, or want, to know if it's possible to call the overloaded operators when there's no argument that takes T. Which is my main problem; the code won't compile because it can't deduce T.

---

This statement doesn't make much sense without context.
Show some code.
Kurt

Class CValueHandler - the one with the overloaded operators.

Code:

---

class CValueHandler
{
        ...
        template<typename T> CValueHandler& operator ++ (); // Prefix
        template<typename T> CValueHandler& operator -- (); // Prefix
        template<typename T> CValueHandler operator ++ (int); // Postfix
        template<typename T> CValueHandler operator -- (int); // Postfix
        ...
};

---

Sync is declared as:

Code:

---

CSyncClass Sync;

---

Which has an overload that returns a CValueHandler&:

Code:

---

class CSyncClass
{
        ...
        const CValueHandler& operator [] (CString strName);
        ...
};

---

And here's what I try to do - call operator ++ (postfix):

Code:

---

UINT64 n = Sync["nNumOfDirs"]++;

---

(Of course, it's just test code yet.)
Which gives me the error:

Code:

---

error C2783: 'CSyncClass::CValueHandler CSyncClass::CValueHandler::operator ++(int)' : could not deduce template argument for 'T'

---

You can tell it like that

Code:

---

a.operator++<int>();

---

But then the syntax is so ugly that you might use a regular member function.

Will keep in mind. Any other ways it might work?

Don't make operator++ . Making operator ++ a template member function doesn't make sense.

If anything you can make a template cast operator, so that the reference returned by operator++ can be convertible to any comparable type.

Or just make the whole class a template.

It all depends on what you are trying to do.

The whole idea was to make a thread-safe class that could store memory kind of like a linked list. Problem was that the memory was stored in raw form and no type information was available, so the operator ++ had to know the type of the data (hence the template) in order to cast the memory to the correct type and increase it.
I'm thinking this is a bit of a problem and there's probably easier ways to do it. For one, storing type information might be done, but it's just that it's so prone to errors since there's so many different types of data that can be stored.

Code:

---

class CSyncClass
{
public:
        enum eDataType
        {
                TYPE_CHAR,
                TYPE_BYTE,
                TYPE_INT16,
                TYPE_UINT16,
                TYPE_INT32,
                TYPE_UINT32,
                TYPE_INT64,
                TYPE_UINT64,
                TYPE_CSTRING,
                TYPE_CHARP,
                TYPE_BYTEP,
                TYPE_INT16P,
                TYPE_UINT16P,
                TYPE_INT32P,
                TYPE_UINT32P,
                TYPE_INT64P,
                TYPE_UINT64P,
                TYPE_CSTRINGP
        };

        class CBufferValueInfo
        {
                CString strValueName; // Name of the stored data block
                eDataType DataType;  // Type of data stored
                UINT32 nBlockOffset;  // Offset in memory where data is stored
                UINT32 nBlockSize;    // Total size of the data block where the data is stored
                UINT32 nDataSize;          // Size of data (elements of an array) (eg if data = char & this = 4, then there's 4 chars)
                bool bAllocated;      // If true, then data is stored here; if false, then the block is free
        };

        class CValueHandler
        {
        private:
                friend class CSyncClass;
                CBufferValueInfo* pValue;

        public:
                //template<typename T> CValueHandler operator + (T tData);
                //template<typename T> CValueHandler operator - (T tData);
                //template<typename T> CValueHandler operator * (T tData);
                //template<typename T> CValueHandler operator / (T tData);
                template<typename T> CValueHandler& operator += (T tData);
                template<typename T> CValueHandler& operator -= (T tData);
                template<typename T> CValueHandler& operator *= (T tData);
                template<typename T> CValueHandler& operator /= (T tData);
                CValueHandler& operator ++ (); // Prefix
                CValueHandler& operator -- (); // Prefix
                CValueHandler operator ++ (int); // Postfix
                CValueHandler operator -- (int); // Postfix
                template<typename T> CValueHandler& operator = (T tData);
                //template<typename T> operator T;
        };

        CSyncClass();
        ~CSyncClass();
        template<typename T> void SetValue(CString strName, T tData, UINT32 nSize = 0);
        template<typename T> T GetValue(CString strName, UINT32 nSize = 0);
        //template<typename T> void IncValue(CString strName);
        //template<typename T> void DecValue(CString strName);
        const CValueHandler& operator [] (CString strName);

private:
        CValueHandler m_Value;
        pp<BYTE> m_pBuffer; // Array to hold memory
        CMapStringToPtr m_LookupMap; // Array containing info of stored values, looked up by name
        CMap<DWORD, DWORD, CBufferValueInfo*, CBufferValueInfo*> m_BlockLookupMap; // Array containing info of stored values, looked up by offset
        UINT32 m_nBufferSize;
        CCriticalSection cSync;

        template<typename T> eDataType GetDataType(T tData);
        template<typename T> DWORD GetSize(T& tData);
        template<typename T> bool IsNumType(T& tData)
        {
                if ( typeid(tData) == typeid(UINT8) || typeid(tData) == typeid(INT8) || typeid(tData) == typeid(UINT16) || typeid(tData) == typeid(INT16) || typeid(tData) == typeid(UINT32) ||
                        typeid(tData) == typeid(INT32) || typeid(tData) == typeid(UINT64) || typeid(tData) == typeid(INT64) || typeid(tData) == typeid(float) || typeid(tData) == typeid(double) )
                {
                        return true;
                }
                else
                {
                        return false;
                }
        }
};

---

So does the each instance of the list store Values of the same, or can a single list hold multiple types?

If the former, you just need to make your list a template, and take all those templates out of the member functions.

If the latter, you have a more complex problem on your hands. You can't just have you increment and decrement receive a type because the element incremented or decremented to won't necessarily be of the same type. The way to have a list store different types is to use inheritance. Your list would be a list of generic objects. Then have each type inherit from this generic object type. For primitives this requires a warper object that can easily be implemented as a template.

Another option in the later case is to use unions. I'm only mentioning this for completeness. Inheritance is preferred because it is type safe. However, unions are slightly faster because the implementation requires you to figure out which type is stored instead of figuring out on its own.

It's a single class to hold multiple values in one big huge block of memory, by converting it to BYTE* (ie raw) and storing it along with type information.

Quote:

---

Originally Posted by Elysia

It's a single class to hold multiple values in one big huge block of memory, by converting it to BYTE* (ie raw) and storing it along with type information.

---

Oh, I see. So you're reinventing the Heap.

Then you just have to make the pointers/iterators and subscript operators use that type information information to figure out how to move to the next element. No templates needed, because the type information is stored with the objects.

You may need templates when you actually dereference your pointers/iterators, to make them return the correct type. Alternatively you can still make operators * and -> work by returning a generic object type that can be cast to any object. Or just use BYTE.

Maybe. I figured it was the only way to store type information since some operators can't be made with templates.
The only big hurdle I see right now is that I have to manually check for type and cast it to the right type. This is especially important with pointers since they reference a fixed amount of memory.
I figure I have a lot to think about in making such a class. For now, I made a much simpler ThreadSafetyInt class to lock and unlock before fetching/saving data. Although strings are a little more complex.

Quote:

---

Originally Posted by Elysia

Code:

---

class CSyncClass
{
public:
        template<typename T> eDataType GetDataType(T tData);
        template<typename T> DWORD GetSize(T& tData);
        template<typename T> bool IsNumType(T& tData);
};

---

---

BTW, these 3 functions could easily be made into compile time computations, instead of runtime:

Code:

---

#define MK_GET_DATA_TYPE(T)  eDataType GetDataType(T tData) { \
        return sizeof(TYPE_##T);                              \
    }

    MK_GET_DATA_TYPE(CHAR);
    MK_GET_DATA_TYPE(TYPE_CSTRINGP);
#undef MK_GET_DATA_TYPE
    template<typename T> DWORD GetSize(T& tData){return sizeof(T)}
    // use a combination of the above to implement IsNumType

---

GetDataType would usually try to inquire the type of the data and return appropriate enum type. It's just that it can't be done at compile time since data is stored raw and hence all type information (except for what I store) is gone.
I can't see how that helps.
Further, the GetSize function you write is lacking since if the data type is an array, a string or a class such as CString, it will return faulty length.
But then again, I fear that I didn't design the class to handle arrays -_-

Quote:

---

Originally Posted by Elysia

GetDataType would usually try to inquire the type of the data and return appropriate enum type. It's just that it can't be done at compile time since data is stored raw and hence all type information (except for what I store) is gone.
I can't see how that helps.

---

My mistake, I assumed it just converted a type to it's enum value.

Quote:

---

Further, the GetSize function you write is lacking since if the data type is an array, a string or a class such as CString, it will return faulty length.
But then again, I fear that I didn't design the class to handle arrays -_-

---

If it is an array or string you have to explicitly specify the special case:

Code:

---

template<typename T> DWORD GetSize(T *tData){
    //assume 0 element is size.(as an example)
    return tData[0]
};
template<> DWORD GetSize(STRCLASS tData){
    return tData.size();
};

---

Same approach goes for writing IsNumType.

Quote:

---

Originally Posted by King Mir

My mistake, I assumed it just converted a type to it's enum value.

---

Code:

---

template<typename T> CSyncClass::eDataType CSyncClass::GetDataType(T tData)
{
        if ( typeid(tData) == typeid(CHAR) ) return TYPE_CHAR;
        else if ( typeid(tData) == typeid(BYTE) ) return TYPE_BYTE;
        else if ( typeid(tData) == typeid(INT16) ) return TYPE_INT16;
        else if ( typeid(tData) == typeid(UINT16) ) return TYPE_UINT16;
        else if ( typeid(tData) == typeid(INT32) ) return TYPE_INT32;
        else if ( typeid(tData) == typeid(UINT32) ) return TYPE_UINT32;
        else if ( typeid(tData) == typeid(INT64) ) return TYPE_INT64;
        else if ( typeid(tData) == typeid(UINT64) ) return TYPE_UINT64;
        else if ( typeid(tData) == typeid(CString) ) return TYPE_CSTRING;
        else if ( typeid(tData) == typeid(CHAR*) ) return TYPE_CHARP;
        else if ( typeid(tData) == typeid(BYTE*) ) return TYPE_BYTEP;
        else if ( typeid(tData) == typeid(INT16*) ) return TYPE_INT16P;
        else if ( typeid(tData) == typeid(UINT16*) ) return TYPE_UINT16P;
        else if ( typeid(tData) == typeid(INT32*) ) return TYPE_INT32P;
        else if ( typeid(tData) == typeid(UINT32*) ) return TYPE_UINT32P;
        else if ( typeid(tData) == typeid(INT64*) ) return TYPE_INT64P;
        else if ( typeid(tData) == typeid(UINT64*) ) return TYPE_UINT64P;
        else if ( typeid(tData) == typeid(CString*) ) return TYPE_CSTRINGP;
}

---

Quote:

---

If it is an array or string you have to explicitly specify the special case:

Code:

---

template<typename T> DWORD GetSize(T *tData){
    //assume 0 element is size.(as an example)
    return tData[0]
};
template<> DWORD GetSize(STRCLASS tData){
    return tData.size();
};

---

Same approach goes for writing IsNumType.

---

If my memory serves me, the function is used to determine the size of the data/buffer passed, so long as it's not an array (will have to refine ideas on that one, though I don't know if it may be beyond the scope of the class). It uses the returned size the set the block size and know how much data to allocate. Current implemtation:

Code:

---

template<typename T> DWORD CSyncClass::GetSize(T& tData)
{
        DWORD dwSize;
        if ( IsNumType(tData) )
        {
                nSize = sizeof(tData);
        }
        else if ( typeid(tData) == typeid(CHAR*) )
        {
                nSize = strlen((CHAR*)tData) + 1; // Be sure to include the NULL char!
        }
        else if ( typeid(tData) == typeid(CString) )
        {
                ASSERT(FALSE); // CStrings not supported!
                nSize = ((CString*)&tData)->GetLength();
        }
        else if ( typeid(tData) == typeid(CString*) )
        {
                ASSERT(FALSE); // CStrings not supported!
                nSize = ((CString*)tData)->GetLength();
        }
        ASSERT(dwSize > 0);
        return dwSize;
}

---

So are these Compile time or runtime checks?

If compile time, then my implementation works better.

If runtime, then the parameter passed will not be of the type of data it is pointing to -- it will instead be of the type of the generic object (which you said was BYTE). To conclude what the type is, you will have to read the type information from where ever in memory you store it.

Runtime.
Both functions are executed BEFORE the data is stored. They're used to gather information used in storing the data. GetSize is called first to check the actual size of the data. Then GetDataType is called to attain the type the data is. Those two values are stored in a struct when saving the value.
There are no post-checks after retrieving the data, but I guess I will need to do that. But I won't use those functions for that because there's no runtime data after retrieving stored data. I could post the entire saving function, but it's pretty long. But here it is anyway, if you want to have a look at it:

Code:

---

template<typename T> void CSyncClass::SetValue(CString strName, T tData, UINT32 nSize)
{
        cSync.Lock();
        nSize = GetSize(tData); // Get data size
        CBufferValueInfo* pValue = NULL;

        // Does a value of this type already exist?
        m_LookupMap.Lookup(strName, (void*&)pValue);
        if (pValue != NULL)
        {
                // There exists a value with this name already. Check size. If size is equal, then go ahead and replace it. If not...
                if (pValue->nSize == nSize) goto AssignValue;
                if (pValue->nSize < nSize)
                {
                        // The existing block isn't large enough to hold our data! Let's free it and find a new block.
                        pValue->bAllocated = false;
                        pValue->strValueName = "";
                        pValue = NULL;
                        UINT32 nOffset = 0;

                        for(;;)
                        {
                                // Loop for finding a new block
                                m_BlockLookupMap.Lookup(nOffset, pValue);
                                if (pValue == NULL)
                                {
                                        // The map is empty or we found the end of the map! Create a new block and continue.
                                        pValue = new CBufferValueInfo;
                                        pValue->nOffset = nOffset;
                                        goto AssignValue;
                                }
                                else
                                {
                                        // We found an existing block. If it's allocated already, ignore it. If it's free, check if it's big enough.
                                        if (pValue->bAllocated)
                                        {
                                                nOffset += pValue->nSize; // Jump ahead to the beginning of the next block.
                                                continue;
                                        }
                                        else
                                        {
                                                // Block is empty, but is it large enough?
                                                if (pValue->nSize == nSize)
                                                {
                                                        // Block is exactly the right size to hold our data, so go ahead and assign the data!
                                                        pValue = new CBufferValueInfo;
                                                        pValue->nOffset = nOffset;
                                                        goto AssignValue;
                                                }
                                                if (pValue->nSize > nSize)
                                                {
                                                        // Block is bigger than the data it needs to hold, so let's split it.
                                                        CBufferValueInfo* pTemp = new CBufferValueInfo;
                                                        pTemp->nOffset = pValue->nOffset + nSize;
                                                        pTemp->nSize = pValue->nSize - nSize;
                                                        pTemp->bAllocated = false;
                                                        m_BlockLookupMap.SetAt(pTemp->nOffset, pTemp);
                                                        pTemp = NULL;
                                                        pValue->nSize = nSize;
                                                        goto AssignValue;
                                                }
                                                if (pValue->nSize < nSize)
                                                {
                                                        // Block isn't large enough to hold our data! So let's check if there's another free block ahead we can use as well. If not, we'll continue searching.
                                                        CBufferValueInfo* pTemp = NULL;
                                                        m_BlockLookupMap.Lookup(pValue->nOffset + pValue->nSize, pTemp);
                                                        if (pTemp == NULL)
                                                        {
                                                                // There's no more blocks available. Extend the size of this one and continue with the assigning process!
                                                                pValue->nSize = nSize;
                                                                goto AssignValue;
                                                        }
                                                        else
                                                        {
                                                                // There's another block here! Let's examine it.
                                                                if (pTemp->bAllocated)
                                                                {
                                                                        // No luck. Block is already taken.
                                                                        nOffset += pValue->nSize;
                                                                        continue;
                                                                }
                                                                else
                                                                {
                                                                        // Block is free! Let's merge these two and continue the search!
                                                                        pValue->nSize += pTemp->nSize;
                                                                        m_BlockLookupMap.RemoveKey(pTemp->nOffset);
                                                                        continue;
                                                                }
                                                        }
                                                }
                                        }
                                }
                        }
                }
                if (pValue->nSize > nSize)
                {
                        // Block is large enough to hold our data - in fact, it's a little too big. We need to split the block and free the memory we don't need.
                        CBufferValueInfo* pTemp = new CBufferValueInfo;
                        pTemp->nOffset = pValue->nOffset + nSize;
                        pTemp->nSize = pValue->nSize - nSize;
                        pTemp->bAllocated = false;
                        pValue->nSize = nSize;
                        m_BlockLookupMap.SetAt(pTemp->nOffset, pTemp);
                        goto AssignValue;
                }
        }
       
        // Find a free block, or if none such exist, create one
       
AssignValue:
        // Let's create out index and store it in the maps
        pValue->nSize = nSize;
        pValue->strValueName = strName;
        pValue->bAllocated = true;
        pValue->DataType = GetDataType(tData);
        m_LookupMap.SetAt(strName, (void*)pValue);
        m_BlockLookupMap.SetAt(pValue->nOffset, pValue);

        // Is the offset of the data larger than our current buffer size? If so, then we need to resize it!
        if (pValue->nOffset > m_nBufferSize)
        {
                m_nBufferSize = pValue->nOffset - m_nBufferSize + 100;
                m_pBuffer.Resize(m_nBufferSize);
        }

        // Everything set then? Let's copy the data to our buffer!
        //if ( typeid(tData) ==
        memcpy_s(m_pBuffer[pValue->nOffset], m_nBufferSize - pValue->nOffset, tData, nSize);
        cSync.Unlock();
}

---

Quote:

---

Originally Posted by King Mir

So are these Compile time or runtime checks?

If compile time, then my implementation works better.

If runtime, then the parameter passed will not be of the type of data it is pointing to -- it will instead be of the type of the generic object (which you said was BYTE). To conclude what the type is, you will have to read the type information from where ever in memory you store it.

---

These tests are done at runtime.

--
Mats

No, look, if you use a template, then the test is done at compile time for that function. You can still pass an generic type to it at run type if you cast it first (implicitly or explicitly). But since any cast is done compile time, the function knows which version to call. For example you can do this:

Code:

---

void genericIncrement(GENERIC_TYPE tData){
    int type= getType(tData);
    stitch(type){
        case TYPE_INT: ++((INT)tData);
        case TYPE_CHAR: ++((CHAR)tData);
        case TYPE_CSTR: (CSTR)tData ( (CSTR)tData).size()-1)++ //increment last member
        default: throw MyException("type data corupted");
    }
}

---

Elysia, in the code you just posted, since SetValue is a template, all tests on the type are done compile time; when you call set Value you must already know the type T. As such the previously mentioned overloaded GetDataType function and specialized templated GetSize should be used.

But if you want the class to manage the multiple Type, you still need to have a function/meathod/class that reads the type information and casts it to the correct type. Once the type is deduced, the template functions can be called.

So typeid() should not be used AT ALL. It will not help you here. Either you know the type T, in which case you should use overloaded functions and specialized templates to operate on the type. Or must deduce the Type form wherever your enum eDataType is stored. Typeid is used only in inheritance, to deduce the child object from a reference or pointer to its parent. Since you are not using inheritance, you have no use for typeid. Even if you do use inheritance in your code, there is still unlikely to be a use for typeid, because typeid breaks the polymorphic model.

What you do say has some truth to it... I never thought about it, but some functions such as GetSize or GetDataType could be overloaded similarly as to what you propose at compile time.

I will look into it. But the main work lies in casting to the correct type to modify the data.

Quote:

---

Originally Posted by Elysia

But the main work lies in casting to the correct type to modify the data.

---

When you modify the data, You should already know the correct type. A a cast is involved, but it is only done once -- a simple get<TYPE>() function could easily cast the BYTE* (or void *, or your own personal pointer class) to the correct pointer type. Optionally, it could check if the type is correct and throw an exception or something if it isn't.

EDIT: Unless that is the type really is determined runtime. This would mean that the program user, some runtime determinable file, or a network connection specifies the data type. This would apply to things like parsers

If you want to provide a generic interphase to your data, this is separate from the task of managing where it is located and ensuring synchronized thread safe access.