«

Consider a class that has
vector< pair<int, string>* > c;
as member data object.

I need to use operator>> to store values into this container object
and
operator<< to print the contents of the container.

I have written both these operators as non-friend functions.

The destructor deletes all the pair<int, string> pointers in the
vector.

My doubt is that I am using a store_pair() function which allocates
memory
for each pair<int, string> pointer and stores into the container; but
the
dtor deletes these pointers thereby releasing the memory.

Kindly let me know if the approach in this program is correct.

Here is the full program:

#include <cstdlib>
#include <iostream>
#include <vector>
#include <utility>

using namespace std;

class Test
{
public:
Test();
~Test();

typedef pair<int, string> pair_type;
typedef vector<pair_type*> container_type;

void store_pair(const pair_type& arg);
const container_type& container() const { return c; }

private:
container_type c;
};

Test::Test() : c()
{
}

void Test::store_pair(const pair_type& arg)
{
pair_type* p = new pair_type(arg.first, arg.second);
c.push_back(p);
}

Test::~Test()
{
for (container_type::iterator it = c.begin(); it != c.end(); +
+it)
{
delete *it;
*it = 0;
}
}

istream& operator>>(istream& is, Test& obj)
{
while (is)
{
int x;
string str;
is >> x >> str;

if (is)
{
Test:air_type temp(x, str);
obj.store_pair(temp);
}
}

return is;
}

ostream& operator<<(ostream& os, const Test& obj)
{
for (Test::container_type::const_iterator it =
obj.container().begin();
it != obj.container().end();
++it)
os << (**it).first << " " << (*it)->second << endl;

return os;
}

int main()
{
Test obj;

cin >> obj;

cout << obj;

return EXIT_SUCCESS;
}

Thanks
V.Subramanian

On Apr 25, 8:29*pm, "subramanian10...@yahoo.com, India"
<subramanian10...@yahoo.com> wrote:
> Consider a class that has
> vector< pair<int, string>* > *c;
> as member data object.
>
> I need to use operator>> to store values into this container object
> and
> operator<< to print the contents of the container.
>
> I have written both these operators as non-friend functions.
>
> The destructor deletes all the pair<int, string> pointers in the
> vector.
>
> My doubt is that I am using a store_pair() function which allocates
> memory
> for each pair<int, string> pointer and stores into the container; but
> the
> dtor deletes these pointers thereby releasing the memory.
>
> Kindly let me know if the approach in this program is correct.
>
> Here is the full program:
>
> #include <cstdlib>
> #include <iostream>
> #include <vector>
> #include <utility>
>
> using namespace std;
>
> class Test
> {
> public:
> Test();
> ~Test();
>
> typedef pair<int, string> pair_type;
> typedef vector<pair_type*> container_type;
>
> void store_pair(const pair_type& arg);
> const container_type& container() const { return c; }
>
> private:
> container_type c;
>
> };
>
> Test::Test() : c()
> {
>
> }
>
> void Test::store_pair(const pair_type& arg)
> {
> * * * * pair_type* p = new pair_type(arg.first, arg.second);
> * * * * c.push_back(p);
>
> }
>
> Test::~Test()
> {
> * * * * for (container_type::iterator it = c.begin(); it != c.end(); +
> +it)
> * * * * {
> * * * * * * * * delete *it;
> * * * * * * * * *it = 0;
> * * * * }
>
> }
>
> istream& operator>>(istream& is, Test& obj)
> {
> * * * * while (is)
> * * * * {
> * * * * * * * * int x;
> * * * * * * * * string str;
> * * * * * * * * is >> x >> str;
>
> * * * * * * * * if (is)
> * * * * * * * * {
> * * * * * * * * * * * * Test:air_type temp(x, str);
> * * * * * * * * * * * * obj.store_pair(temp);
> * * * * * * * * }
> * * * * }
>
> * * * * return is;
>
> }
>
> ostream& operator<<(ostream& os, const Test& obj)
> {
> * * * * for (Test::container_type::const_iterator it =
> obj.container().begin();
> * * * * * * * it != obj.container().end();
> * * * * * * * ++it)
> * * * * * * * * os << (**it).first << " * " << (*it)->second << endl;
>
> * * * * return os;
>
> }
>
> int main()
> {
> * * * * Test obj;
>
> * * * * cin >> obj;
>
> * * * * cout << obj;
>
> * * * * return EXIT_SUCCESS;
>
> }
>
> Thanks
> V.Subramanian

#include<string> in your program and it should work fine.

wrote:
>
> #include<string> in your program and it should work fine.

Did you have to quote the entire message just to add that?

--
Ian Collins.

, India wrote:
> Consider a class that has
> vector< pair<int, string>* > c;
> as member data object.
>
> I need to use operator>> to store values into this container object
> and
> operator<< to print the contents of the container.
>
> I have written both these operators as non-friend functions.
>
> The destructor deletes all the pair<int, string> pointers in the
> vector.
>
> My doubt is that I am using a store_pair() function which allocates
> memory
> for each pair<int, string> pointer and stores into the container; but
> the
> dtor deletes these pointers thereby releasing the memory.
>
> Kindly let me know if the approach in this program is correct.
>
It is one option, but consider just storing small objects (like your
pair<int, string>) in the vector rather than pointers. Then you won't
have to bother deleting them or copying a temporary object in your inserter.

--
Ian Collins.

>
> Did you have to quote the entire message just to add that?
>
> --
> Ian Collins.

opps. I could swear I did not quote the message at all, but I have to
learn to double-check for next time.

Thanks for the tip.

wrote:
>> Did you have to quote the entire message just to add that?
>>
>> --
>> Ian Collins.
>
> opps. I could swear I did not quote the message at all, but I have to
> learn to double-check for next time.
>
> Thanks for the tip.

OK, while we're here, it's bad form to quote signatures (the bit after
the "-- ").

--
Ian Collins.

> OK, while we're here, it's bad form to quote signatures (the bit after
> the "-- ").

I hope I got it right this time. Ok, I'll read the FAQ guidelines
again:
http://www.parashift.com/c++-faq-lite/how-to-post.html

, India wrote:
> Consider a class that has
> vector< pair<int, string>* > c;
> as member data object.

> I need to use operator>> to store values into this container
> object and operator<< to print the contents of the container.

> I have written both these operators as non-friend functions.

> The destructor deletes all the pair<int, string> pointers in
> the vector.

> My doubt is that I am using a store_pair() function which
> allocates memory for each pair<int, string> pointer and stores
> into the container; but the dtor deletes these pointers
> thereby releasing the memory.

And what do you doubt about that? (I have doubts about the
wisdom of storing pointers, rather than the objects themselves,
given that std:air has value semantics, but that's a different
issue.)

> Kindly let me know if the approach in this program is correct.

> Here is the full program:

> #include <cstdlib>
> #include <iostream>
> #include <vector>
> #include <utility>

> using namespace std;

> class Test
> {
> public:
> Test();
> ~Test();

> typedef pair<int, string> pair_type;
> typedef vector<pair_type*> container_type;

> void store_pair(const pair_type& arg);
> const container_type& container() const { return c; }

I also have a lot of doubts about exposing the implementation
like this. If you're going to do this, you might as well make
the container public, and be done with it.

> private:
> container_type c;
> };

> Test::Test() : c()
> {
> }

> void Test::store_pair(const pair_type& arg)
> {
> pair_type* p = new pair_type(arg.first, arg.second);
> c.push_back(p);

What's wrong with simply:
c.push_ back( new pair_type( arg ) ) ;
?

> }

> Test::~Test()
> {
> for (container_type::iterator it = c.begin(); it != c.end(); +
> +it)
> {
> delete *it;
> *it = 0;

Formally (but only formally), this is undefined behavior. You
must set the pointer in the container to null before the delete.

Practically, of course, there'll never be an implementation
where it will cause any problems, so I wouldn't worry about it.
For that matter, I wouldn't worry about setting the pointer to
null, since there'll never be an implementation where not doing
so will cause problems either, so I wouldn't worry about that
either.

> }
> }

> istream& operator>>(istream& is, Test& obj)
> {
> while (is)
> {
> int x;
> string str;
> is >> x >> str;

> if (is)
> {
> Test:air_type temp(x, str);
> obj.store_pair(temp);
> }
> }
> return is;
> }

The real question is what semantics you want. Generally
speaking, I have my doubts about the format you're inputting; I
can't think of a context where it would be appropriate. But
what is appropriate depends on the application. Until you've
defined the format, it's impossible to say whether this is
correct or not.

> ostream& operator<<(ostream& os, const Test& obj)
> {
> for (Test::container_type::const_iterator it =
> obj.container().begin();
> it != obj.container().end();
> ++it)
> os << (**it).first << " " << (*it)->second << endl;

Why the two different ways to access the pair? Choose one, and
use it consistently. (I'd use the second, but that's more a
question of personal preference.)

> return os;
> }

--
James Kanze (GABI Software) email:
Conseils en informatique orientée objet/
Beratung in objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34

On 28 Apr, 10:10, James Kanze <james.ka...@gmail.com> wrote:
> subramanian10...@yahoo.com, India wrote:
> > Test::~Test()
> > {
> > * * * * for (container_type::iterator it = c.begin(); it != c.end(); +
> > +it)
> > * * * * {
> > * * * * * * * * delete *it;
> > * * * * * * * * *it = 0;
>
> Formally (but only formally), this is undefined behavior. *You
> must set the pointer in the container to null before the delete.
>

Why is that?

On Apr 29, 7:41 am, Triple-DES <DenPlettf...@gmail.com> wrote:
> On 28 Apr, 10:10, James Kanze <james.ka...@gmail.com> wrote:

> > subramanian10...@yahoo.com, India wrote:
> > > Test::~Test()
> > > {
> > > for (container_type::iterator it = c.begin(); it != c.end(); +
> > > +it)
> > > {
> > > delete *it;
> > > *it = 0;

> > Formally (but only formally), this is undefined behavior. You
> > must set the pointer in the container to null before the delete.

> Why is that?

Because all objects in a container must be copiable, and a
deleted pointer is not copiable. In practice, of course

-- I don't know of any implementation today where copying a
deleted pointer will actually cause problems (although some
have definitely existed in the past), and above all

-- the implementation of std::vector is not going to copy an
element without reason, and as long as you don't extend the
vector, or explicitly do something which reads the value,
there's no reason.

So while I wouldn't leave a deleted pointer in an std::vector
which will remain live, I don't think you have to worry about
any problems between deleting it and assigning null, if they
immediately follow one another, nor any problems if the delete's
are preliminary to calling the vector's destructor (as is the
case here---there's no real reason to even assign 0 in this
case).

--
James Kanze (GABI Software) email:
Conseils en informatique orientée objet/
Beratung in objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34