why is the iterator not initialized in this code - c++

Question

In the code below, Class A has a vector of ints. Class B inherits from A and has an iterator to the vector. The constructor of B initializes the iterator of B. But when we print, we get garbage. Why does the cout in main print garbage? Am I missing something?
#include <iostream>
#include <vector>
class A {
public:
A() {}
A(const A& copyFrom) : intList(copyFrom.intList) {} //copy constructor
virtual ~A() {}
void populateList()
{
for(int i=10; i<100; i++)
{
intList.push_back(i);
}
}
protected:
std::vector<int> intList;
};
class B : public A {
public:
B() : A() {}
B(const A& a) : A(a), intIt(intList.begin())
{
std::cout << "constructor with base class param called" << std::endl;
}
B(const B& b) : A(b), intIt(intList.begin()) //copy constructor
{
std::cout << "copy constructor called" << std::endl;
}
std::vector<int>::iterator intIt;
};
int main() {
A a;
a.populateList();
B b ;
b = B(a);
std::cout << *b.intIt << std::endl; //prints garbage. why?
}
Thanks!

Answer 1

B b ;
b = B(a); //the copy constructor of B is not called here. Why?
The operation in that line is assignment, not copy constructor. The copy constructor would be:
B b = someotherB;
Note that semantically this is also copy-constructing:
B b = B(a);
But the compiler will more often than not elide the copy contruction by creating B(a) in place of b.

Answer 2

The expression b = B(a) separated from declaration is assignment, not copy construction. This is one of the confusing things about C++:
Foo x(y); // copy-construction
Foo x = y; // also copy-construction, equivalent to the above
Foo x; x = y; // default-construction followed by assignment, different
// (and possibly less efficient) than the above
Failing to define an assignment operator will create a default one that performs member-wise assignment. This is OK for the intList member, but the assigned intIt will keep pointing to the old list, which in your case belongs to the temporary reference to B created by the B(a) expression. As soon as this reference is destroyed (which is at the end of the outermost expression), its intList is destroyed and the iterator becomes invalid.
In other words, B b; b = B(a) is equivalent to:
B b; // constructor
{
B tmp(a); // copy constructor
b = tmp; // member-wise assignment
// at this point, b.intList is a copy of tmp.intList, but b.intIt
// points to the beginning of tmp.intList, not to the beginning of
// b.intList
}
// tmp is destroyed and b.intIt now points to the beginning of a deleted list
It is your responsibility to define an assignment operator that maintains the invariant of intIt referring to an element in intList; for example:
B& operator=(const B& rhs)
{
intList = rhs.intList;
intIt = intList.begin() + (rhs.intIt - rhs.intList.begin());
std::cout << "assignment called" << std::endl;
return *this;
}
Also note that all iterators into the vector are invalidated when you change the size of the vector, even if you only append with push_back(). So populateList(), and other methods that can change the size of the vector should be overridden in B to also recalculate intIt. For these reasons it would be a better idea to avoid using an iterator and simply store the position into the vector, and have a function that returns intList.begin() + pos, thus creating an iterator on-demand that is guaranteed to be valid. Then you wouldn't need to define neither a copy-constructor nor an assignment operator, as the compiler-supplied defaults would work just fine.

Answer 3

The Copy construction will not be called because you are not assigning object of same class
b = B(a); //the copy constructor of B is not called here. Why?
in above code below constructor will be called because you are passing object of type A
B(const A& a) : A(a), intIt(intList.begin())
{
std::cout << "constructor with base class param called" << std::endl;
}
Iterator value will not be usable because you are not initializing it
std::cout << *(b.intIt) << std::endl; //prints garbage. why?
you need to initalize it
std::vector<X>::iterator iter; //no particular value
iter = some_vector.begin(); //iter is now usable