Thread: local objects

Here in this code the function "foo" adds local objects to a global list.
Then the function "bar" tries to access the list. In this simple example it worked.
(I was expecting some garbage values or other errors like invalid memory access).
So to ensure that "foo"'s stack values are destroyed, I made a large array of doubles
(which I later changed to smaller and smaller, and ultimately to 1)
in "bar". And now I get invalid values from the list and mem errors too.
I was expecting this to happen. Because the objects were created on stack so they were
gone!
Now is there a better way to do the same i.e. :
the "foo" function will create new objects
and the "bar" function will access them.

There is only way on my mind right now i.e. to create objects using "new".
Help Please!

Code:

#include <iostream>
#include <string>
#include <list>
#include <cmath>

using namespace std;

typedef list<string> mylist;

mylist msg_list;

void foo()
{
	string h("Hello");
	string w("World");

	msg_list.push_back(h);
	msg_list.push_back(w);
}

void bar()
{
	double vals[1024];
	for (int i=0; i<sizeof(vals)/sizeof(double); ++i)
	{
		vals[i] = i * sin(3.1415/180.0 * i);
	}

	mylist::const_iterator it = msg_list.begin();
	while (it != msg_list.end())
	{
		cout << "Msg: " << *it << endl;
		++it;
	}
}

int main()
{
	foo();
	bar();

	return 0;
}

sizeof() tells you the number of bytes, not the number of subscripts.

Your variables are static globals so all functions have access to them.

> Here in this code the function "foo" adds local objects to a global list.
Except it doesn't, it makes a copy.

> msg_list.push_back(h);
This creates a copy of h, and stores that.

Try it using a small class of your own so you can trace the instances of constructor, destructor, copy and assignment.

The function call itself might take a reference, but that doesn't take into account what happens inside push_back().

Yes, standard containers make a copy of what you put in. Push-back takes a reference to be able to do it with only one copying of the object instead of two (one for the container, one when passing a copy to the function in the first place).