C / C++ / MFC

BOOL CSmartToolTip::SetTipText(CWnd *pTipOwnerWnd, CString strTip )
{
	TOOLINFO ti;

	_CreateTipWnd();

	// Fill tool tip info structure:
	// (Set flags to indicates that the uId member is the window handle
	// to the tool, and to indicate that the ToolTip control should subclass
	// the tool's window to intercept messages.)
	ti.cbSize = sizeof(ti);						// size of this structure
	ti.uFlags = TTF_IDISHWND | TTF_SUBCLASS;		// flags
	ti.hwnd = pTipOwnerWnd->GetParent()->GetSafeHwnd();	// handle to the window that contains the tool
	ti.uId = (UINT)pTipOwnerWnd->GetSafeHwnd();			// application-defined identifier of the tool
	ti.hinst = AfxGetResourceHandle();				// handle to the instance that contains the string resource for the tool
	ti.lpszText = (LPTSTR)((LPCTSTR)strTip);						// pointer to the buffer that contains the text for the tool
	
	// Send add tool message and return result:
	//	return CToolTipCtrl::AddTool( pTipOwnerWnd->GetParent(), 1 );
	return((BOOL)SendMessage(TTM_ADDTOOL, 0, (LPARAM)&ti));
}


void CSmartToolTip::_CreateTipWnd()
{
	// We must create its once!
	if( ! IsWindow(*this) )
	{
		// Create ToolTip control
		this->Create( NULL );
		
		SetTipBkColor( RGB( 255, 255, 0) );
		SetTipTextColor( RGB( 0, 0, 0) );
		
		// Enable multiline
		::SendMessage( *this, TTM_SETMAXTIPWIDTH, 0, 
			(LPARAM)(INT) MAKELONG(400, 0));
	}
}

CBitmap Bitmap;
CDC dcMem;
HBITMAP hBitmap = 0;
hBitmap = (HBITMAP)LoadImage( AfxGetInstanceHandle(),
    strLocationOfBitmap,
    IMAGE_BITMAP,
    0,
    0,
    LR_LOADFROMFILE | LR_DEFAULTSIZE);

dcMem.CreateCompatibleDC(pDC);
Bitmap.CreateCompatibleBitmap(pDC, 390, -230);

Bitmap.Attach( hBitmap );
dcMem.SelectObject(&Bitmap);
pDC->BitBlt(1280, -1765, 390,  -230, &dcMem, 0, 0, SRCCOPY);/*pDC : on draw defined dc*/

kumar sanghvi wrote:

void function(int y,int w)
{
printf("int function");

}

void function(float y,float w)
{
printf("float function");
}

kumar sanghvi wrote:

function(1.2,2.2);

int main()
{
float f1=1.2, f2=2.2;
int n1=22, n2=23;

function(f1, f2); //f1 and f2 are floats, so the compiler will call the float version.
function(n1, n2); //Similarly, the compiler would call the int version.
function((int)f1, (int)f2); //int version would be called.
function((float)n2, (float)n1); //float version would be called
//function(f1, n2); //Ambiguous! If you enable this, the program won't compile!
return 0;
}

a.cpp:16: error: call of overloaded ‘function(double, double)’ is ambiguous
a.cpp:3: note: candidates are: void function(int, int)
a.cpp:9: note:                 void function(float, float)

kumar sanghvi wrote:

int *p;   //With this statement, you just declared a pointer variable (which will point to an integer)
int w=10; //You declared an integer and initialized it. The storage for this variable is on the stack.
p=&w;    //You made the integer pointer you earlier declared, point to the integer that you just created on the stack.

the memory allocation for both w and p will be on stack only ...?

kumar sanghvi wrote:

when it is really useful to allocate memory dynamically using pointer than allocating on the stack..?

kumar sanghvi wrote:

if possible can u explain with example when the dynamic memory allocation is really useful...

Rajesh R Subramanian wrote:

p=&10;

kumar sanghvi wrote:

int* p; //declared pointer to int (statement does nothing)<br />
int w=10; //declares and initializes an int to 10, but it won't exist unless you use it<br />
p=&10; //this is an error, you probably meant p=&w?