asked on

function template conditional execution of code

Hi,

I want to do the following

------------------------------------------------------------------------------------
template <class T> void PutToSA(SAFEARRAY* &insa,long ElemNo,T& InVal)
{
VARIANT MyVar;
VariantInit(&MyVar);
#if typeof(T) is CString
MyVar.vt=VT_BSTR;
MyVar.bstrVal=InVal.AllocSysString();
#else
MyVar.vt=VT_I2;
MyVar.intVal=InVal;
#end if
SafeArrayPutElement(insa,&ElemNo,&MyVar);
};

------------------------------------------------------------------------------------

However, I just made up the "#if typeof" statement

Is there another way of doing this ???

I know I can create another template just for the CString class, but this seems to defeat the purpose of templates...

Crius

Eee, well, bad to use precompiled directives like this in code. Probably wouldn't work well anyway.

Try using COleVariant. It has a constructor that takes in all sorts of different variable types.

template <class T> void PutToSA(SAFEARRAY* &insa,long ElemNo,T& InVal)
{
COleVariant MyVar(T);

SafeArrayPutElement(insa,&ElemNo,&MyVar);
};

It also allocates and deallocates memory (And calls the VariantInit) functions automatically. If you allocate a BSTR, it must be deallocated somewhere afterall. :)

Crius

Oops, sorry,

COleVariant MyVar(InVal);

Don't use the type of the variable, just the value. Hehe.

ASKER CERTIFIED SOLUTION

Axter

membership

This solution is only available to members.

To access this solution, you must be a member of Experts Exchange.

Start Free Trial

ct.smith

Seems to me like this is a good case for template specialisation:

template <class T> void PutToSA(SAFEARRAY* &insa,long ElemNo,T& InVal)
{
VARIANT MyVar;
VariantInit(&MyVar);
MyVar.vt=VT_I2;
MyVar.intVal=InVal;
SafeArrayPutElement(insa,&ElemNo,&MyVar);
};

template <CString> void PutToSA(SAFEARRAY* &insa,long ElemNo,CString& InVal)
{
VARIANT MyVar;
VariantInit(&MyVar);
MyVar.vt=VT_BSTR;
MyVar.bstrVal=InVal.AllocSysString();
SafeArrayPutElement(insa,&ElemNo,&MyVar);
};

Small catch, I don't have VC6 handy to double check my example code, but the spirit of the solution is fairly straightforward.

andymurd

ct.smith is correct, but I think an overload rather than template specialzation is more appropriate.

So you would have:

void PutToSA(SAFEARRAY* &insa,long ElemNo,CString& InVal)
{
VARIANT MyVar;
VariantInit(&MyVar);
MyVar.vt=VT_BSTR;
MyVar.bstrVal=InVal.AllocSysString();
SafeArrayPutElement(insa,&ElemNo,&MyVar);
};

template <class T> void PutToSA(SAFEARRAY* &insa,long ElemNo,T& InVal)
{
VARIANT MyVar;
VariantInit(&MyVar);
MyVar.vt=VT_I2;
MyVar.intVal=InVal;
SafeArrayPutElement(insa,&ElemNo,&MyVar);
};

NOTE: The CString version comes BEFORE the template so the compiler will pick that one first if appropriate.

smegghead

ASKER

Hi,

Thanks for your advice everyone, I have, in the interim, gone for the function overload solution, as this works fine.

However, I really wanted a way of branching code depending on the type/class passed in... it seems strange that the compiler doesn't have some way of doing this. It would make code a lot simpler and avoid a lot of duplicate code.

crius... I wasn't suggesting using pre-processor directives, this was just an example of the sort of thing I wanted to do.

I'm inclined to give the points to axter, as he/she came up with a solution I'd not thought of/tried.

So I'm gonna pass the points on to axter...

Sorry everyone else... I do appreciate your suggestions...

Regards

Smg.