Thread: Memory leak by simple char

Originally Posted by Ktulu

I don't want to use vectors because I don't know, I really don't wanna use code which I don't know yet.

You should consider taking the time to learn them. The advantages they offer over regular arrays is similar to the advantages the C++ string class has over C style strings.

However, you can still follow the advice with char arrays instead of vectors. The important point is that you should still be using C++ strings, and when you can't (like with GetWindowText) you try to minimize the use of C style strings to as small a scope as possible. Basically, follow the idea of Ken Fitlike's example below, except use char arrays instead of vector, and you will still be able to use C++ strings successfully.

Ok Cat.

Originally Posted by Mario F.

any specific need for char arrays is quiet easily fulfilled with the c_str() member function. If you have a function needing a char array:

void somefunction(char* buffer);
or
void somefunction(char[] buffer);

The following will do it.

Code:

std::string foo = "pass me as c-style string";

/*... do here all the nifty things C++ Strings allow you to do ...*/

somefunction(foo.c_str());

There are windows functions like 'GetWindowText' (and more!) were you can't parse a std :: string, were you need to use CHAR Buffers, so, how use them safely?

Ok, so, if I'm just making sure that there is no way my CHAR is getting overrun and declaring it with enough arrays, it is safe to use?

Another question, when declaring variables, is it better to always set them to 0 when you declare them?

Code:

CHAR Cha [ 512 ];

INT Int;

LPITEMIDLIST ITL;

Or:

Code:

CHAR Cha [ 512 ] = { 0 };

INT Int = 0;

LPITEMIDLIST ITL = NULL;

>> if I'm just making sure that there is no way my CHAR is getting overrun and declaring it with enough arrays, it is safe to use?
Yes, if you use them correctly, they are safe. The point is that they are more difficult to use correctly.

>> is it better to always set them to 0 when you declare them?
Yes, always initialize variables. In some rare cases it doesn't matter, but since it doesn't matter, it doesn't hurt to initialize the variable.

What you should be trying to do is to not declare a variable until you are ready to initialize it with a valid value. In C++ you should keep variables in the smallest possible scope. So if you are initializing a variable to 0 at the top of the function, then changing it to a real value later before you start using it, you should just declare it later when you have that real value available.

Ok, good to know, but there is another issue, windows uses alot of self 'designed' variables, how can I know what kind of data I have to set to some variables?

Can you give an example?

No problem .

Code:

HKEY Key = ???;

HANDLE Han = ???;

HWND Win = ???;

HBITMAP BMP = ???;

HBRUSH Bru = ???;

HDC DCo = ???;

HFILE Fil = ???;

HFONT Fon = ???;

LRESULT Res = ???;

By the way, sometimes when you declare a variable, you want to give it a value right away.

INT Int = 20;

Should you first declare it to zero and then give it his value.

INT Int = 0;

Int = 20;

Or is the first way better?

>> sometimes when you declare a variable, you want to give it a value right away.
That is my point. You should always try to wait until you are ready to give it a value before you declare it, then use the first option.

As for the windows types, if you wait to declare them until you are ready to initialize them, it shouldn't be a problem. In the cases where you have a reason to initialize them to a zero-like value, they have corresponding options. Several of those use NULL (which is just 0 anyway), but some use something different like HFILE might be set to INVALID_HANDLE_VALUE. You just have to look in MSDN at the instructions and code examples to find out the appropriate one for each type.