5

Im was reading an example of simple inheritence and came across the basic idea that a square is a base type and a rectangle is derived from a square.

The example for setting the square dimensions used a property called Size. The example for the rectangle then went on to use Width and Height.

This didnt make sense in my head, so I coded it.

The problem seems to be that when accessing rectangle, there will always be a confusing property called 'Size' present.

Have I got this right? Or is there a way to hide other classes from seeing Size when looking at rectangle?

public class square
{
    public int Size { get; set; }
    public square(int size)
    {
        this.Size = size;
    }
}

public class rectangle : square
{
    public int Width { get { return base.Size; } set { base.Size = value; } }

    public int Height { get; set; }

    public rectangle(int width, int height)
        : base(width)
    {
        Height = height;
    }
}
Improve this question
7
  • 7
    It should be the other way around: square should derive from a rectangle. A square also has a width and a height, they just happen to be equal for the square. A rectangle may, of course, have different values. Commented Feb 16, 2012 at 22:41
  • 1
    Not the first poor example of inheritance you'll come across in your study, or your career for that matter. Congratulations on spotting it, google code smell sometime... Commented Feb 16, 2012 at 22:51
  • @Tod Item 35 is "Consider alternatives to virtual functions." My answer does not contain a single virtual function (in fact, unless you derive another class from either Square or Rectangle you can't mutate an object of either type), so care to comment on how that makes my answer "dead wrong?" Commented Feb 16, 2012 at 22:58
  • Do yourself a favor and go out RIGHT NOW and buy a copy of Scott Meyer's Effective C++ 3rd edition. In my copy (2nd edition) this is explained in great depth in Item 35. You'll find the other 54 items in the book equally valuable. Commented Feb 16, 2012 at 22:59
  • @Tod Thanks. Im concerned it would be wasted on me as my focus is predominantly c sharp Commented Feb 16, 2012 at 23:06

8 Answers 8

Reset to default
13

You are 100% right that this is backwards inheritance. Instead, you should have a Square class inherit from a Rectangle class, since a square is a special kind of rectangle.

Then, you get something like

public class Rectangle
{
    public int Width { get; private set; }
    public int Height { get; private set; }

    public Rectangle(int width, int height)
    {
        if (width <= 0 || height <= 0)
            throw new ArgumentOutOfRangeException();
        Width = width;
        Height = height;
    }
}

public class Square : Rectangle
{
    public int Size
    {
        get
        {
            return Width;
        }
    }

    public Square(int size)
        : base(size, size)
    {
    }
}
Improve this answer
Sign up to request clarification or add additional context in comments.

4 Comments

Having Square subclass Rectangle is not necessarily a good idea, either - while all Squares are Rectangles, designing your inheritance hierarchy this way is a quick way to violate the Liskov Substitution Principle...
@ReedCopsey It's perfectly legitimate to have Square subclass Rectangle if you are minimizing mutability, as I do in the posted code.
True - I wrote this before your edit. However, if you allow mutation of the types (such as the OP's example classes), then it is dangerous.
@ReedCopsey I agree completely.
8

The problem is that a rectangle is not a square - You also cannot even say that a Square is a Rectangle because this causes a lot of problems too since a Rectangle (usually) offers methods to independently set width and height - this would be constrained by a Square - this is a classic violation of the Liskov substition principle. - to quote from Wikipedia:

A typical example that violates LSP is a Square class that derives from a Rectangle class, assuming getter and setter methods exist for both width and height. The Square class always assumes that the width is equal with the height. If a Square object is used in a context where a Rectangle is expected, unexpected behavior may occur because the dimensions of a Square cannot (or rather should not) be modified independently. This problem cannot be easily fixed: if we can modify the setter methods in the Square class so that they preserve the Square invariant (i.e., keep the dimensions equal), then these methods will weaken (violate) the postconditions for the Rectangle setters, which state that dimensions can be modified independently. Violations of LSP, like this one, may or may not be a problem in practice, depending on the postconditions or invariants that are actually expected by the code that uses classes violating LSP. Mutability is a key issue here. If Square and Rectangle had only getter methods (i.e., they were immutable objects), then no violation of LSP could occur.

Improve this answer

Comments

3

came across the basic idea that a square is a base type and a rectangle is derived from a square.

The problem is that this is false -

A square is a specific type of rectangle, but a rectangle is not a square.

That being said, making square inherit rectangle is also dangerous, as you end up with a situation which is unexpected. This is a common violation of the Liskov Substitution Principle, which is why it's often better to have both Square and Rectangle implement a common base class, such as Shape, which would only contain properties shared by both classes, such as things like Area or Bounds, etc.

Improve this answer

Comments

2

I think that the problem is a geometrical one :-)

A rectangle IS NOT a square. A square IS a rectangle.

You should invert the inheritance and you will discover that rectangle just have Width and Height and square has an additional property called Size.

Bye, Marco

Improve this answer

Comments

0

A square is always a rectangle, but a rectangle is not always a square - hence Rectangle should be the parent of Square and not the other way around.

Improve this answer

Comments

0

Geometry 101: A square is a rectangle, but a rectangle is not a square.

Improve this answer

Comments

0

Square and Rectangle are a classic example of a violation of the Liskov substitution principle. In this principle, neither are directly related to each other, but could be related to a Shape, for example.

For example:

public class Rectangle
{
     public int width {get;set;}
     public int height {get;set;}
     public int Area() { return width * height; }
}

public class Square : Rectangle
{
    public override int width
    {
        get { return base.width; }
        set { base.height = value; base.width = value; }
    }

    //... etc ...
}

[Test]
public void Rectangles_area_should_equal_length_times_width()
{
    Rectangle r = new Square();
    r.height = 10;
    r.width  = 15;

    Assert.That(r.Area() == 150); // Fails
}

Do you see the problem? When referencing the square from its base class, the behavior changes in an unexpected way. The correct solution is for Square and Rectangle to be siblings, (children of Shape), not parent/child.

Improve this answer

Comments

0

Referring to your question about hiding inherited members, you can use the new modifier:

public class Rectangle : Square {
     private new int Size { get; set; }
     ...
}
Improve this answer

Comments

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.