reference, declarationdefinition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced
    1
    2
    3
    4
    5
    6
    7
    8
    9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20
   21
   22
   23
   24
   25
   26
   27
   28
   29
   30
   31
   32
   33
   34
   35
   36
   37
   38
   39
   40
   41
   42
   43
   44
   45
   46
   47
   48
   49
   50
   51
   52
   53
   54
   55
   56
   57
   58
   59
   60
   61
   62
   63
   64
   65
   66
   67
   68
   69
   70
   71
   72
   73
   74
   75
   76
   77
   78
   79
   80
   81
   82
   83
   84
//===-- main.cpp ------------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <stdio.h>

static int g_next_value = 12345;

class VBase
{
public:
    VBase() : m_value(g_next_value++) {}
    virtual ~VBase() {}
    void Print() 
    {
        printf("%p: %s\n%p: m_value = 0x%8.8x\n", this, __PRETTY_FUNCTION__, &m_value, m_value);
    }
    int m_value;
};

class Derived1 : public virtual VBase
{
public:
    Derived1() {};
    void Print ()
    {
        printf("%p: %s\n", this, __PRETTY_FUNCTION__);
        VBase::Print();
    }

};

class Derived2 : public virtual VBase
{
public:
    Derived2() {};
    
    void Print ()
    {
        printf("%p: %s\n", this, __PRETTY_FUNCTION__);
        VBase::Print();
    }
};

class Joiner1 : public Derived1, public Derived2
{
public:
    Joiner1() : 
        m_joiner1(3456), 
        m_joiner2(6789) {}
    void Print ()
    {
        printf("%p: %s \n%p: m_joiner1 = 0x%8.8x\n%p: m_joiner2 = 0x%8.8x\n",
               this,
               __PRETTY_FUNCTION__,
               &m_joiner1,
               m_joiner1,
               &m_joiner2,
               m_joiner2);
        Derived1::Print();
        Derived2::Print();
    }
    int m_joiner1;
    int m_joiner2;
};

class Joiner2 : public Derived2
{
    int m_stuff[32];
};

int main(int argc, const char * argv[])
{
    Joiner1 j1;
    Joiner2 j2;
    j1.Print();
    j2.Print();
    Derived2 *d = &j1;
    d = &j2;  // breakpoint 1
    return 0; // breakpoint 2
}