Embedding vs. Inheritance in Go

Question

I'm trying to learn Go, but I keep bashing my head against some of its concepts that apply differently compared to other languages.

Suppose I have a struct

type Vehicle struct {
    Seats int
}

I now want another struct, which embeds Vehicle:

type Car struct {
    Vehicle
    Color string
}

As I understand it, the Car struct now embeds Vehicle.

Now I want to have a function that takes any vehicle

func getSeats(v Vehicle){
    return v.Seats
}

But whenever I try to pass a Car:

    getSeats(myCar)

I get the following error:
cannot use myCar (value of type Car) as Vehicle value in argument to getSeats
But my IDE tells me myCar has a Seats property!

From this I understand that embedding is not the same as inheriting.

My question is; Is there an equivalent to struct inheritance like c++, where a function can take a base struct, or is this something Go handles completely different? How would I implement something like this in the "Go way"?

There is no such thing as inheritance in Go. "I want to have a function that takes any vehicle." This is where your mental model goes wrong. There is only one type of Vehicle, because Vehicle is a concrete type, not an interface. Either call getSeats(myCar.Vehicle), or make Vehicle an interface if you want polymorphism. — Peter
– Peter, Commented Jan 15, 2022 at 12:12
Now I want to have a function that takes any vehicle Do you really need to to begin with. The example is contrived and I find it hard to perceive the need here. — user4466350
– user4466350, Commented Jan 15, 2022 at 13:08
Go is unique. The sooner you discard the notion that it acts like other programming languages you know, the faster you'll be able to wrap your head around it. Take some time understanding the answers here, which have some great gems of knowledge. — erik258
– erik258, Commented Jan 15, 2022 at 20:03

Dylan Reimerink · Accepted Answer · 2022-01-15 11:53:58Z

Like you mentioned, Go has no inheritance in the typical sense. Embedding is really just syntactic sugar.

When embedding, you add a field to you struct with the exact same name as the type you are embedding. Any methods of the embedded struct can be called on the struct which embeds them, this does nothing more than forwarding them.

One tick is that, if the struct which embeds another already declares a method, it will be preferred over forwarding it, which allows you to sort of overwrite functions if you want to think of it like that.

As you have noticed, we can't use Car as a Vehicle even if Car embeds Vehicle since they are strictly not the same type. But any struct which embeds Vehicle will have all methods which were defined by Vehicle, thus if we define an interface which Vehicle implements, all types that embed Vehicle should also implement that interface.

For example:

package main

import (
    "fmt"
)

type Seater interface {
    Seats() int
}

type Vehicle struct {
    seats int
}

func (v *Vehicle) Seats() int {
    return v.seats
}

type Car struct {
    Vehicle
    Color string
}

type Bike struct {
    Vehicle
    Flag bool
}

// A bike always has 1 seat
func (b *Bike) Seats() int {
    return 1
}

type Motorcycle struct {
    Vehicle
    Sidecar bool
}

// A motorcycle has the base amounts of seats, +1 if it has a side car
func (m *Motorcycle) Seats() int {
    return m.Vehicle.seats + 1
}

func getSeats(v Seater) int {
    return v.Seats()
}

func main() {
    fmt.Println(getSeats(&Bike{
        Vehicle: Vehicle{
            seats: 2, // Set to 2 in the Vehicle
        },
        Flag: true,
    }))

    fmt.Println(getSeats(&Motorcycle{
        Vehicle: Vehicle{
            seats: 1,
        },
        Sidecar: true,
    }))

    fmt.Println(getSeats(&Car{
        Vehicle: Vehicle{
            seats: 4,
        },
        Color: "blue",
    }))
}

This prints:

1
2
4

In the case of Bike the Bike.Seats method is called which is why it returns 1 even when the seats value of its Vehicle is 2.

In the case of Motorcycle the Motorcycle.Seats method is also called, but here we can access the embedded type and still use it to get a result.

In the case of Car, the Vehicle.Seats method is called since Car doesn't "overwrite" Seats.

Jakub Dóka · Accepted Answer · 2022-01-15 12:59:12Z

This is something I cared about when I started with Go. I thought using concepts from OOP languages like Java is natural way of doing things. Well its not, Go is not object oriented and it does not implement polymorphism trough inheritance. In the end, composition that Go supports takes good things from what inheritance offers and removes things that adds more overhead then effective help. Go's answer to polymorphism are interfaces. Go tries to be simple and you can usually achieve things only one obvious way. Lets say you have a Java classes like these:

class Base {
    private int attribute;

    public int getAttribute() {
        return this.attribute;
    }
}

class Something extends Base {}

In java every object is on the heap and you have pointer to it. It can be null and it also means it has same size when you pass it around. This is one of the reasons why you can pass objects more freely (Whether you pass Base or Something, as long as argument type is super class, it will compile). Go is designed to manage memory more efficiently and use stack more then heap, and even heap is less fragmented. When you declare a struct, the size of that struct is determined by data it holds, so you cannot pass it to places where embedded structure belongs. Let's give an example:

type Base struct {
   attribute int32 
}

func (b *Base) Attribute() int32 {
    return b.attribute
}

type Something struct {
    garbage int32
    Base
}

While Base has 4 bytes, Something has 8, and attribute has different offset. If the compiler lets you pass Something in place of Base, you would access garbage instead of attribute. If you want to get this behavior you have to use interface. Luckily, all you have to declare is this:

type BaseInterface interface {
    Attribute() int32
}

Now that you have this interface, you can make general functions over all structs that embed Base (unless it also embeds something else that has method names Attribute on the same level) like this:

func DoubleOfBaseAttribute(base BaseInterface) int32 {
    return base.Attribute() * 2
}

This is also called Dynamic Dispatch and its what languages like C++ or Java use implicitly.

Hosein Rahnama · Accepted Answer · 2024-05-10 18:31:48Z

In GO, you do inheritance by composition and polymorphism by interfaces. The following example is an effort to clarify this. Notice the following.

For mimicking inheritance by composition, you only need to mention the inherited type without any field name in the derived type.
All shapes that have implemented the interface ShapeDescriber can be assigned to s, which allows polymorphism or dynamic dispatch.
The Type Circle did not implement the interface directly and the compiler called the associated describe method of Shape in this case.

package main

import (
    "fmt"
)

// describe is a common behavior that Shape and its sub-classes
// Circle, Rectangle and Square have.
type ShapeDescriber interface {
    describe() string
}

// Shape can be considered as a base class.
type Shape struct {
    name string
}

func (s *Shape) describe() string {
    return s.name
}

// Circle can be considered as a derived class of Shape.
type Circle struct {
    Shape
    radius float32
}

// Rectangle can be considered as a derived class of Shape.
type Rectangle struct {
    Shape
    height float32
    width  float32
}

func (r *Rectangle) describe() string {
    return fmt.Sprintf("%s, height: %.2f, width: %.2f", r.Shape.name, r.height, r.width)
}

// Square can be considered as a derived class of Rectangle.
type Square struct {
    Rectangle
    side float32
}

func (q *Square) describe() string {
    return fmt.Sprintf("%s, side: %.2f", q.Shape.name, q.Rectangle.height)
}

func main() {
    var s ShapeDescriber

    s = &Circle{
        Shape:  Shape{"Circle"},
        radius: 1.0,
    }
    fmt.Println(s.describe())

    s = &Rectangle{
        Shape:  Shape{"Rectangle"},
        height: 1.0,
        width:  2.0,
    }
    fmt.Println(s.describe())

    s = &Square{
        Rectangle: Rectangle{Shape{"Square"}, 1.0, 1.0},
        side:      1.0,
    }
    fmt.Println(s.describe())
}

Collectives™ on Stack Overflow

Embedding vs. Inheritance in Go

3 Answers 3

Comments

Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

3 Answers 3

Comments

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related