Derived Class Array not Formed

Question

I am facing a problem while creating an array of derived class objects, and I can not find any explanation of this problem. The problem is the following:

I have an abstract base class RDMonitorBase and a derived class RDMonitorHashTable.

In another class RDMonitorPool I have the variable RDMonitorBase * m_rd_monitors.

In RDMonitorPool constructor I am creating an array of RDMonitorHashTable objects (using new) and assigning them to m_rd_monitors.

Immediately after the construction, only the even number indexed RDMonitorHashTable objects are properly formed. The objects with odd numbered index have garbage in the member variables. I have no idea why this is happening.

The code and the GDB output on a breakpoint immediately after the construction are given below:

Relevant parts of the RDMonitorBase and RDMonitorHashTable classes are as follows. I have a virtual Access() method in Base which is not implemented in the derived, and a pure virtual RecordDistance() method. Access() calls the RecordDistance() method. This should be okay I think, a similar structure worked when I created simple examples.

class RDMonitorBase {
 public:
  RDMonitorBase();
  virtual void StartMonitoring(const physical_address_t& target_address, const int core_id);
  virtual Index Access(const physical_address_t& address, const int core_id);
  bool IsActive() { return m_active; }
  static const Index TRACKING_NOT_COMPLETE = -1;

 protected:
  virtual void RecordDistance(const physical_address_t& address) = 0;
  const Index m_maximum_distance;
  bool m_active;
  physical_address_t m_target_address;
  Index m_distance;
  int m_core_id;
};

class RDMonitorHashTable: public RDMonitorBase {
 public:
  RDMonitorHashTable();
  virtual void StartMonitoring(const physical_address_t& target_address,
                           const int core_id);
 protected:
  virtual void RecordDistance(const physical_address_t& address);
  std::tr1::unordered_set<physical_address_t> m_address_set;
};

RDMonitorBase::RDMonitorBase():
  m_maximum_distance(32),
  m_active(false),
  m_target_address(0),
  m_distance(0),
  m_core_id(-1) { ; }

Index RDMonitorBase::Access(const physical_address_t& address,
                        const int core_id) {

  // ... some code
  RecordDistance(address);
  //... some other code 
  return m_distance;
}

RDMonitorHashTable::RDMonitorHashTable()
  :RDMonitorBase() { ; }

void RDMonitorHashTable::RecordDistance(const physical_address_t& address) {
  m_address_set.insert(address);
  m_distance = m_address_set.size();
}

Now in the RDMonitorPool class constructor, the following is basically executed:

RDMonitorBase * m_rd_monitors = new (std::nothrow) RDMonitorHashTable[4096];

After this line executes, when I try to print the objects in gdb, I get this:

(gdb) print *(m_rd_monitors + 0)
$2 = {_vptr.RDMonitorBase = 0x7ffd93cacc90, static TRACKING_NOT_COMPLETE = -1, m_maximum_distance = 32, m_active = false, m_target_address = 0, m_distance = 0, m_core_id = -1}
(gdb) print *(m_rd_monitors + 1)
$3 = {_vptr.RDMonitorBase = 0x1, static TRACKING_NOT_COMPLETE = -1, m_maximum_distance = 68540736, m_active = 11, m_target_address = 0, m_distance = 4611686019492741120, m_core_id = 11}
(gdb) print *(m_rd_monitors + 2)
$4 = {_vptr.RDMonitorBase = 0x7ffd93cacc90, static TRACKING_NOT_COMPLETE = -1, m_maximum_distance = 32, m_active = false, m_target_address = 0, m_distance = 0, m_core_id = -1}
(gdb) print *(m_rd_monitors + 3)
warning: can't find linker symbol for virtual table for `RDMonitorBase' value
$5 = warning: can't find linker symbol for virtual table for `RDMonitorBase' value
{_vptr.RDMonitorBase = 0x7ffda46b3e98, static TRACKING_NOT_COMPLETE = -1, m_maximum_distance = 68566480, m_active = 11, m_target_address = 0, m_distance = 4611686019492741120, m_core_id = 11}

So the even-indexed values have the proper values that are assigned in the constructor (for example 32 for m_maximum_distance). But the odd-index objexxts have garbage in m_maximum_distance and other members.

I will be extremely thankful if anybody can shed some light on why this is happening. Thanks!

I haven't had time to look at this carefully, but I suspect that the problem is that `RDMonitorHashTable` isn't the same size as `RDMonitorBase`, and as a result `*(m_rd_monitors + 1)` doesn't actually point to the second element, but to somewhere in the middle of the first element (i.e. the objects allocated by `new` were the correct size for the derived type, but because the pointer is pointing to the base type, it only adds the size of the base type when adding 1). Not sure why even-indexed values look reasonable - it could be just some quirk of the memory layout. — Ben S., Sep 11 '13 at 01:41
@BenS. that's exactly what happens, but even if the offsets were somehow exactly the same and it insidently worked, relying on this, is not supported and the behavior is undefined. — brunocodutra, Sep 11 '13 at 02:04
Thanks a lot! Both of you guys found the correct reason. Base class pointer arithmetic should not be used for derived class objects. Lesson learnt. Life's good again! — Abhi, Sep 11 '13 at 02:51

score 1 · Accepted Answer · edited May 23 '17 at 10:25

Your problem is addressed here: Base pointer to array of derived objects

The problem is that the array is of type RDMonitorBase, so when you try to access any of its positions, the compiler calculates the offset according to RDMonitorBase instead of RDMonitorHashTable, effectively dereferencing the memory at the wrong point and thus slicing up the actual object which is of a different type. From the point your program access any position of that array, its bahavior becomes undefined.

The most straightforward alternative would be to use an array of pointers to the base type and assign an object of the derived class dynamicaly constructed to each of them.

RDMonitorBase* m_rd_monitors[4096];
for(std::size_t i = 0; i < 4096; ++i)
    m_rd_monitors[i] = new (std::nothrow) RDMonitorHashTable;

Derived Class Array not Formed

1 Answers1