Question

Update : Sorry, just a big mistake. It is meaningless to write int *a = 3; But please just think the analogy to the case like TCHAR *a = TEXT("text"); (I edited my question, so some answers and comments are strange, since they are for my original question which is not suitable)

In main function, suppose I have a pointer TCHAR *a = TEXT("text"); Then it excutes the following code:

int i;
for (i = 0; i < 1000; i++) {
        a = test(i);
}

with the function TCHAR* test(int par) defined by:

TCHAR* test(int par)
{
    TCHAR *b = TEXT("aaa");
    return b;
}

My question is, after executing the above code, but before the program ends, in the memory:

    1. the pointer `a` remains?
    2. The 1000 pointers `b` are deleted each time the function test(...) exits ?
    3. But there are still 1000 memory blocks there?

---

In fact, my question is motivated from the following code, which shows a tooltip when mouse is over a tab item in a tab control with the style TCS_TOOLTIPS:

case WM_NOTIFY
    if (lpnmhdr->code == TTN_GETDISPINFO) {
    LPNMTTDISPINFO lpnmtdi;
    lpnmtdi = (LPNMTTDISPINFO)lParam;

    int tabIndex = (int) wParam; // wParam is the index of the tab item.

            lpnmtdi->lpszText = SetTabToolTipText(panel->gWin.At(tabIndex));
            break;
    }

I am thinking if the memory usage increases each time it calls

SetTabToolTipText(panel->gWin.At(tabIndex)), which manipulates with TCHAR and TCHAR* and return a value of type LPTSTR.

Answer 1

1. Yes, the pointer a remains till we return from the main function
2. The variable b (a 4-byte pointer) is automatic. It is created each time we call test function. Once we return from it, the variable disappears (the pointer). Please note, the value to which b points isn’t affected.
3. No. In most of the cases, I think, there will be only one block allocated during compilation time (most likely in the read-only memory) and the function will be returning the same pointer on every invocation.

If SetTabToolTipText allocates a string inside using some memory management facilities new/malloc or some os-specific, you should do an additional cleanup. Otherwise there’ll be a memory leak.

If nothing like this happens inside (it’s not mentioned in the documentation or comments etc), it’s most likely returning the pointer to some internal buffer which you typically use as readonly. In this case, there should be no concerns about a memory consumption increase.