我怎么知道指向基类对象的指针数组中元素的类型，它将为派生类分配内存

Question

PC and Printer are derived classes from the base class Item , if I make an array of pointers of type Item , and I wanna allocate memory for the array based on the user's input so it can make the elements in the array either PC s or Printer s or a mix of them.

all the errors are the same:

ERROR: class "Item" has no member "getPC_Counter()" and "getP_Counter()" and "setCapacity()" and "setType()"

Sorry for asking my question in a very weird and complicated manner but i don't really know how to explain my question properly, any ways here's my code and i'll try to explain what i can't figure out in the comments:

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

class Item {
    int ID;
public:
    Item() {
        ID = 0;
    }
    Item(int i) {
        ID = i;
    }
    void print() {
        cout << ID << endl;
    }
    int getID() {
        return ID;
    }
};

class PC :public Item {
    static int PCc;
    string type;
public:
    PC() {
        type = "";
        PCc++;
    }
    void setType(string t) {
        type = t;
    }
    void print() {
        Item::print();
        cout << type << endl;
    }
    string getType() {
        return type;
    }
    int getPC_Counter() {
        return PCc;
    }
};

class Printer: public Item {
    int capacity;
    static int printerc;
public:
    Printer() {
        capacity = 0;
        printerc++;
    }
    void setCapacity(int c) {
        capacity = c;
    }
    void print() {
        Item::print();
        cout << capacity << endl;
    }
    int getCapacity() {
        return capacity;
    }
    int getP_Counter() {
        return printerc;
    }
};

int PC::PCc = 0;
int Printer::printerc = 0;

int main() {
    Item *store[5];
    string c, t;
    int cap;

    cout << "pc or printer?" << endl;
    for (int i = 0; i < 5; i++) {
        cin >> c;
        if (c == "pc") {
            store[i] = new PC();
            cout << "type?" << endl;
            cin >> t;
            //here how do i use the current element as an object of type PC?
            store[i]->setType(t);
        }
        if (c == "printer") {
            store[i] = new Printer();
            cout << "capacity?" << endl;
            cin >> cap;
            //here how do i use the current element as an object of type Printer?
            store[i]->setCapacity(cap);
        }
    }
    //here how do i know if the element is of type printer or pc ? 
    //how do i use the getP_counter() and getPC_Counter funcions properly?
    cout << "number of printers: " << store[0]->getP_Counter() << endl;
    cout << "number of PCs: " << store[0]->getPC_Counter() << endl;
    return 0;
}

Answer 1

You need to use dynamic_cast to cast your base pointer down to the derived pointer you require. For example, in the case of PC :

dynamic_cast<PC*>(store[i])->setType(t);

will work, as this casts Item* (the base) down to a PC* (the derived).

Note, as this is C++, you should really be using std::unique_ptr and std::vector instead of raw-pointers and C-style arrays, respectively. The former will still allow dynamic casting and polymorphism. In other words, use:

std::vector<std::unique_ptr<Item>> store;

instead of

Item* store[5];

Answer 2

I would say the correct way to do this is to make getP_Counter and getPC_Counter static member functions. Then there is no requirement for dynamic dispatch, as those functions only access static data anyway.

...
    // make functions static
    static int getPC_Counter() {
        return PCc;
    }
...

//later call static functions
cout << "number of printers: " << Printer::getP_Counter() << '\n';
cout << "number of PCs: " << PC::getPC_Counter() << '\n';

To deal with setCapacity and setType simply delay erasing the type by initially assigning to the real type and add this to the array after calling those functions.

PC* pc = new PC();
cout << "type?" << '\n';
cin >> t;
//here how do i use the current element as an object of type PC?
pc->setType(t);
store[i] = pc;

Answer 3

A common pattern to solve the issue is known as double dispatching.
It follows a minimal, working example:

struct Visitor;

struct Base {
    virtual void accept(Visitor &) = 0;
};

struct Derived1: Base {
    void accept(Visitor &v) override;
    void f() {}
};

struct Derived2: Base {
    void accept(Visitor &v) override;
    void g() {}
};

struct Visitor {
    void visit(Derived1 d) { d.f(); }
    void visit(Derived2 d) { d.g(); }
};

void Derived1::accept(Visitor &v) { v.visit(*this); }
void Derived2::accept(Visitor &v) { v.visit(*this); }

void func(Base &b) {
    Visitor v;
    b.accept(v);
}

int main() {
    Derived1 d1;
    Derived2 d2;

    func(d1);
    func(d2);
}

The basic idea is that you can use a visitor class that is accepted by all of the classes that belong to your hierarchy.
When a class in the hierarchy accepts a visitor, it promotes itself to the right type and pass a reference to the visitor.

It's heavily based on polymorphism and pretty invasive as a solution, but it doesn't require you to use dynamic_cast or any other technique.

Answer 4

The Question is not clear. Perhaps it is: Why do you get:

"ERROR: class "Item" has no member "getPC_Counter()" and "getP_Counter()" and "setCapacity()" and "setType()"

These errors are self explanatory. You simply have not coded these 4 methods for the base type "Item".

---

If you are headed for polymorphic derived objects, ie using virtual methods, your virtual methods (of base class) should not care which type of derived. The base class becomes an interface definition for the derived classes.

ie Invoking the virtual method print() will invoke the derived type's print().

---

If a printer has methods that a PC does not (or vice versa) there are 2 (or more) approaches to resolve this 'mis-match' between base class (Item) and the derived classes.

I prefer to have base class methods for all possible derived methods. So I would add the four methods to base class (all marked as virtual)

Item::getPC_Counter()
Item::getP_Counter()
Item::setCapacity()
Item::setType()

I also prefer for the base class methods to handle (perhaps an error / warning message) the concept of asking a derived to perform a method that it does not support. This lack of support is caused by 'mixing apples an oranges' in a polymorhpic effort. (I've seen this quite often.)

If setCapacity() is meaningless for derived class Foo,

// virtual
Item::setCapacity(std::string lbl) 
{ std::cerr << " invalid setCapacity() for " << lbl << std::endl; }

and

Foo::setCapacity() { Item::setCapacity("Foo"); }

See how the virtual method in Foo sent info up to the base class method?

And for a derived class Bar, which does have a capacity to set:

Bar::setCapacity() {  /* perform Bar requirements */ }

---

Perhaps a better approach requires more English language ability than is taught in computer class. This approach requires that you create a verb that each derived class can support.

The classic example is perhaps class animal, with derived species. Not all species can bark, but maybe all the ones you wish to consider can vocalize(), or perhaps they speak(), or eat() or, well the other end.

Animal::vocalize() can be virtually supported by dog::vocalize() { bark(); }, cat::vocalize() { meow(); }, where bark and meow are species (or derived class) specific methods.

I can not guess what you would mean by printer::setCapacity(), or pc::setCapacity(). You need to define it. And then come up with a more 'generic' verb that both pc and printer support. And maybe these office equipment objects should not address these issues.

Review your polymorphic tutorials. Plan your objects carefully.

Update your question when you can improve it.

Answer 5

You can statistically or dynamically cast that pointer to know what type he is example :

`auto e = dynamic_pointer_cast<Type>(pointer);`

dynamic cast are expensive thing and you probably want to use static_cast if u know what type is it

auto e = static_pointer_cast<expecting type>(pointer);

example :

auto e = static_pointer_cast<Pc>(pointer);

also if u are using raw pointers you want to use static_cast instead of static_pointer_cast