learner's question on populating vector< pair<int, string>* > asmember

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, stringpointers in the
vector.
>
My doubt is that I am using a store_pair() function which allocates
memory
for each pair<int, stringpointer 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, stringpair_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::pair_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<stringin your program and it should work fine.

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, stringpointers in the
vector.
>
My doubt is that I am using a store_pair() function which allocates
memory
for each pair<int, stringpointer 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.
>

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.

the "-- ").

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, stringpointers in
the vector.

My doubt is that I am using a store_pair() function which
allocates memory for each pair<int, stringpointer 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, stringpair_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::pair_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;
}

subramanian10...@yahoo.com, India wrote:>
Formally (but only formally), this is undefined behavior. *You
must set the pointer in the container to null before the delete.
>

On 28 Apr, 10:10, James Kanze <james.ka...@gmail.comwrote:

Why is that?

subramanian10...@yahoo.com, India wrote:

>
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.
>

On Apr 29, 7:41 am, Triple-DES <DenPlettf...@gmail.comwrote:
>>
Because all objects in a container must be copiable, and a
deleted pointer is not copiable. *In practice, of course

>
You are right. 3.7.3.2/4 does indeed say that "The effect of using an
invalid pointer value (...) is undefined". But doesn't this also mean
that formally, setting the pointer to null is also undefined, because
"An object (...) is _used_ if its name appears in a potentially-
evaluated expression" (3.2/2)?
>

On 29 Apr, 11:31, James Kanze <james.ka...@gmail.comwrote:

[snip]

You are right. 3.7.3.2/4 does indeed say that "The effect of using an
invalid pointer value (...) is undefined". But doesn't this also mean
that formally, setting the pointer to null is also undefined, because
"An object (...) is _used_ if its name appears in a potentially-
evaluated expression" (3.2/2)?

int * p = new int(5);
delete p;
p = 0; // undefined
p = new int(42); // reusing the ptr, fairly common, but undefined
char buf[sizeof(p)]; // ok, p is not _used_

Or am I missing something?

On Apr 28, 4:10 am, James Kanze <james.ka...@gmail.comwrote:

By saying 'Exposing implementation', are you referring to
"const container_type& container() const { return c; }" ?

If so, I am returning only 'const container_type&'.
Will that create any problem ?

An alternative that I can think of is to make operator<<
a friend because, only in operator<<, container() is needed.

But Stroustrup has advised to avoid friend functions(except
to avoid global data and public data).

On Apr 29, 1:38 pm, Triple-DES <DenPlettf...@gmail.comwrote:>
The fact that using an object doesn't necessarily mean using its
value? *In general, I'd say that you only use its value if there
is either an lvalue to rvalue conversion, or an operation that
is described in terms of other operations which would involve an
lvalue to rvalue conversion. *(That latter sounds a bit
complicated, but all it's saying is that ++p would use the
value, because it is defined as the equivalent of p = p + 1, and
the second use of p there involves an lvalue to rvalue
conversion.)

Hello everyone,
>
kindly bear with me for asking same question. I am unclear now.
>
For deleting the elements of a container where the container contains
pointer to elements, I thought following is the only way.
>
for (container_type::iterator it = c.begin(); it != c.end(); ++it)
{
* * * *delete *it;
* * * **it = 0;
>
}
>
Does 'delete *it; followed by *it = 0;' invoke undefined behaviour ?

If so, how else will I delete the pointers in the container ?
>
Also, all along I have been using
>
int* p = new int();
// use p
delete p;
p = 0;
Is this wrong then ?

Setting the pointer to null after deletion ensures that if the object
pointed to by the pointer is used in any way, then the program will
crash at the same point during every run so that debugging is easy. Am
I correct?