void pointer to type

[voidspace]

I want to be able to use a a function like

WriteLogType("Double Type", 10.4563);
WriteLogType("Integer Type", 10);
WriteLogType("String", "Hello"); 

etc


I was trying to determine the type like below but it was always satisfying Integer condition. How to resolve this?

void CMyApp::WriteLogType(CString strMessage, void *pVoidType)
{
    // then it is an integer
    if(sizeof(&pVoidType) == sizeof(int))
    {
        TRACE("Integer");
    }
    else if(sizeof(&pVoidType) == sizeof(float))
    {
        TRACE("Float");
    }
    else if((sizeof(&pVoidType) == sizeof(double)))
    {
        TRACE("Double");
    }
    else if((sizeof(&pVoidType) == sizeof(char)))
    {
        TRACE("Char");
    }
    else
    {
        TRACE("Unknown");
    }
} 

[Hobson]

The best way would be to create template function and \ or set of overloaded functions for logging purposes:

#include <iostream>
#include <string>

template <typename T>
void WriteLog(const std::string &sMsg, T val)
{
	std::cout << sMsg << val << std::endl;
} 



int main(int argc, char* argv[])
{
	WriteLog("int:", 1);
	WriteLog("char:", '1');
	WriteLog("float:", 1.0f);
	return 0;
}

In your example condition

if(sizeof(&pVoidType) == sizeof(int))

is always true, because size of pointer is always equal to size of int.

Hob

[cilu]

The template version looks the most appropriate. Just to offer a third solution, you can pass an aditional param to indicate the type.

enum Types {TYPE_UNKNOWN = 0, TYPE_INT, TYPE_CHAR, TYPE_STRING, ...};

void CMyApp::WriteLogType(CString strMessage, void *pVoidType, int bufferSize, 
    Types type = TYPE_UNKNOWN);

[Siddhartha]

Lets first analyze why this happened -

I was trying to determine the type like below but it was always satisfying Integer condition.

The sizeof (pAnyPointer) is always 4 on Win 32.

The sizeof (int) is 4, and so is the sizeof (float) 4.
Hence, the condition being checked was fundamentally flawed.

You can either solve the problem using the method Hobson has recommended or using Overloaded Functions -

void CMyApp::WriteLog(const std::string &sMsg, int nVal)
{
	std::cout << sMsg << nVal << std::endl;
};

void CMyApp::WriteLog(const std::string &sMsg, float fVal)
{
	std::cout << sMsg << fVal << std::endl;
};

[JMS]

Or of coarse you could just overload your function.

main()
{
     double myDouble            = 10.4563;  
     int        myInt                  = 10;
     char     myString[40]       = "Hello";

     WriteLogType(myDouble); 
     WriteLogType(myInt); 
     WriteLogType(myString); 
}

void WriteLogType(double myDouble) 
{}
void WriteLogType(int myInt) 
{}
void WriteLogType(char *pMyString) 
{}

[GCDEF]

Or you could overload the function.

void CMyApp::WriteLogType(CString strMessage, int*pIntType)
void CMyApp::WriteLogType(CString strMessage, float*pFloatType)

etc.

[Siddhartha]

void CMyApp::WriteLogType(CString strMessage, int*pIntType)
void CMyApp::WriteLogType(CString strMessage, float*pFloatType)

On a side note, instead of passing a pointer (which can be invalid), one would rather pass a reference -

void CMyApp::WriteLog (std::string &sMsg, int & nVal)
{
   // Implementation... 
};

void CMyApp::WriteLog (std::string &sMsg, float & fVal)
{
   // Implementation... 
};

...if the changes to passed parameter values made in WriteLog need to be reflected outside it.

[Siddhartha]

[ moved ]

Regards,
Siddhartha

[voidspace]

Thanks guys. I did the function overloading and it works fine.

I like the template idea .. so will try that too.

[MrViggy]

Are all the functions the same? If so, maybe templates would be better. Let the compiler write out all the functions for you!



Viggy