Перегрузка метода родительского класса

#include <stdio.h>
#include <iostream>
using namespace std;
 
class Device {
    public:
        int serial_number = 12345678;
 
        void turn_on() {
            cout << "Device is on" << endl;
        }
};
 
class Computer: private Device {
    public:
        void turn_on(int i) {
            cout << "Device #" << i << endl;
        }
        
        void say_hello() {
            turn_on();
            cout << "Welcome to Windows 95!" << endl;
        }
};
 
int main() {
    Device Device_instance;
    Computer Computer_instance;
 
    cout << "\t Device" << endl;
    cout << "Serial number is: "<< Device_instance.serial_number << endl;
    Device_instance.turn_on();
 
    // cout << "Serial number is: " << Computer_instance.serial_number << endl;
    // Computer_instance.turn_on();
    // will cause compile time error
 
    cout << "\t Computer" << endl;
    Computer_instance.say_hello();
    return 0;
}

#include <stdio.h>
class A{
    public:
    inline void write(unsigned char c){
        putc(c,stdout);
    }
};
class B{
    public:
    virtual void write(unsigned char) = 0;
    void print(const char *c){
        while(*c) write(*c++);
    }
    void print(unsigned long n){
      write(n);
    }
};
class C: public A, public B{
    public:
    using A::write;
    void write (const char *c){
        while(*c) write(*c++);
    }
};
C c;
int main()
{
    c.print(105);
    return 0;
}

class X: A
{
   void F() override
   {
   }
};

Device_instance.turn_on();  // вызвать метод того класса, к которому относится Device_instance
Device_instance.Computer::turn_on(); // принудительно вызвать метод класса Computer 
Device_instance.Device::turn_on(); // принудительно вызвать метод класса Device
 
Device *p_Device_instance = &Device_instance; // указатель базового класса
p_Device_instance->turn_on(); // если turn_on() виртуальная, то вызовется именно та её реализация, которая объявлена для класса, к которому относится Device_instance
// если не виртуальная, то вызов аналогичен  Device_instance.Device::turn_on();
p_Device_instance->Device::turn_on();  // независимо от того, является ли turn_on() виртуальной, принудительно вызовется реализация для класса Device

class C: public A, public B{
    public:
    virtual void write(unsigned char c) override { // если б у класса A write() тоже б была виртуальной, фокус бы не прошёл
                                                     // виртуальная функция переопределяется для B 
        A::write(c);                            // вызов принудительно реализации для класса А
    }
    void write (const char *c){
        while(*c) write(*c++);
    }
};

на ошибки железных регистров RXEN0 TXEN0 и тд плиз не обращяйте внимание (это для avr gcc компилятора)
#include <stdio.h>
#include <stdint.h>
class LLPrint {
 
  public:
    virtual inline void write(unsigned char) =0;
 
    inline void print(char c) {
      write(c);
    }
 
    inline void print(const char *s) {
      while (*s) write(*s++);
    }
 
};
class LLStream : public LLPrint {
 
  public:
    virtual inline unsigned char count() const { }
    virtual inline void write(unsigned char) { }
 
    inline bool available() const {
      return count();
    }
 
    inline void write(const char *s) {
      while (*s) write(*s++);
    }
 
};
#include <assert.h>
class UUART : public LLStream {
  private:
    typedef uint8_t T;
    static const T rx_buffer_size = 16;
    static const T rx_mask = rx_buffer_size - 1;
    T rx_buffer[rx_buffer_size] = {0};
    volatile T rx_head = 0;
    volatile T rx_tail = 0;
    static_assert((rx_buffer_size & rx_mask) == 0, "buffer size must be a power of 2");
    static_assert(rx_buffer_size <= 256, "buffer size must be less than 256");
    const T rxen, txen, rxcie, txcie, udrie;
 
  public:
    UUART(int rxen_= 1, int txen_= 1, int rxcie_= 1, int txcie_= 0, int udrie_= 0)
    : rxen(rxen_), txen(txen_), rxcie(rxcie_), txcie(txcie_), udrie(udrie_)
    {
      assert(rxen_ == 0 || rxen_ == 1);
      assert(txen_ == 0 || txen_ == 1);
      assert(rxcie_== 0 || rxcie_== 1);
      assert(txcie_== 0 || txcie_== 1);
      assert(udrie_== 0 || udrie_== 1);
    }
    inline void begin(const uint32_t ubrr = 9600, const uint8_t format = 6, const bool u2x = 1) {
      // Enable receiver, transmitter, interrupt
      UCSR0B = (rxen << RXEN0) | (txen << TXEN0) | (rxcie << RXCIE0) | (txcie << TXCIE0) | (udrie << UDRIE0);
    }
 
    inline bool irq() {
        rx_buffer[rx_head++ & rx_mask] = UDR0;
        return true;
    }
 
    using LLStream::write; // pull in write(const char *);
    inline void write(uint32_t c){ write((T)c); }
    inline void write(uint16_t c){ write((T)c); }
    inline void write(int32_t c) { write((T)c); }
    inline void write(int16_t c) { write((T)c); }
    inline void write(T c) {
      UDR0 = c;
    }
 
    inline T read() {
      return rx_buffer[rx_tail++ & rx_mask];
    }
 
    inline T peek() {
      return rx_buffer[rx_tail & rx_mask];
    }
 
    inline T count() const {
      return (uint8_t)(rx_head - rx_tail);
    }
 
};
UUART sserial;
 
int main()
{
    sserial.print('c');
    return 0;
}

class LLStream : public LLPrint
{
  public:
    void write(unsigned char)override { }

    inline void print(unsigned long n, int base = DEC) {
      if (base == 0) write(n);
      ...
      }

CVector CVector::operator+ (const CVector& param) {
  CVector temp;
  temp.x = x + param.x;
  temp.y = y + param.y;
  return temp;
}

CVector CVector::operator+ (const CVector& param) {
  CVector temp;
  temp.x = this->x + param.x;
  temp.y = this->y + param.y;
  return temp;
}

#include <stdio.h>
 
class P {
    public:
    virtual void write(unsigned char) = 0;
    inline void print(const char *c) { while (*c) write (*c++); }
    template <class T>
    P& operator<< (const T& i)
    { return print(i); }
};
class W : public P {
    public:
    virtual void write(unsigned char) { }
    inline void write(const char *c) { while (*c) write (*c++); }
};
class S : public W {
    public:
    inline void write(unsigned char  c) { putchar(c); }
    using W::write;
};
S s;
 
#include <stdio.h>
 
int main()
{
    s << "Hello World" << "!";
 
    return 0;
}

    template <class T>
    P& operator<< (const T& i)
    { print(i); return *this; }