std::vector - how to free the memory of char* elements in a vector?

Question

Consider the following C++ codes :

using namespace std;
vector<char*> aCharPointerRow;
aCharPointerRow.push_back("String_11");
aCharPointerRow.push_back("String_12");
aCharPointerRow.push_back("String_13");
for (int i=0; i<aCharPointerRow.size(); i++)  {
   cout << aCharPointerRow[i] << ",";
}
aCharPointerRow.clear();

After the aCharPointerRow.clear(); line, the character pointer elements in aCharPointerRow should all be removed.

Is there a memory leak in the above C++ code ? Do I need to explicitly free the memory allocated to the char* strings ? If yes, how ?

Thanks for any suggestion.

You handle your allocations, then `vector` will handle its own allocations. — jalf, Mar 13 '12 at 08:35
It should be `vector`. A `char*` pointer allows modification, but `"String_11"` is a string literal and therefore `const`. — MSalters, Mar 13 '12 at 08:48

Alok Save · Accepted Answer · 2012-03-13T08:30:55.537

Is there a memory leak in the above C++ code?
There is no memory leak.

Since you never used new you do not need to call delete. You only need to deallocate dynamicmemory if it was allocated in first place.

Note that ideally, You should be using vector of std::string.

std::vector<std::string> str;
str.push_back("String_11");
str.push_back("String_12");
str.push_back("String_13");

You could use std::string.c_str() in case you need to get the underlying character pointer(char *), which lot of C api expect as an parameter.

score 5 · Answer 2 · edited May 23 '17 at 10:34

5

You are pushing in your vector string literals (the strings in "..."). These aren't allocated by you. They are given to you by the C++ compiler/runtime and they have a lifetime equal to the lifetime of the app, so you can't/mustn't free them.

See for example Scope of (string) literals

Note that everything I told you was based on the fact that you are using string literals. If you need to allocate your strings' memory, then you will have to use some automatic deallocators like std::unique_ptr (of C++11) or boost::unique_ptr or boost::shared_ptr (of Boost) or better use the std::string class as suggested by Als

edited May 23 '17 at 10:34

Community

1
1

answered Mar 13 '12 at 08:22

xanatos

109,618
12
197
280

Why not simply use `std::string` instead? – Alok Save Mar 13 '12 at 08:37
@Als `or better use the std::string class as suggested by Als` – xanatos Mar 13 '12 at 08:39
@Als And in the end I wanted to show to the OP the "richness" of auto-pointers. If he is really interested in C++ he will need them... – xanatos Mar 13 '12 at 08:41
Fair Enough, I don't notice that quot, My bad. – Alok Save Mar 13 '12 at 08:45
@xanatos Thanks for your suggestions. I know the existence of smart pointers. I am just new to C++ and want to clarify the concepts of std::vector. – user1129812 Mar 13 '12 at 08:48

Emilio Garavaglia · Answer 3 · 2012-03-13T14:56:32.790

The sample has no leak, since the pointer you give don't refer to dynamic memory.

But is also a bad written code: string literals are constant, but C++ allow to refer them as char* to retain a C library backward compatibility. If you intend to refer to string literals, you should better use const char* instead of char* (in case of an attempt to modify them you got a compiler error, not a runtime exception)

Another bad thing, here, is that in a more extensive code, you sooner or later lose the control on what are the char* effectively stored in the vector: Are they granted to always be string literals or can they also be some other way allocated dynamic char[] ?? And who is responsible for their allocation / deallocation ?

std::vector says nothing about that, and if you are in the position you cannot give a clean answer to the above questions (each const char* referred buffer can be either exist outside the vector existence scope or not), you have probably better to use std::vector<std::string>, and treat the strings as "values" (not referenced objects), letting the string class to do the dirty job.

score 1 · Answer 4 · answered Mar 13 '12 at 08:19

1

There is no leak. As long as you're not making a copy of those strings, you don't need to explicitly delete or free() them.

answered Mar 13 '12 at 08:19

Tomas Andrle

13,132
15
75
92

std::vector - how to free the memory of char* elements in a vector?

4 Answers4