why cant I make square take one perimeter whilst rectangle takes two?

[AL88]

My book is asking me to make the rectangle class constructor just take length whilst making rectangle take width and lenght , how do i get it to compile?

#include<iostream>

class Shape
{
public:
Shape(){}
~Shape(){}
protected:
};

class Rectangle : public Shape
{
public:
virtual Rectangle(int length, int width){}
virtual ~Rectangle(){}
protected:
int length, width;
};

class Square : public Rectangle
{
public:
virtual Square(int length){}
virtual Square(const Square &){}
virtual ~Square(){}
int getLength(){return length;}
protected:
int length;
};

int main()
{
Square Object(5);
std::cout << "The length is << " <<Object.getLength()<<std::endl;
}
~                                                                                                                                           
~                                                                                                                                           
~                                                                                                                                           
~                                                                                                                                           
~                                                                                                                                           
"q2ch11.cpp" 35L, 501C                                                                                                    23,26         All

[Repeater]

Square's constructor calls Rectangle's constructor. If you don't tell Square's constructor which of Rectangle's constructors to call, it tries to call the default constructor (which doesn't exist).

#include<iostream>

class Shape
{
public:
Shape(){}
virtual ~Shape(){}
};

class Rectangle : public Shape
{
public:
 Rectangle(int inputlength, int inputwidth) : length(inputlength), width(inputwidth){}
 ~Rectangle(){}
protected:
int length, width;
};

class Square : public Rectangle
{
public:
 Square(int length) : Rectangle(length, length){}  // Calls  Rectangle(int inputlength, int inputwidth)
 Square(const Square & other) : Rectangle(other.length, other.length) {}  // Calls  Rectangle(int inputlength, int inputwidth)
 ~Square(){}
int getLength(){return length;}
};

int main()
{
Square Object(5);
std::cout << "The length is << " <<Object.getLength()<<std::endl;
}

[Peter87]

Constructors cannot be virtual. Destructors can be virtual and probably should be in this case.

[tpb]

The "virtual" mechanism doesn't come into effect unless you use pointers or references to the base class(es).

class Shape {
public:
    virtual ~Shape() = default;
    virtual int area() = 0;
};

class Rect : public Shape {
    int length, width;
public:
    Rect(int length, int width) : length(length), width(width) {}
    int area() { return length * width; }
};

class Square : public Rect {
public:
    Square(int side) : Rect(side, side) {}
};

#include <iostream>

int main() {
    Shape *sh = new Square(10);
    std::cout << sh->area() << '\n';
    delete sh;
}