How to realize Virtual Inheritance in Go

1. How to realize "Virtual Inheritance" in Go?

2. go lang compiler version: "1.3.1 windows/amd64", does it support "Virtual Inheritance" for Go?

I never heard a C like language could support "Virtual", so I really misunderstand.

Virtual Inheritance solves a problem which does not exist if you don't have multiple inheritance. Consider the following inheritance tree:

  A
 / \
B   C
 \ /
  D

If classes B and C both provide a data-member (or method for that matter) with the same name then when accessing said member in D, you need a way to disambiguate whose ancestor's data-member (or method) you wish to access.

Virtual Inheritance is C++'s solution.

In Go you don't have inheritance to begin with; only composition and you can embed at most 1 member of any given type at once.

http://play.golang.org/p/1iYzdoFqIC

package main

type B struct {
}

func (b B) Foo() {}

type C struct {
}

func (c C) Foo() {}

type D struct {
	B
	C
}

func main() {
	d := D{B{}, C{}}
	// d.Foo() // <- ambiguous
	d.B.Foo()  // <- ok
    d.C.Foo()  // <- ok
}

Virtual Inheritance not only solves the problem of multiple inheritance but also gives us polymorphism.

package main

import (
	"fmt"
	"math"
)

type Form interface {
	Color() string
	Area() float64
}

type form struct {
	color string
}

func (f *form) Color() string {
	return f.color
}

type Circle struct {
	form
	radius float64
}

func (k *Circle) Area() float64 {
	return math.Pi * k.radius * k.radius
}

type Rectangle struct {
	form
	width, height float64
}

func (r *Rectangle) Area() float64 {
	return r.width * r.height
}

func main() {
	var forms [2]Form
	forms[0] = &Circle{
		form:   form{ "black" },
		radius: 5.0,
	}
	forms[1] = &Rectangle{
		form:   form{ "read" },
		width:  2.0,
		height: 3.0,
	}
	for _, f := range forms {
		fmt.Printf("%s: %.2f\n", f.Color(), f.Area())
	}
}

Here we have an array of things that have something in common (Color and Area) and we can just iterate over this array calling the same functions and always the right thing will happen.

This is just one advantage of polymorphism. It plays a big role in most design patterns.

"Virtual Inheritance" is something more like this

http://play.golang.org/p/8RvPmB3Pof

package main

type A struct {
    virtual int
}

func (a *A) set(v int) {
     a.virtual = v
}

func (a *A) get() int {
    return a.virtual
}

type B struct {
    *A
}

type C struct {
    *A
}

type D struct {
    *B
    *C
}

func main() {
    a := &A{}
    b := &B{a}
    c := &C{a}
    d := &D{b, c}
    d.B.set(3)
    println(d.C.get())
    return
}