void BestOfList::additem(Calander toadd) {
    int score = toadd.score();
    size_t len = Scores.size();
    if(score < 0) {return;}
    printf("Adding to list will continue - score >= 0\n");
    // Calander is failed or just very bad.
    for(unsigned int i = 0; i < len; i++) {
        printf("Checking to see if calander toadd is the same calander %u\n",i);
        if(score == Scores[i]) {
            if(toadd == Calanders[i]) {
                printf("Calander is the same. returning...\n");
                return;
            }
        }
    }

    // We already have calander in the list because the
    // same calander can be created multiple ways
    printf("toadd passed required checks. adding Calander...\n");
    Scores.push_back(score);
    printf("pushed back score\n");
    Calanders.push_back(toadd); // <- Line causing problem
    printf("pushed back calander\n");
    reorder();
    resize();
}

class BestOfList {
private:
    vector<int> Scores;
    vector<Calander> Calanders;
    void resize();
    void reorder();
public:
    void additem(Calander toadd);
    int getscore(unsigned int index);
    Calander getcalander(unsigned int index);
    unsigned int length();
    void empty();
};

(snip)
Calander is not a failure. Continuing test.
Returning score of 60000
Adding to list will continue - score >= 0
toadd passed required checks. adding Calander...
pushed back score
pushed back calander
Reordering calander...
Resizing Calander...
Appointment at 0,14
Adding appointment 3
(snip)
Adding to list will continue - score >= 0
Checking to see if calander toadd is the same calander 0
toadd passed required checks. adding Calander...
pushed back score
*** glibc detected *** double free or corruption (!prev): 0x08054810 ***

#include <iostream>
#include <vector>
#include <string>

using namespace std;

class foo{
    public:
        foo(){ lock=1; name=""; }
        void nameFoo(string n) { name=n; }
        void unlock() { lock=0; }
        void print(){ if(!lock) cout << "in a foo: " << name << endl; }
        int lock;
        string name;
};

class foolist{
    public:
        vector<foo> v;
        void add(foo f) { v.push_back(f); }
        void list(){
            for(int i=0; i<v.size(); ++i){
                v[i].print();
            }
        }
};

/* the copy in here will be pushed onto the list, and can be read only from list when it goes out of scope.. */
void bar(foolist& l){
    foo temp;       // this foo is local scope and should DIE
    temp.unlock();  // unlock it so we can be sure it is this one being printed
    temp.nameFoo("dead Foo?");  // name it too just for fun
    l.add(temp);    // push it onto the list from main.
}

int main(){
    foolist l;
    foo f;

    f.unlock();     // unlock it so we can be sure it is this foo
    f.nameFoo("main's Foo");    // name it
    l.add(f);       // add one foo here
    bar(l);         // add another foo that goes out of scope here..
    l.list();       // shows two foos here
    return 0;
}

~foo()
{
	cout <<name <<"  out of scope\n";
}

void add(foo f) { v.push_back(f); }

#include <iostream>
#include <vector>
#include <string>

using namespace std;

class foo{
    public:
        foo(){ lock=1; name=""; }
        ~foo(){cout <<name <<"  out of scope\n";}
        void nameFoo(string n) { name=n; }
        void unlock() { lock=0; }
        void print(){ if(!lock) cout << "in a foo: " << name << endl; }
        int lock;
        string name;
};

class foolist{
    public:
        vector<foo*> v;
        void add(foo* f) { f->nameFoo("in foolist"),v.push_back(f); }
        void list(){
            for(int i=0; i<v.size(); ++i){
                v[i]->print();
            }
        }
};

/* the copy in here will be pushed onto the list, and can be read only from list when it goes out of scope.. */
void bar(foolist& l){
    foo temp;       // this foo is local scope and should DIE
    temp.unlock();  // unlock it so we can be sure it is this one being printed
    temp.nameFoo("dead Foo?");  // name it too just for fun
    l.add(&temp);    // push it onto the list from main.
    temp.nameFoo("dead Foo?");  // name it too just for fun
}

int main(){
    foolist l;
    foo f;

    f.unlock();     // unlock it so we can be sure it is this foo
    f.nameFoo("main's Foo");    // name it
    l.add(&f);       // add one foo here
    f.nameFoo("main's Foo");    // name it
    bar(l);         // add another foo that goes out of scope here..
    l.list();       // shows two foos here
    return 0;
}

dead Foo?  out of scope
in a foo: main's Foo
in a foo: dead Foo?
main's Foo  out of scope
Press Enter to continue!

Vector
Cost of overflowing allocated storage
A vector starts by grabbing a block of storage, as if it’s taking a guess at how many objects
you plan to put in it. As long as you don’t try to put in more objects than can be held in the
initial block of storage, everything is very rapid and efficient (note that if you do know how
many objects to expect, you can pre-allocate storage using reserve( )). But eventually you
will put in one too many objects and, unbeknownst to you, the vector responds by:
1. Allocating a new, bigger piece of storage
2. Copying all the objects from the old storage to the new (using the copy-constructor)
3. Destroying all the old objects (the destructor is called for each one)
4. Releasing the old memory
For complex objects, this copy-construction and destruction can end up being very expensive
if you overfill your vector a lot. To see what happens when you’re filling a vector, here is a
class that prints out information about its creations, destructions, assignments and copyconstructions:

foolist(){ v.reserve(10); }

main's Foo out of scope              <--- ???
dead Foo? out of scope               <--- ???
dead Foo? out of scope
in a foo: main's Foo
in a foo: dead Foo?
main's Foo out of scope
in foolist::~foolist()
main's Foo out of scope
dead Foo? out of scope