#include <iostream>
#include <memory>

class Base1 {
public:
    virtual ~Base1() = default;

    virtual  void fun1() const {
        std::cout << "fun1=" << a << std::endl;
    }

    virtual void fun2() const {
        std::cout << "fun2=" << a << std::endl;
    }

    virtual void fun3() const {
        std::cout << "fun3=" << a << std::endl;
    }

    virtual void fun4() const {
        std::cout << "fun4=" << a << std::endl;
    }
private:
    int a = 0;
};

class V1 : public Base1 {
public:
    void fun1() const override {
        std::cout << "_fun1=" << a << std::endl;
    }
private:
    int a = 1;
};

class V2 : public V1 {
public:
    void fun2() const override {
        std::cout << "__fun2=" << a << std::endl;
    }
private:
    int a = 2;
};

class V3 final : public V2 {
public:
    void fun3() const override {
        std::cout << "___fun2=" << a << std::endl;
    }
private:
    int a = 3;
};

int main() {
    const auto v3 = std::make_unique<V3>();

    v3->fun1();
    v3->fun2();
    v3->fun3();
    v3->fun4();

    return 0;
}

trait Base1Ops {
    // доступ к "Base1::a"
    fn base1_a(&self) -> i32;

    // виртуальные методы (есть дефолт, как в Base1)
    fn fun1(&self) {
        println!("fun1={}", self.base1_a());
    }
    fn fun2(&self) {
        println!("fun2={}", self.base1_a());
    }
    fn fun3(&self) {
        println!("fun3={}", self.base1_a());
    }
    fn fun4(&self) {
        println!("fun4={}", self.base1_a());
    }
}

struct Base1 {
    a: i32,
}

impl Base1 {
    fn new() -> Self {
        Self { a: 0 }
    }
}

impl Base1Ops for Base1 {
    fn base1_a(&self) -> i32 {
        self.a
    }
}

struct V1 {
    base: Base1,
    a: i32, // V1::a
}

impl V1 {
    fn new() -> Self {
        Self {
            base: Base1::new(),
            a: 1,
        }
    }
}

impl Base1Ops for V1 {
    fn base1_a(&self) -> i32 {
        self.base.a
    }

    fn fun1(&self) {
        println!("_fun1={}", self.a);
    }
}

struct V2 {
    v1: V1,
    a: i32, // V2::a
}

impl V2 {
    fn new() -> Self {
        Self { v1: V1::new(), a: 2 }
    }
}

impl Base1Ops for V2 {
    fn base1_a(&self) -> i32 {
        self.v1.base.a
    }

    // наследуем поведение V1::fun1
    fn fun1(&self) {
        self.v1.fun1();
    }

    fn fun2(&self) {
        println!("__fun2={}", self.a);
    }
}

struct V3 {
    v2: V2,
    a: i32, // V3::a
}

impl V3 {
    fn new() -> Self {
        Self { v2: V2::new(), a: 3 }
    }
}

impl Base1Ops for V3 {
    fn base1_a(&self) -> i32 {
        self.v2.v1.base.a
    }

    // наследуем поведение V1::fun1 и V2::fun2
    fn fun1(&self) {
        self.v2.fun1();
    }
    fn fun2(&self) {
        self.v2.fun2();
    }

    fn fun3(&self) {
        // в исходнике строка "___fun2=" (хотя это fun3) — сохраняю как есть
        println!("___fun2={}", self.a);
    }
    // fun4 не переопределяем => будет Base1-версия через дефолт
}

fn main() {
    let v3 = Box::new(V3::new());

    v3.fun1();
    v3.fun2();
    v3.fun3();
    v3.fun4();
}