C ++ memórialefoglalás a listán az absztrakt osztály tárgyak

szavazat
0

Saját megértése C ++ tömbök, hogy nem lehet kiosztani egy sor absztrakt osztály tárgyak, mivel a C ++ nem tudja, hogyan kell a memóriát a még-to-be-döntött osztály típusát.

Én raktam össze egy kis példa, hogy összezavart egy kicsit, így akartam kérdezni egy kicsit

#include <iostream>

class Animal {
public:
  virtual void hello() {}
};

class Dog : public Animal {
public:
  void hello() { std::cout << woof! << std::endl; }
};

class Cat : public Animal {
public:
  void hello() { std::cout << meow << std::endl; }
};

int main() {
  Dog d;
  d.hello(); // prints woof!

  Cat c;
  c.hello(); // prints meow

  // how are we allowed to create an array of abstract class?
  // doesn't c++ need to know how to allocate memory for any abstract
  // class in order to do this?
  Animal creatures[5];
  creatures[0] = d;
  creatures[1] = c;
  creatures[4] = d;

  // prints 6Animal
  std::cout << typeid(creatures[0]).name() << std::endl;

  // this appears to call the Animal hello(), which does nothing
  creatures[1].hello();
}

Kérdések

  1. Hogyan C ++ képes memóriát kiosztani ezt a tömböt? Miért nem panaszkodnak?
  2. Úgy tűnik, valami ebben nem hibás köszönhető kezelésére valamennyi tárgy, mint az állatok, azaz nem megfelelően tesz polimorfizmus. Pontosan mi folyik itt, és miért? Ne csak meg kell kiosztani listáját mutató, hogy ezt megfelelően helyette?

Kösz!

A kérdést 19/03/2020 21:55
a forrás felhasználó
Más nyelveken...                            


1 válasz

szavazat
2

Animalnem elvont. Nem tartalmaz tiszta virtuális tagfüggvény. Ha hozzá cés daz elemei creaturesakkor szeletelés őket.

Ha ehelyett Animal::hellonyilvánították tiszta virtuális, azaz

class Animal {
public:
  virtual void hello() = 0;
};

Animal creatures[5]azt nem összeállításához , mivel Animalmost elvont.


Mint egy a második kérdés, futásidejű polimorfizmus C ++ csak akkor működik, referenciák és mutatókat. Ha még nem ismeri, nyelvek, mint a Java vagy Python ez úgy tűnik, egy kicsit furcsa elsőre, de ne feledje, hogy az ezeken a nyelveken összes változó osztály típusú mutató pointer (vagy pointer-szerű dolog, egyébként).

A C ++, Animal creatures[5]akkor lefektetett memória, valahogy így:

creatures
+--------+--------+--------+--------+--------+
| Animal | Animal | Animal | Animal | Animal |
+--------+--------+--------+--------+--------+

A Java, Animal[] creatures = new Animal[5];akkor lefektetett memória, mint ez:

+-----------+   +---+---+---+---+---+
| creatures +-->+ 0 | 1 | 2 | 3 | 4 |
+-----------+   +-+-+-+-+-+-+-+-+-+-+
                  |   |   |   |   |
       +--------+ |   |   |   |   | +--------+
       | Object +<+   |   |   |   +>+ Object |
       +--------+     |   |   |     +--------+
                      v   |   v
               +------+-+ |  ++-------+
               | Object | |  | Object |
               +--------+ |  +--------+
                          v
                     +----+---+
                     | Object |
                     +--------+

Nincs közvetlen analóg C ++ nyelven tömbök, mint a Java vagy Python

Ez azt jelenti, hogy minden tárgy egy C ++ tömbnek kell lennie pontosan ugyanolyan típusú. Ha azt szeretnénk, hogy létrejöjjön valami, mint a Java tömb, akkor kell használni mutatók. Akkor érdemes használni a standard smart pointer osztály std::unique_ptrés std::shared_ptr. azaz

std::shared_ptr<Animal> creatures[5];
creatures[0] = std::make_shared<Dog>();
creatures[1] = std::make_shared<Cat>();

creatrues[0]->hello(); // prints "woof!"
creatures[1]->hello(); // prints "meow"
Válaszolt 19/03/2020 22:00
a forrás felhasználó

Cookies help us deliver our services. By using our services, you agree to our use of cookies. Learn more