Ich habe eine Klassenstruktur, bestehend aus einer Superklasse und zwei davon abgeleteten Klassen (A & B).

Jetzt würde ich gerne ein Array erstellen, welches Elemente sowohl von A als auch von B enthalten kann.

Wie mache ich das?

Grüße, pktm

Dann könntest du die Elemente in das Array einfügen und wenn du auf sie zugreifst wird zur Laufzeit entschieden, ob es sich um Klasse A oder Klasse B handelt.

Viele Grüße
Andreas

Bei der Verwendung des Datentype der Superklasse hatte ich das Problem, dass ich die Eigenschaften der Unterklassen verlor, wenn ich die Objekte in dieses Array aufnahm.
Beispiel:

#include <iostream>
#include <string>
using namespace std;

int main()
{

	class Test
	{
		public:
			string name;
	};

	class MyTest : public Test
	{
		public: 
			int zahl;

	};

	Test array[2];

	MyTest olaf;

	olaf.name = "Peter";
	olaf.zahl = 5;

	Test irina;
	irina.name = "hans";

	array[0] = olaf;

	cout << array[0].name << " " << array[0].zahl << "\n";

	system("pause");

}

Grüße, pktm

#include <iostream> 
#include <string> 
using namespace std; 

int main() 
{ 
    class Test 
    { 
        public: 
            virtual void SetName(string name){};
            virtual string GetName(){};
            string m_sname; 
    }; 

    class MyTest : public Test 
    { 
        public: 
            void SetName(string name){m_sname = name};
            string GetName(){return m_sname;}
            int zahl; 
    }; 

    Test* array[2]; 

    MyTest* olaf = new MyTest; 

    olaf->SetName(string("Peter"); 
   // olaf.zahl = 5; 

    MyTest* irina = new MyTest; 
    irina->SetName("hans"); 

    array[0] = olaf; 
    array[1] = irina; 

    cout << array[0]->GetName() << " " << array[1]->GetName() << "\n"; 

    system("pause");
}

Ich habs jetzt aber nicht ausprobiert, kann sein das kleinere fehler drin sind

#include <iostream> 
#include <string> 
using namespace std; 

int main() 
{ 
    class Test 
    { 
        string m_sname;     
		public: 
            virtual void SetName(string name){}; 
            virtual string GetName(){return "";}; 

    }; 

    class MyTest : public Test 
    { 
        public: 
            void SetName(string name){m_sname = name;} 
            string GetName(){return m_sname;} 
            int zahl; 
    }; 

    Test* array[2]; 

    MyTest* olaf = new MyTest; 

    olaf->SetName(string("Peter")); 
   // olaf.zahl = 5; 

    MyTest* irina = new MyTest; 
    irina->SetName(string("hans")); 

    array[0] = olaf; 
    array[1] = irina; 

    cout << array[0]->GetName() << " " << array[1]->GetName() << "\n"; 

    system("pause"); 
	return 0;
}

error C2248: "main::Test::m_sname": Kein Zugriff auf private Member, dessen Deklaration in der main::Test-Klasse erfolgte.

:-S

Ich hab hier Visual C++ Express Edition 2005 (Version 8.0).

So viel Ahnung hab ich von C++ leider noch nicht, hoffe ihr könnt mir noch ein bißchen helfen.

Erweitert um Methoden für Zahl.

#include <iostream> 
#include <string> 
using namespace std; 

int main() 
{ 
    class Test 
    { 
		string m_sname;
        public: 
            virtual void SetName(string name){}; 
            virtual string GetName(){return "";}; 

    }; 

    class MyTest : public Test 
    { 
		private:
			int m_zahl;
        public: 
            void SetName(string name){m_sname = name;} 
            string GetName(){return m_sname;} 
			void SetZahl(int z){m_zahl = z;} 
			int GetZahl(){return m_zahl;} 
    }; 

    Test* array[2]; 

    MyTest* olaf = new MyTest;

    olaf->SetName(string("Peter"));
    olaf->SetZahl(5); 

    MyTest* irina = new MyTest; 
    irina->SetName(string("hans")); 

    array[0] = olaf; 
    array[1] = irina; 

    cout << array[0]->GetName() << " " << array[1]->GetName() << array[0]->GetZahl() << "\n"; 

    system("pause"); 
    return 0; 
}

ja sry das hatte ich noch übersehen, was passiert denn wenn du über die Deklaration von m_sname in Test "protected:" schreibst?

Ja, damit geht es. Erklärst du mir warum?

Was zudem aber nicht geht ist der zugriff auf eine nicht in der Superklasse vorhandenen Methode. Die scheint wieder getilgt zu werden. Oder kann man irgendwie angeben, ob man ein Objekt eines bestimmten Typs interpolieren will? In Java geht sowas z.B. so: Typ variable = (Typ)variableVonAnderemTyp;

Hier der momentane Code:

#include <iostream> 
#include <string> 
using namespace std; 

int main() 
{ 
    class Test 
    { 
		protected:
			string m_sname;
        public: 
            virtual void SetName(string name){}; 
            virtual string GetName(){return "";}; 

    }; 

    class MyTest : public Test 
    { 
		protected:
			int m_zahl;
        public: 
            void SetName(string name){m_sname = name;} 
            string GetName(){return m_sname;} 
			void SetZahl(int z){m_zahl = z;} 
			int GetZahl(){return m_zahl;} 
    }; 

    Test* array[2]; 

    MyTest* olaf = new MyTest;

    olaf->SetName(string("Peter"));
    olaf->SetZahl(5); 

    MyTest* irina = new MyTest; 
    irina->SetName(string("hans")); 

    array[0] = olaf; 
    array[1] = irina; 

    cout << array[0]->GetName() << " " << array[1]->GetName() << array[0]->GetZahl() << "\n"; 

    system("pause"); 
    return 0; 
}

Grüße, pktm

Für die Methoden gilt das gleiche, deshalb konntest du ja auch auf die Methoden wie SetName, etc zugreifen, weil sie als public deklariert waren.

Um auf eine Methode oder Membervariable einer Abgleiteten Klasse zugreifen zu können kannst du schreiben:

MyTest* dummy = (MyTest*) array[0];
dummy->GetZahl();

in diesem Fall:

cout << array[0]->GetName() << " " << array[1]->GetName() << ((MyTest*)array[0])->GetZahl() << "\n";

#include <string> // std::string
#include <vector> // std::vector
#include <memory> // std::auto_ptr
#include <iostream> // std::cout

class base
{
    std::string m_name;

public:
    base(std::string const& name)
        : m_name(name)
    {}

public:
    std::string const& get_name() const { return m_name; }
};

class derived : public base
{
    int m_data;

public:
    derived(int data, std::string const& name)
        : base(name), m_data(data)
    {}

public:
    int get_data() const { return m_data; }
};

int main()
{
    // std::vector< std::auto_ptr<base> > data;
    std::vector<base*> data;
    data.push_back(new base("{- base instance -}"));
    data.push_back(new derive(10, "{- derived instance -}"));

    std::cout << "#01: " << data[0]->get_name() 
              << "#02: " << data[1]->get_name()
              << "    - data := " << static_cast<derived*>(data[1])->get_data() << std::endl;

    // bei std::auto_ptr nicht notwendig! Sonst Speicher freigeben!
    for (std::vector<base*>::iterator it(data.begin()); it != data.end(); ++it)
        delete (*it);
}

... so wäre es doch schöner, oder?