C++ - A question about memory management

Question

I have the following class:

class StringHolder { public: StringHolder(std::string& str) { m_str = &str; } private: std::string* m_str; };

And have the following string object (str), with a size of 1,024KB:

char c = 'a'; unsigned long long limit = 1024 * 1024; std::stringstream stream; for(int i = 0; i < limit; i++) { stream << c; } std::string str = stream.str();

Whenever I initialize the StringHolder class with a string, it doesn't make a copy of that string. That's because I used references & pointers, but I'm not sure if I used them properly :\

The question: did I use references & pointers properly?

You could pass a reference to StringHolder(std::stringstream &stream) and have std::string str as a class member. — user963241
– user963241, Commented Dec 25, 2010 at 11:15
It is unclear to me whether the fact that no copies are made is by design or an unwanted side effect. That is, in your design, do you want all objects to refer to the same string so that if one of them changes the string all other see the change or if you want to have them isolated. If the strings are shared, do all objects have write access to the string or just need to notice that the string has changed? — David Rodríguez - dribeas
– David Rodríguez - dribeas, Commented Dec 25, 2010 at 11:35
@David: I just want to use less memory. Lets say I have an XML string in memory, and I pass it to my special XmlParser, I make sure the XmlParser doesn't make a copy of that string. Is there anything wrong here? :\ — Zippo
– Zippo, Commented Dec 25, 2010 at 14:25
That is what I understood from your question, but then you accepted an answer were a copy is being made. Now, the rest of the questions aim to determine the exact requirements you have. Does your XmlParser change the string? If it does not, and it is defined at construction then it might be sufficient to pass and store an std::string const &, if it can be changed later, then you can pass a reference and store a pointer (beware of different lifetimes)... different requirements lead to different solutions (duh!) — David Rodríguez - dribeas
– David Rodríguez - dribeas, Commented Dec 25, 2010 at 17:02
@David: Once I got the first answer, I thought nobody understood me and gave up (great answer (+1), but not for what I asked). If you can write the solution you wrote for no-need-to-change object as an answer, it'll be accepted :) — Zippo
– Zippo, Commented Dec 26, 2010 at 5:45

Prasoon Saurav · Accepted Answer · 2010-12-25 11:10:00Z

5

The correct implementation should be something like

class StringHolder { public: StringHolder(const std::string& str) //note const : m_str(str){} //use initialization list private: std::string m_str; //no need to make it a pointer };

answered Dec 25, 2010 at 11:10

Prasoon Saurav

93.3k51 gold badges245 silver badges348 bronze badges

Sign up to request clarification or add additional context in comments.

5 Comments

Zippo Over a year ago

Every object can be initialized like this?

Prasoon Saurav Over a year ago

Data members can only be initialized via initialization list.

user963241 Over a year ago

Yes, Every class member object as long as you would be doing an assignment operation.

Zippo Over a year ago

And if I have void setStr(std::string& str) how can I use initialization list?

Prasoon Saurav Over a year ago

@Zippo : You can't because setStr() is not a constructor.

David Rodríguez - dribeas · Accepted Answer · 2010-12-27 15:22:11Z

Under the assumption that the lifetime of the string is known to outlive the object that will refer to it, and that the object will not need to modify the string, then you can take a constant reference to the string in the constructor and store that in:

class StringHolder { std::string const & str; public: StringHolder( std::string const & s ) : str(s) {} };

With this solution the contents of the string will not be copied, but any change to the original string will affect the contents seen from the reference. Also, this does not allow you to change the string referred to after construction. If you need to reseat the reference you will have to do with a pointer:

class StringHolder { std::string const * str; public: StringHolder( std::string const & s ) : str(&s) {} void reset( std::string const & s ) { str = &s; } };

The fact that you need to store a pointer instead of a reference is an implementation detail, so you can (as I did) hide it from the user, or you could change the interface to take the string by pointer to make it more explicit (I prefer the former, but the later has the effect of self documentation: it is clearer that lifetimes have to be considered).

Also note that with the implementation as shown, a temporary can be used to initialize/set the string, causing undefined behavior: temporary dies, reference points to nowhere.

Collectives™ on Stack Overflow

C++ - A question about memory management

2 Answers 2

5 Comments

Comments

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

5 Comments

Comments

Related