printing to screen from a vector

[Roffemuffe]

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?

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

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

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:

std::cout << people;

[laserlight]

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.

[Roffemuffe]

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:

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:

// 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:

#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)

[Roffemuffe]

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

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:

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?

[Elysia]

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));