jak polaczyc polimorfizm z kontenerami

0

Witajcie.

Aby jasno sformulować problem, pozwole sobie na krotki wstep.
Oczywiste jest, ze jesli stworze jakas klase (podstawowa) i zdefiniuje w niej pewna wirtualna funkcje skladowa, to tworzac klase pochodna od danej klasy podstawowej moge w niej zdefiniowac funkcje o tej samej nazwie i liscie parametrow formalnych, lecz innym ciele. Wowczas, jesli napisze funkcje zewnetrzna, przyjmująca jako parametr formalny wskaznik (badz referencje) do obiektu klasy podstawowej, w ciele ktorej siedzi wywołanie funkcji wirtualnej na rzecz danego wskaznika (badz referncji), to taka funkcja zewnetrzna moze przyjac rowniez wskaznik (badz referencje) do obiektu klasy pochodnej i wywolac funkcje wirtualna juz na rzecz tegoz. To sie nazywa polimorfizm.

A teraz moj problem.
Otoz mam klase podstawowa Obiekt1 i pochodna od niej klase Obiekt2. W tych klasach definiuje funkcje wirtualna. W programie głównym definiuje typy listowe w postaci:

typedef list <Obiekt1 *> ListaObiektow1;
typedef list <Obiekt2 *> ListaObiektow2;
ListaObiektow1  lista1;
ListaObiektow2  lista2;

Moje pytanie brzmi: czy mozna stworzyc funkcje zewnetrzna, ktora formalnie przyjmowac bedzie w jakis sposob parametr typu ListaObiektow1, ale bedzie mozna do niej równiez przeslać parametr typu ListaObiektow2? W skrocie moge zapytac: czy jezeli istnieje dziedziczenie klas, to czy moze istniec pewne dziedziczenie tak zdefiniowanych typow list?

Chcialbym bowiem moc korzystac z polimorfizmu zwiazanego z powyzszymi klasami, ale majac jednoczesnie zgrupowane w listach wskazniki do obiektow klas.

Mam nadzieje, że powyzszy wywod jest zrozumialy

Teraz przykladowy kod (pisze go na sucho, by przedstawic problem wiec moze nie dzialac):

//---------------- 
//   DEFINICJE KLAS

class Obiekt1
{
   public:
          virtual void funkcja () { cout << "jestem z klasy Obiekt1" <<endl;}
};
class Obiekt2: public Obiekt1
{
   public:
          void funkcja () { cout << "jestem z klasy Obiekt2" <<endl;}
};
//----------------
//   DEFINICJE I DEKLARACJE FUNKCJI GLOBALNYCH
typedef list <Obiekt1 *> ListaObiektow1;
typedef list <Obiekt2 *> ListaObiektow2;

ListaObiektow1  lista1;
ListaObiektow2  lista2;

    void SpecFun (Obiekt1 *)
    void SpecFunList (ListaObiektow1) // - potrzebuje wlasnie takiej analogicznej funkcji
			   	       //   dla list


//----------------
//   PROGRAM GLOWNY
int main()
{
    Obiekt1 *ob1;
    Obiekt2 *ob2;
    
// dynamiczne stworzenie 3 wskazników do obiektow obu klas i zapisanie ich do 
// odpowiednich list 

   for(int i=0; i<3; i++)
  {
     ob1 = new Obiekt1;
     lista1.push_back(ob1);
     ob2 = new Obiekt2;
     lista2.push_back(ob2);
  }

// wywolanie funkcji wirtualnych na rzecz poszczegolnych skladnikow list

    ListaObiektow1::iterator i1;
    ListaObiektow2::iterator i2;

// za pomoca specjalnej funkcji Spec_Fun(Obiekt1 *) robimy to dla pojedynczego skladnika 
// (w tym wypadku pierwszego) listy

    i1 = lista1.begin();
    ob1 = (*i1);
    Spec_Fun(ob1);

    i2 = lista2.begin();
    ob2 = (*i2);
    Spec_Fun(ob2);


// za pomoca petli po wszystkich skladnikach listy

    while(i1 != lista1.end())
    {
     	ob1 = (*i1);
	ob1->funkcja();
	i1++;
    }
        
    while(i2 != lista2.end())
    {
     	ob2 = (*i2);
	ob2->funkcja();
	i2++;
    }

// a wiec jesli chce wywolac funkcje wirtualna funkcja() dla wszystkich 
// skladnikow list to musze to zrobic w petlach, a wolalbym na przyklad
// tak:
   
   SpecFunList(lista1);
   SpecFunList(lista2);


// zwalnianie pamieci
   i1 = lista1.begin();
   while (i1 != lista1.end()) 
   {
       delete (*i1);
          ++i1;
   }
   i2 = lista2.begin();
   while (i2 != lista2.end()) 
   {
       delete (*i2);
          ++i2;
   }

  return 0;
}

//----------------
//DEFINICJE FUNKCJI GLOBALNYCH

    void SpecFun (Obiekt1 * obiekt)
    {
	obiekt->funkcja();
    }

    void SpecFunList (ListaObiektow1 lista) // to pewnie powinno byc inaczej ale w takim sensie
    {
      ListaObiektow1::iterator i;
      Obiekt1 * ob;
      
      i = lista.begin();
      while(i != lista.end())
      {
     	  ob = (*i);
	  ob->funkcja();
	  i++;
      }
    }

 

Jesli ktos wytrwal do konca tego zawilego tlumaczenia to bardzo dziekuje i prosze o pomoc wwyjasnieniu kwestii.

Pozdrawiam

0

Może funkcja szablonowa ? :-/

0

A moge poprosic o jakis przyklad realizacji. Dzieki.

0

Poczytaj o funkcjach szablonowych (Templates) i sam zmontujesz.
w SPACJA końcu obiekty listy których używasz to też szablony .

0

Sorki, za poprzedni poast, ale nie doczytałem że Obiekt2 dziedziczy po Obiekt1. Wystarczy że użyjesz typedef list <Obiekt1 *> ListaObiektow1; dla obu obiektów. Skoro funkcja w Obiekt1 jest wirtualna to automatycznie funkcja w Obiekt2 też jest, więc po co dwa typedefy ?

0

Zrób wspólną klasę czysto wirtualną dla Obiekt1 i Obiekt2 i po zabiegu. :-)

0
dzejo napisał(a)

Zrób wspólną klasę czysto wirtualną dla Obiekt1 i Obiekt2 i po zabiegu. :-)

Ale po co skoro jedna dziedziczy po drugiej...

0

Masz rację :-)

0

DzieX:

czy chodzi Tobie o taki zapis

typedef list <Obiekt1 *> ListaObiektow1, ListaObiektow2;
ListaObiektow1 lista1;
ListaObiektow2 lista2;

czy moze tak

typedef list <Obiekt1 *> ListaObiektow1;
ListaObiektow1 lista1, lista2;
0

Przecież to to samo ;P Ale drugi lepszy, bo mniej typedefów :)

0

No tak :-/ Poczatkujacy jestem ... ;-)

0

Jednak powyzsza czesc kodu nie spelnia moich wymagan.

Moze inaczej sformuluje pytanie: Jak rozpoznac typ elementow listy?

Jesli mam listy

typedef list <Obiekt1 *> ListaObiektow1;
typedef list <Obiekt2 *> ListaObiektow2;

i chcialbym, aby zdefiniowana przeze mnie funkcja, ktora formalnie przyjmuje liste ListaObiektow1, mogla tez przyjac ListaObiektow2. Przypomne, ze klasa Obiekt2 dziedziczy od klasy Obiekt1.

Czy to sie da zrobic?

0

No dobra, skoro nie daje tak rady to napisz to co dziejo wcześniej mówił.

template<class T>
void SpecFun(T param)
{
    T::iterator i;
         
    i = param.begin();
    while(i != param.end())
    {
        i->funkcja();
        i++;
    }
}

Jednak nie gwarantuje, ze sie nigdzie nie pomyliłem bo nie mam dostepu do kompilatora.

0

Gotowy Kod

#include <list.h>
#include <iostream.h>
class Obiekt1
{
   public:
          virtual void funkcja () { cout << "jestem z klasy Obiekt1" <<endl;}
};
class Obiekt2: public Obiekt1
{
   public:
          void funkcja () { cout << "jestem z klasy Obiekt2" <<endl;}
};
//----------------
//   DEFINICJE I DEKLARACJE FUNKCJI GLOBALNYCH
typedef list <Obiekt1 *> ListaObiektow1;
typedef list <Obiekt2 *> ListaObiektow2;

ListaObiektow1  lista1;
ListaObiektow2  lista2;

    void SpecFun (Obiekt1 *) ;
   /*
    void SpecFunList (ListaObiektow1) ;//potrzebuje wlasnie takiej analogicznej funkcji
   */

//------------No to masz :-)
//-----------------------------------------------------------------------------
// -----------Ta Funkcja działa dla Obiekt1 i Obiekt2 poprzez polimorfizm
//------------i poprzez szablon Powodzenia
 template <typename Typ1>
 void SpecFunList (Typ1 lista) 
    {


      Typ1::iterator i;
      Obiekt1 * ob;

      i = lista.begin();
      while(i != lista.end())
      {
               ob = (*i);
          cout << "dziala szablon SpecFunList dla obiektu ->";
          ob->funkcja();


          i++;
      }


    }

//----------------------------------------------------------------------------------
//----------------
//   PROGRAM GLOWNY
int main()
{
    Obiekt1 *ob1;
    Obiekt2 *ob2;

// dynamiczne stworzenie 3 wskazników do obiektow obu klas i zapisanie ich do
// odpowiednich list

   for(int i=0; i<3; i++)
  {
     ob1 = new Obiekt1;
     lista1.push_back(ob1);
     ob2 = new Obiekt2;
     lista2.push_back(ob2);
  }

// wywolanie funkcji wirtualnych na rzecz poszczegolnych skladnikow list

    ListaObiektow1::iterator i1;
    ListaObiektow2::iterator i2;

// za pomoca specjalnej funkcji Spec_Fun(Obiekt1 *) robimy to dla pojedynczego skladnika
// (w tym wypadku pierwszego) listy

    i1 = lista1.begin();
    ob1 = (*i1);
    SpecFun(ob1);

    i2 = lista2.begin();
    ob2 = (*i2);
    SpecFun(ob2);


// za pomoca petli po wszystkich skladnikach listy

    while(i1 != lista1.end())
    {
             ob1 = (*i1);
        ob1->funkcja();
        i1++;
    }

    while(i2 != lista2.end())
    {
             ob2 = (*i2);
        ob2->funkcja();
        i2++;
    }

// a wiec jesli chce wywolac funkcje wirtualna funkcja() dla wszystkich
// skladnikow list to musze to zrobic w petlach, a wolalbym na przyklad
// tak:

   SpecFunList(lista1);
   SpecFunList(lista2);


// zwalnianie pamieci
   i1 = lista1.begin();
   while (i1 != lista1.end())
   {
       delete (*i1);
          ++i1;
   }
   i2 = lista2.begin();
   while (i2 != lista2.end())
   {
       delete (*i2);
          ++i2;
   }

     cout <<" Koniec nacisnij ENTER" << endl ;
     cin.get();

  return 0;
}

//----------------
//DEFINICJE FUNKCJI GLOBALNYCH

// -----------Ta Funkcja działa dla Obiekt1 i Obiekt2 poprzez polimorfizm

    void SpecFun (Obiekt1 * obiekt)
    {
        obiekt->funkcja();
    }


//-------------------Przedefiniowane na szablon !!!!!!!!!!!!!!!!!!
/*
 void SpecFunList (ListaObiektow1 lista) // to pewnie powinno byc inaczej ale w takim sensie
    {
      ListaObiektow1::iterator i;
      Obiekt1 * ob;

      i = lista.begin();
      while(i != lista.end())
      {
               ob = (*i);
          ob->funkcja();
          i++;
      }


    }
    */

Nie sprawdzam poprawnosci kodu(pamięć itp..) mogą byc błedy bo kompilator
zgłasza info o nie wykorzystanych wskażnikach
dodałem tylko szablon .
Kod działający po kompilacji.
<url>
http://www.win32prog.republika.pl
</url>
Albo jazda na całego aby pozbyc się tych Obiekt1 i Obiekt2 dla list i funkcji to:

#include <list.h>
#include <iostream.h>

class Obiekt{
               public:
               virtual void funkcja ()=0 ;
               virtual ~Obiekt(){};
             };
//------------------------------------------------------------------------
class Obiekt1: public Obiekt
{
   public:
          virtual void funkcja () { cout << "jestem z klasy Obiekt1" <<endl;}
};
//------------------------------------------------------------------------
class Obiekt2: public Obiekt             // lub public Obiekt1 jeśli musi tak być
{
   public:
          void funkcja () { cout << "jestem z klasy Obiekt2" <<endl;}
};
//----------------
//   DEFINICJE I DEKLARACJE FUNKCJI GLOBALNYCH
typedef list <Obiekt*> ListaObiektow1;
typedef list <Obiekt*> ListaObiektow2;

ListaObiektow1  lista1;
ListaObiektow2  lista2;

    void SpecFun (Obiekt *) ;
   /*
    void SpecFunList (ListaObiektow1) ;//potrzebuje wlasnie takiej analogicznej funkcji
   */

//------------No to masz :-)
//-----------------------------------------------------------------------------
// -----------Ta Funkcja działa dla Obiekt1 i Obiekt2 poprzez polimorfizm
//------------i poprzez szablon Powodzenia
 template <typename Typ1>
 void SpecFunList (Typ1 lista) 
    {


      Typ1::iterator i;
      Obiekt * ob;

      i = lista.begin();
      while(i != lista.end())
      {
               ob = (*i);
          cout << "dziala szablon SpecFunList dla obiektu ->";
          ob->funkcja();


          i++;
      }


    }

//----------------------------------------------------------------------------------
//----------------
//   PROGRAM GLOWNY
int main()
{
Obiekt * ob ;

// dynamiczne stworzenie 3 wskazników do obiektow obu klas i zapisanie ich do
// odpowiednich list

   for(int i=0; i<3; i++)
  {
     ob = new Obiekt1;
     lista1.push_back(ob);
     ob = new Obiekt2;
     lista2.push_back(ob);
  }

// wywolanie funkcji wirtualnych na rzecz poszczegolnych skladnikow list

    ListaObiektow1::iterator i1;
    ListaObiektow2::iterator i2;

// za pomoca specjalnej funkcji Spec_Fun(Obiekt1 *) robimy to dla pojedynczego skladnika
// (w tym wypadku pierwszego) listy


    i1 = lista1.begin();
    ob = (*i1);
    SpecFun(ob);

    i2 = lista2.begin();
    ob = (*i2);
    SpecFun(ob);


// za pomoca petli po wszystkich skladnikach listy

    while(i1 != lista1.end())
    {
             ob = (*i1);
        ob->funkcja();
        i1++;
    }

    while(i2 != lista2.end())
    {
             ob = (*i2);
        ob->funkcja();
        i2++;
    }

// a wiec jesli chce wywolac funkcje wirtualna funkcja() dla wszystkich
// skladnikow list to musze to zrobic w petlach, a wolalbym na przyklad
// tak:

   SpecFunList(lista1);
   SpecFunList(lista2);


// zwalnianie pamieci
   i1 = lista1.begin();
   while (i1 != lista1.end())
   {
       delete (*i1);
          ++i1;
   }
   i2 = lista2.begin();
   while (i2 != lista2.end())
   {
       delete (*i2);
          ++i2;
   }

     cout <<" Koniec nacisnij ENTER" << endl ;
     cin.get();

  return 0;
}

//----------------
//DEFINICJE FUNKCJI GLOBALNYCH

// -----------Ta Funkcja działa dla Obiekt1 i Obiekt2 poprzez polimorfizm

    void SpecFun (Obiekt * obiekt)
    {
        obiekt->funkcja();
    }


//-------------------Przedefiniowane na szablon !!!!!!!!!!!!!!!!!!
/*
 void SpecFunList (ListaObiektow1 lista) // to pewnie powinno byc inaczej ale w takim sensie
    {
      ListaObiektow1::iterator i;
      Obiekt1 * ob;

      i = lista.begin();
      while(i != lista.end())
      {
               ob = (*i);
          ob->funkcja();
          i++;
      }


    }
    */

Oczywiście jeszcze trzeba wywalić
typedefy X 2
ListaObiektow1 lista1;
ListaObiektow2 lista2;

i wpisac do kodu

typedef list <Obiekt*> ListaObiektow;
ListaObiektow lista1;
ListaObiektow lista2;

ListaObiektow::iterator i1;
ListaObiektow::iterator i2;

Ale mi się nie chce...

bo to to samo...

0

A ostetacznie po wyprowadzeniuObiekt1 i Obiekt2 ze wspólnej klasy bazowej
żadne szablony nie są potrzebne :-) .
Na początku problem stwarzało to że

list <Obiekt1*> ListaObiektow1 i list <Obiekt2*> ListaObiektow2
to dwie różne Klasy List ,Bo list<Obiekt1*> i list<Obiekt2*> jest szablonem
kontenera który wygeneruje dwie niepowiązane ze sobą klasy.

Teraz mamy wspólną klasę list <Obiekt*> ListaObiektow dla Obiekt1 i Obiekt2
można nawet wpakować Obiekt1 i Obiekt2 do jednej Listy ;-)

                                       Obiekt
                                          |
                                       Obiekt1
                                          |
                                       Obiekt2  

albo

                                       Obiekt
                                      /        \
                                Obiekt1     Obiekt2


#include <list.h>
#include <iostream.h>

class Obiekt{
               public:
               virtual void funkcja ()=0 ;
               virtual ~Obiekt(){};
             };
//------------------------------------------------------------------------
class Obiekt1: public Obiekt
{
   public:
          virtual void funkcja () { cout << "jestem z klasy Obiekt1" <<endl;}
};
//------------------------------------------------------------------------
class Obiekt2: public Obiekt1
{
   public:
          void funkcja () { cout << "jestem z klasy Obiekt2" <<endl;}
};
//----------------
//   DEFINICJE I DEKLARACJE FUNKCJI GLOBALNYCH
typedef list <Obiekt*> ListaObiektow;


ListaObiektow  lista1;
ListaObiektow  lista2;

    void SpecFun (Obiekt *) ;

    void SpecFunList (ListaObiektow) ;//potrzebuje wlasnie takiej analogicznej funkcji



//------------Niepotrzebny SZABLON-----------------------------------
 /*
 template <typename Typ1>
 void SpecFunList (Typ1 lista) // to pewnie powinno byc inaczej ale w takim sensie
    {


      Typ1::iterator i;
      Obiekt * ob;

      i = lista.begin();
      while(i != lista.end())
      {
               ob = (*i);
          cout << "dziala szablon SpecFunList dla obiektu ->";
          ob->funkcja();


          i++;
      }


    }
    */

//----------------------------------------------------------------------------------
//----------------
//   PROGRAM GLOWNY
int main()
{
Obiekt * ob ;

// dynamiczne stworzenie 3 wskazników do obiektow obu klas i zapisanie ich do
// odpowiednich list

   for(int i=0; i<3; i++)
  {
     ob = new Obiekt1;
     lista1.push_back(ob);
     ob = new Obiekt2;
     lista2.push_back(ob);
  }

// wywolanie funkcji wirtualnych na rzecz poszczegolnych skladnikow list

    ListaObiektow::iterator i1;
    ListaObiektow::iterator i2;

// za pomoca specjalnej funkcji Spec_Fun(Obiekt1 *) robimy to dla pojedynczego skladnika
// (w tym wypadku pierwszego) listy


    i1 = lista1.begin();
    ob = (*i1);
    SpecFun(ob);

    i2 = lista2.begin();
    ob = (*i2);
    SpecFun(ob);


// za pomoca petli po wszystkich skladnikach listy

    while(i1 != lista1.end())
    {
             ob = (*i1);
        ob->funkcja();
        i1++;
    }

    while(i2 != lista2.end())
    {
             ob = (*i2);
        ob->funkcja();
        i2++;
    }

// a wiec jesli chce wywolac funkcje wirtualna funkcja() dla wszystkich
// skladnikow list to musze to zrobic w petlach, a wolalbym na przyklad
// tak:

   SpecFunList(lista1);
   SpecFunList(lista2);


// zwalnianie pamieci
   i1 = lista1.begin();
   while (i1 != lista1.end())
   {
       delete (*i1);
          ++i1;
   }
   i2 = lista2.begin();
   while (i2 != lista2.end())
   {
       delete (*i2);
          ++i2;
   }

     cout <<" Koniec nacisnij ENTER" << endl ;
     cin.get();

  return 0;
}

//----------------
//DEFINICJE FUNKCJI GLOBALNYCH

// -----------Ta Funkcja działa dla Obiekt1 i Obiekt2 poprzez polimorfizm

    void SpecFun (Obiekt * obiekt)
    {
        obiekt->funkcja();
    }


//-------------------Teraz  OK

 void SpecFunList (ListaObiektow lista) // to pewnie powinno byc inaczej ale w takim sensie
    {
      ListaObiektow::iterator i;
      Obiekt * ob;

      i = lista.begin();
      while(i != lista.end())
      {
               ob = (*i);
          ob->funkcja();
          i++;
      }


    }

I jak napisał ----DzieX--- na początku---- wystarczy dać jeden typedef
zdefiniować listy typu list <Obiekt1*> dla Obiekt1 i Obiekt2

typedef list <Obiekt1*> ListaObiektow;

ListaObiektow lista1;
ListaObiektow lista2;

Dać Funkcje w postaci

 void SpecFunList (ListaObiektow lista) // to pewnie powinno byc inaczej ale w takim sensie
    {
      ListaObiektow::iterator i;
      Obiekt1 * ob;

      i = lista.begin();
      while(i != lista.end())
      {
               ob = (*i);
          ob->funkcja();
          i++;
      }


    }

-------------------------------Uwaga-----------------------------------
Oraz powrócić do pierwszej wersji programu i wtedy nie trzeba stosowac szablonu
ani wspólnej klasy bazowej.

Bazową jest wtedy Obiekt1. :-) :-) :-)
Gotowiec:

#include <list.h>
#include <iostream.h>


//------------------------------------------------------------------------
class Obiekt1
{
   public:
          virtual void funkcja () { cout << "jestem z klasy Obiekt1" <<endl;}
};
//------------------------------------------------------------------------
class Obiekt2: public Obiekt1
{
   public:
          void funkcja () { cout << "jestem z klasy Obiekt2" <<endl;}
};
//----------------
//   DEFINICJE I DEKLARACJE FUNKCJI GLOBALNYCH


typedef list <Obiekt1*> ListaObiektow;
ListaObiektow  lista1;
ListaObiektow  lista2;

    void SpecFun (Obiekt1 *) ;

    void SpecFunList (ListaObiektow) ;//potrzebuje wlasnie takiej analogicznej funkcji
//----------------
//   PROGRAM GLOWNY
int main()
{
Obiekt1 * ob ;

// dynamiczne stworzenie 3 wskazników do obiektow obu klas i zapisanie ich do
// odpowiednich list

   for(int i=0; i<3; i++)
  {
     ob = new Obiekt1;
     lista1.push_back(ob);
     ob = new Obiekt2;
     lista2.push_back(ob);
  }

// wywolanie funkcji wirtualnych na rzecz poszczegolnych skladnikow list

    ListaObiektow::iterator i1;
    ListaObiektow::iterator i2;

// za pomoca specjalnej funkcji Spec_Fun(Obiekt1 *) robimy to dla pojedynczego skladnika
// (w tym wypadku pierwszego) listy


    i1 = lista1.begin();
    ob = (*i1);
    SpecFun(ob);

    i2 = lista2.begin();
    ob = (*i2);
    SpecFun(ob);


// za pomoca petli po wszystkich skladnikach listy

    while(i1 != lista1.end())
    {
             ob = (*i1);
        ob->funkcja();
        i1++;
    }

    while(i2 != lista2.end())
    {
             ob = (*i2);
        ob->funkcja();
        i2++;
    }

// a wiec jesli chce wywolac funkcje wirtualna funkcja() dla wszystkich
// skladnikow list to musze to zrobic w petlach, a wolalbym na przyklad
// tak:

   SpecFunList(lista1);
   SpecFunList(lista2);


// zwalnianie pamieci
   i1 = lista1.begin();
   while (i1 != lista1.end())
   {
       delete (*i1);
          ++i1;
   }
   i2 = lista2.begin();
   while (i2 != lista2.end())
   {
       delete (*i2);
          ++i2;
   }

     cout <<" Koniec nacisnij ENTER" << endl ;
     cin.get();

  return 0;
}

//----------------
//DEFINICJE FUNKCJI GLOBALNYCH

// -----------Ta Funkcja działa dla Obiekt1 i Obiekt2 poprzez polimorfizm

    void SpecFun (Obiekt1 * obiekt)
    {
        obiekt->funkcja();
    }


//-------------------Teraz  OK

 void SpecFunList (ListaObiektow lista) // i ta działa poprez polimorfizm
    {
      ListaObiektow::iterator i;
      Obiekt1 * ob;

      i = lista.begin();
      while(i != lista.end())
      {
               ob = (*i);
         cout << "Dziala Spec Funkcja dla listy z obiektami ->" ;
          ob->funkcja();
          i++;
      }


    }

Czyli całe zamieszanie jest niepotrzebne ,czegoś nie załapałes do DZieX podał
rozwiązanie na początku wątku!.
Myślę jednak ze kod ze wspólną klasą bazową dla Obiekt1 i Obiekt2
jest bardziej przejrzysty i podatny na modyfikacje.
To chyba wszystkie przypadki,zależy co chcesz uzyskac..??
KONIEC KONIEC KONIEC ;]

0

Bardzo dziekuje za przedstawienie roznych mozliwosci.
Pozdrawiam

1 użytkowników online, w tym zalogowanych: 0, gości: 1