non-scalar type requested

Question

can somebody please help me with an error

conversion from `A' to non-scalar type `B' requested

I have class A and derived from it B, but I have problems with these rows:

A a(1);
A *pb = new B(a);
B b = *pb;    //here I have an error

thanks in advance for any help

class A {
protected:
    int player;
public:
    A(int initPlayer = 0);
    A(const A&);
    A& operator=(const A&);
    virtual ~A(){};
    virtual void foo();
    void foo() const;
    operator int();
};

class B: public A {
public:
    B(int initPlayer): A(initPlayer){};
    ~B(){};
    virtual void foo();
};

edited

I have this code and (I can't change it):

A a(1);
A *pb = new B(a);
B b = *pb;    

I tried to create constructor for B:

B::B(const A & a):
    player(a.player){}

B& B::operator=(const A& a){
    if(this == &a){
        return *this;
    }
    player = a.player;
    return *this;
}

but it gives me an error, really need help from professionals

Answer 1

Your problem is due to static type checking. When you have this line:

A *pb = new B(a);

The static type of pb is A * and it's dynamic type is B *. While the dynamic type is correct, the compiler is checking the static type.

For this simple code, since you know the dynamic type of pb is always a B, you can fix this with a static cast:

B b = *static_cast<B *>(pb); 

But be warned that if the dynamic type of pb was an A * the cast would cause undefined behavior.

Answer 2

In such situations a dynamic cast is most appropriate. Dynamic cast will invoke the runtime type system to figure out the "real" type of bp and will return 0 if it can't be cast to the requested type. As you know the real type you could also use static_cast here but generally this isn't the case in such situations.

 B* b = dynamic_cast<B*>(pb);

Answer 3

When you dereference an 'A' pointer, you get an 'A' even if it points to a 'B'. Polymorphism does not come into play here! To preserve the 'B' properties to the 'A' object you should properly cast the initialization as explained in some of the other answers.

Answer 4

*pb will give you a A& and not a B&. It's just like pb being an A* and not a B* even though the actual object is a B.

B b = *pb will attempt to copy-construct a B using a synthesised copy constructor. The copy constructor will therefore be looking for a B& as its argument. You have no constructor to make a B from an A, hence the error.

As @R Samuel Klatchko says you could just cast it or, in the case you've given, you could just make pb actually be a B*.

Answer 5

You are trying to assign an object of type A to object of type B. Which is not allowed unless you define a type cast operator. pb is a pointer to A object and in general it is not a pointer to B (in your case it is, but it doesn't matter for the compiler, since it's declared as pointer to A). To make such assignement possible, you first need to down-cast pb to pointer of B (as R Samuel Klatchko pointed out, in your case static_cast is perfectly fine; in other cases you might need use dynamic_cast).