Which of these pointer need free() or delete()

Question

I'm confused with freeing or deleting pointer. For what I have read I have to use free with malloc , calloc , realloc and delete with new

But what if :

char * hello = "helloworld"; //need to use free()?
char * pointerWmalloc= (char*) malloc(sizeof(char)); 
pointerWmalloc="This need free for sure";
//here need to use free() am I right ? 
char * dupOfHello = strdup(hello); //need to use  free()? 
char * thisWnew= new Char(); // this need delete for sure 
char * charReturnedByFunc= returnchar(); // need to use free() for charReturnedByFunc??

You `free` what you `malloc` - and if a function returns a pointer its documentation has to clarify who's in charge of `free`ing it — UnholySheep, Mar 21 '19 at 21:55
@RingØ `strdup` falls into the second category I mentioned - its documentation states that the caller must `free` the pointer they receive from the function — UnholySheep, Mar 21 '19 at 22:03
In C++ you should stick to, in order of preference, 1. Library containers and container-like classes such as `std::string` 2. Smart pointers 3. `new`/`delete` 4. `malloc` and friends and `free`. But before dynamically allocating anything, first ask yourself, "Would an Automatic variable do the job?" With references, move semantics, and return value optimization, you can do a lot with a dumb, old Automatic. More reading: [Why should C++ programmers minimize use of 'new'?](https://stackoverflow.com/questions/6500313/why-should-c-programmers-minimize-use-of-new) — user4581301, Mar 21 '19 at 22:11
I recommend familiarizing yourself with the concept of [String Literals](https://en.wikipedia.org/wiki/String_literal) — user4581301, Mar 21 '19 at 22:12
Thanks to everyone, learned more thanks to all of you than to my teacher — Singh, Mar 21 '19 at 22:14
Also note `char * hello = "helloworld";` is not valid in C++. You need `const char * hello = "helloworld";`. — aschepler, Mar 21 '19 at 22:18
@aschepler That's compiler/revision dependent. It's permitted in MSVC14/C++11 for sure, if still a terrible idea. Doesn't even give a warning. — Tzalumen, Mar 21 '19 at 22:25
@Tzalumen Compilers do as they do, but in the C++ Standard that is verboten. — user4581301, Mar 21 '19 at 22:26
@user4581301 But which version of the standard forbids it? C++98? 03? 11? 14? 17? 20? There's no warnings given, so I'm going to have to assume it was forbidden in C++14 or later. — Tzalumen, Mar 21 '19 at 22:30
My teacher never told us to use const char* , we always used char * = .... ; But thanks to everyone , now I will use const char*. Can I know why downvote ? If someone can explain me it would be great , so in future I can improve my question — Singh, Mar 21 '19 at 22:30
The downvotes are mainly going to be because this information is fairly readily available from multiple locations both on and off SO. — Tzalumen, Mar 21 '19 at 22:40
@Tzalumen Converting a string literal to non-constant pointer is deprecated in C++98 and C++03, and is forbidden in C++11 and later. Never trust MSVC to be correct. Though in this case you can get it to be correct using the "/Zc:strictStrings" switch. — aschepler, Mar 21 '19 at 22:42
@Singh If that's really what your teacher told you he should be fired. *Why* did he tell you that? — user207421, Mar 21 '19 at 22:52
@user207421 he has always used char * = something;( maybe he's old school ?? Who knows) and no one has doubted whether it was Right until now — Singh, Mar 21 '19 at 22:56
Maybe he's technically illiterate. The rules about `const char *` and string literal haven't changed. It's not like he has the choice. Does he like writing code that doesn't compile? Why don't you *ask* him why? You should never accept dogma from anybody in any profession. This is engineering, not magic. — user207421, Mar 22 '19 at 11:01
That said, the teacher is the gatekeeper to passing the class. Explain the problem privately and politely. — user4581301, Mar 22 '19 at 16:17
@user4581301 I asked him and he said : we use c++ minimally ( we mix c and c++ , and we use a lot c ) , so there is no difference for us if we use char or const char — Singh, Mar 22 '19 at 17:23
Not at the compiler level, but at the runtime level... Let's just say C++ made `const char *` illegal in part because of the suffering of 30 years of C programmers (and ten years of pre-Standard C++ programmers) tripping over writes into read-only memory. If a programs spits out a bus error, odds are that was a missing `const`. [Recommended reading on why const is good](https://isocpp.org/wiki/faq/const-correctness). There is a strong case to be made for "Everything should be `const` until proven otherwise." — user4581301, Mar 22 '19 at 18:04

score 2 · Accepted Answer · answered Mar 21 '19 at 22:20

char * hello = "helloworld"; //need to use free()?

"helloworld" is a const char* and hello is now a dynamic reference to it. (You will trigger a runtime exception if you try to change any characters in the string, or free this memory)

char * pointerWmalloc = (char*)malloc(sizeof(char));

This allocated memory needs to be free'd BEFORE reassignment to

pointerWmalloc = "This need free for sure";

which like hello now points to a const char* with the same restrictions.

char * dupOfHello = strdup(hello); //need to use  free()?

this needs to be free'd

char * thisWnew = new Char(); // this need delete for sure

This does need delete. Also, Char is not a class unless you make it one, but I think you meant char()

char * charReturnedByFunc = returnchar(); // need to use free() for charReturnedByFunc??

This one is tricky, it completely depends on what returnchar() returns a pointer to. A const char*? no. A char* owned by another object or function? Maybe. A char* allocated inside the function? Maybe. Unless you make it completely clear, you can't know if returnchar() returns a malloc'd or new'd char*.

All this and more is why it's recommended to avoid raw pointers in favor of std::unique_ptr and std::shared_ptr, avoid malloc in favor of new, and avoid char* in favor of std::string.

I'd reword that last one a bit. It doesn't matter what type is returned nearly as much as how what is returned was allocated. Some fool could even return a pointer to an Automatic. If the types don't line up, the compiler should catch it long before runtime (but as you noted in comments above not all compilers observe the type checked as tightly as they should). — user4581301, Mar 21 '19 at 22:31
Ownership also matters, since `returnchar()` could be returning a memory address to anyone's char* — Tzalumen, Mar 21 '19 at 22:34
@user4581301If we're going to discuss dangerous decisions, there's also the ability to `const_cast` a `const char*` into a regular `char*` — Tzalumen, Mar 21 '19 at 22:37
My point is the type doesn't matter. It's a side issue. The entire problem is you don't know how the memory was allocated and how it must be disposed of. The wording you have used distracts from this and seems to place an equal emphasis on an irrelevant issue. — user4581301, Mar 21 '19 at 23:37

score 1 · Answer 2 · answered Mar 21 '19 at 22:04

1

I'll answer with comments in the code below:

char * hello = "helloworld"; // Do not free/delete pointer
                             // `hello` points to read-only memory
char * pointerWmalloc= (char*) malloc(sizeof(char)); // use free(pointerWmalloc) here
pointerWmalloc="This need free for sure"; // now you created a memory leak since pointerWmalloc now points to read-only memory. So do not free/delete

char * dupOfHello = strdup(hello); // use free(dupOfHello) here (as documented) 
char * thisWnew= new char(); // use delete thisWnew here
char * charReturnedByFunc= returnchar(); // need to read the documentation.
                // could be free, delete, none of the two or something else

answered Mar 21 '19 at 22:04

Bo R

2,334
1
9
17

For read-only memory do u mean that I can't change the value of hello? Example : char * hello = "helloWorld"; hello = "thisIsNewHelloWorld";? Last more question , so for strdup I have always to use free? Also when a function returns strdup(orchard*)? Thanks – Singh Mar 21 '19 at 22:11
2

The answer will depend on the language you are using, C or C++. But in both cases you are allowed to re-assign a new value to `hello`. But shouldn't change the value of what `hello` is pointing to after `char*hello="helloworld";`. So avoid `hello[5]=W;`. But after `malloc` a simpel `*hello = 'x';` is ok, but now `hello` is no longer a pointer to an array of characters but *just* a char. – Bo R Mar 21 '19 at 22:20
@FrançoisAndrieux Actually, `char * hello = "helloworld";` is perfectly valid c++ as of at least MSVC 14/C++11, if extremely unwise. (I tested this whole mess) – Tzalumen Mar 21 '19 at 22:21
As @FrançoisAndrieux points out is correct with up-to-date version of the C++ language, but has been allowed previously in C++98. – Bo R Mar 21 '19 at 22:21
Thanks to everyone, got it ! – Singh Mar 21 '19 at 22:28

Which of these pointer need free() or delete()

2 Answers2