在派生类上调用虚拟函数时遇到分段错误

Question

I'm getting segmentation fault for this short code and I'm not able to figure out why.

class XorY {
public:
    virtual void set_cost(double& cost){}

};
class X_based:public XorY {
public:
    X_based(int _x):x(_x){}
    void set_cost(double& cost)
    {
        cost=cost*(100-x)/100;
    }
    int x;
};
class Y_based:public XorY
{       
    public:
        Y_based(){}
        Y_based(int _y): y(_y){}
        void set_cost(double& cost){
            cost=cost-y;
        }
        int y;
};


int main(){
    double a=2;
    XorY* type;
    Y_based* ptr;
    *ptr=Y_based(3);
    type=ptr;
    type->set_cost(a);
}

It seems that there's an error with this line

*ptr=Y_based(3);

When I change it to

ptr=&Y_based(3);

I get this compile error:

taking address of temporary [-fpermissive]

Thanks in advance.

Answer 1

You're right, the line

*ptr=Y_based(3);

is incorrect. I suppose, you meant that the ptr pointer should point to the new object of type Y_based after this operation.

Hovewer, the meaning of this line is different.

First, the right part ( Y_based(3) ) is calculated. It's an object of type Y_based with _y field equal to 3 . After that, the left part ( *ptr ) is calculated. It's the object which is pointed by ptr pointer and it's undefined since the pointer was not initialized. If the pointer was initialized, after that the value of the right part would be assigned to the value of the left part. That is, the object pointed by ptr would change, not the pointer itself.

Your desirable behavior can be achieved by writing

ptr = new Y_based(3);

Here the left part, which is assigned to, it not the object pointed by ptr , but ptr itself, and the right part is a pointer to a newly created object of type Y_based .

Also, since the object of type Y_based was created by the new keyword, it will not be destroyed after you leave the block, and you should take care of it manually, using delete at a line where you don't need the object anymore. To correctly destroy an object by the pointer to the base class, you should also define a virtual destructor in the base class:

class XorY {
public:
    virtual void set_cost(double& cost){}
    virtual ~XorY() = default;
};

If you don't want to bother with all this stuff, but still need to have a polymorphic behavior, you can use a reference instead of a pointer:

int main(){
    double a=2;
    Y_based& ptr = Y_based(3);
    XorY& type = ptr;
    type.set_cost(a);
}