printing to screen from a vector

I want to make a vector that can input data to via classes and save it in a file.

I have done some testing but I don't see how I do cout the entries?
I am assuming I have a vector here?

Code:

ParentClass people[ ] = {
			SubClass("Name", "Adress", Phone)
	};

I have made all the appropriate classes and and when running, I get this output:

Code:

ParentClass constructor...
SubClass constructor...
SubClass destructor...
ParentClass destructor...
0x22fef0ParentClass destructor...

the last one is a little weird... did I forget to delete something?

I tried this, but it doesn't print extra anything on screen:

Code:

std::cout << people;

One problem is that people is an array of ParentClass objects. You created a SubClass object, and SubClass is presumably derived publicly from ParentClass, but then type slicing happens: people[0] is a ParentClass object, not a SubClass object, but with parts that are a copy of the ParentClass subobject of the SubClass temporary object.

A solution here is to store an array of (smart) pointers to ParentClass. These pointers can thus point to SubClass objects.

Yes, SubClass is derived from ParentClass.

the "string Name" and "string Adress" are in the ParentClass, while "int Phone" is in the SubClass.

How would I use pointers to point directly to an object in the class? and should I make another array to save those pointers in?

In the final programme, I will be writing the arrays to a file and save that file and not to the screen (just mentioning the full scenario), but I assume the process is pretty much the same.

The full code is as follows:
ParentClass.h:

Code:

class ParentClass
protected:
	ParentClass();														// constructor
	ParentClass(string Name, string Adress);	// overloaded constructor!
	virtual string GetName() const { return itsName; }		// inline constant funktion
	virtual void SaveName(string Name) { itsName = Name; }		// inline function
	virtual string GetAdress() const {return itsAdress; }		// inline constantfunction
	virtual void SaveAdress(string Adress) { itsAdress = Adress; }	// inline function
private:
            string itsName;
            string itsAdress;

// overloaded ParentClass
ParentClass::ParentClass(string Name, string Adress):			         itsName(Name), itsAdress(Adress)
{
	cout << "ParentClass constructor...\n";
}

SubClass.h:

Code:

// inheritance from ParentClass
class SubClass: virtual public ParentClass	{
public:
	SubClass();
	SubClass(string Name, string Adress, int Phone); // overloaded constructor
	virtual ~SubClass() { std::cout << "SubClass destructor...\n"; }	// destructor!
	virtual string GetPhone() const { return itsPhone; }
private:
	int itsPhone;
};
// overloaded SubClass

SubClass::SubClass(string Name, string Adress, int Phone):
		    ParentClass(Name, Adress),
		    itsPhone(Phone)
{
	cout << "SubClass constructor...\n";
}

and finally main.ccp:

Code:

#include <iostream>
#include <string>
#include "ParentClass.h"
#include "SubClass.h"

using std::string;

int main() {
	// Array of objects to store in file.
ParentClass people[ ] = {
			SubClass("Name", "Adress", Phone)
	};

std::cout << people;

(I've changed the names of the classes to English, so it's easier to read)m so if there is some syntaxes in names, don't mind it, it's not there in my programme)

This is the solution I've come up with so far:

Code:

SubClass *pSubs = new SubClass("Billy", "Home", 555);

	string name = pSubs->GetName();
	string adress = pStud->GetAdress();
	string phone = pStud->GetPhone();
	std::cout << name << ", " << adress << ", " << phone << std::endl;

	delete pSubs;

output:

Code:

ParentClass constructor...
SubClass constructor...
Billy, Home, 555
SubClass destructor...
ParentClass destructor...

I got rid of that weird extra destructor too.

This seems like a fine solution for one entry, but I have no idea where to begin with multiple entries?
And how do I move this pointer into a vector? or should I use an array instead?

std::vector<std::shared_ptr<ParentClass>> v;
v.push_back(std::make_shared<SubClass>("Billy", "Home", 555));
//...

This assumes you use C++0x. Otherwise this won't work.
std::shared_ptr is a smart pointer. It will automatically delete the memory for you.
std::make_shared creates a shared pointer with an appropriate object. It is equivalent with:

std::shared_ptr<SubClass>(new SubClass("Billy", "Home", 555));