Question

C++ problem to use dynamic memory allocation (of arrays) and pointer manipulation in order to implement the Inner and Outer classes (Circular Buffer of circular buffers using Queues). No need of any classes from the Standard Template Library (STL), not even vector.

Add the member functions of those classes by following the codes of InnerCB.h and CBofCB.h below:

// file: InnerCB.h
// Header file for Inner Circular Buffer.
// See project description for details.
//

#ifndef _INNERCB_H_
#define _INNERCB_H_

class InnerCB {

public:
   // Constructor, default size is 10.
   InnerCB(int n=10) ;

   // Copy constructor
   InnerCB(const InnerCB& other) ;

   // Destructor
   ~InnerCB() ;

   // Add item to circular buffer
   void enqueue(int data) ;

   // Remove item from circular buffer
   int dequeue() ;

   // True if no space left in buffer
   bool isFull() ; 

   // True if buffer holds no items
   bool isEmpty() ;

   // return maximum number of items this buffer can hold
   int capacity() ;

   // return number of items currently held in the buffer
   int size() ;

   // overloaded assignment operator
   const InnerCB& operator=(const InnerCB& rhs) ;

   // debugging function. Prints out contents.
   void dump() ;

   // grading function used to examine private data members.
   // Do not implement!
   bool inspect (int* &buf, int &cap, int &size, int &start, int &end) ;

private :
   int *m_buffer ;   // pointer to dynamically allocate array for buffer 
   int m_capacity ;  // length of the allocated space pointed by m_buffer
   int m_size ;      // # of items in the buffer
   int m_start ;     // index of the first (oldest) item in the buffer
   int m_end ;       // index of the last (newest) item in the buffer
} ;

#endif

-------------------------------------------------------------------------------------------------------------------------------------------

// file: CBofCB.h
// Header file for Circular Buffer of Circular Buffer.
// See project description for details.
//

#ifndef _CBOFCB_H_
#define _CBOFCB_H_

#include "InnerCB.h" 

class CBofCB {

public:
   // default constructor
   CBofCB() ;

   // copy constructor
   CBofCB(const CBofCB& other) ;

   // destructor
   ~CBofCB() ;

   // add item to this data structure
   void enqueue(int data) ;

   // remove item from this data structure
   int dequeue() ;

   // returns true if cannot add more items
   bool isFull() ; 

   // returns true if no items stored in data structure
   bool isEmpty() ;

   // number of items in the data structure as a whole.
   // Note: not the number of InnerCB's
   int size() ;

   // overloaded assignment operator
   const CBofCB& operator=(const CBofCB& rhs) ;

   // debugging function, prints out contents of data structure
   void dump() ;

   // grading function. Do not implement!
   bool inspect (InnerCB** &buf, int &cap, int &size, int &start, int &end) ;

private :

   // max number of Inner Circular Buffers
   //
   static const int m_obCapacity=7 ;

   // array of pointers to InnerCB's.
   // Each entry of the array is a pointer.
   // Note: array itself is NOT dynamically allocated
   InnerCB * m_buffers[m_obCapacity] ;

   int m_obSize ;  // number of inner circular buffers in the outer CB
   int m_oldest ;  // index of the oldest circular buffer (start)
   int m_newest ;  // index of the newest circular buffer (end)
} ;

#endif

Answer 1

Dynamic Memory Allocation

Dispensing memory

There are two different ways that memory gets dispensed for information stockpiling:

Aggregate Time (or static) Allocation

Memory for named factors is designated by the compiler

Correct size and sort of capacity must be known at aggregate time

For standard exhibit affirmations, this is the reason the size must be steady

Dynamic Memory Allocation

Memory assigned "on the fly" amid run time

progressively assigned space typically set in a program portion known as the stack or the free store

Correct measure of room or number of things does not need to be known by the compiler ahead of time.

For dynamic memory portion, pointers are pivotal

Dynamic Memory Allocation

We can powerfully designate storage room while the program is running, yet we can't make new factor names "on the fly"

Therefore, dynamic allotment requires two stages:

Making the dynamic space.

Putting away its location in a pointer (with the goal that the space can be accesed)

To powerfully distribute memory in C++, we utilize the new administrator.

De-designation:

Deallocation is the "tidy up" of space being utilized for factors or other information stockpiling

Accumulate time factors are consequently deallocated in light of their referred to degree (this is the same as extension for "programmed" factors)

It is the developer's business to deallocate powerfully made space

To de-distribute dynamic memory, we utilize the erase administrator

Assigning space with new

To assign space progressively, utilize the unary administrator new, trailed by the sort being dispensed.

new int;/progressively dispenses an int

new twofold;/progressively dispenses a twofold

On the off chance that making an exhibit powerfully, utilize a similar shape, however put sections with a size after the sort:

new int[40];/progressively assigns a variety of 40 ints

new double[size];/progressively assigns a variety of size copies

/take note of that the size can be a variable

These announcements above are not extremely helpful independent from anyone else, in light of the fact that the apportioned spaces have no names! In any case, the new administrator restores the beginning location of the distributed space, and this location can be put away in a pointer:

int * p;/announce a pointer p

p = new int;/powerfully distribute an int and load address into p

twofold * d;/proclaim a pointer d

d = new twofold;/progressively designate a twofold and load address into d

/we can likewise do these in single line proclamations

int x = 40;

int * list = new int[x];

drift * numbers = new float[x+10];

Notice this is one all the more method for introducing a pointer to a substantial target (and the most essential one).

Getting to powerfully made space

So once the space has been powerfully allotted, how would we utilize it?

For single things, we experience the pointer. Dereference the pointer to achieve the progressively made target:

int * p = new int; //dynamic whole number, indicated by p

*p = 10; //relegates 10 to the dynamic whole number

cout << *p; //prints 10

For powerfully made clusters, you can utilize either pointer-balance documentation, or regard the pointer as the exhibit name and utilize the standard section documentation:

twofold * numList = new double[size]; //dynamic exhibit

for (int I = 0; I < estimate; i++)

numList[i] = 0; //instate exhibit components to 0

numList[5] = 20; //section documentation

*(numList + 7) = 15; //pointer-counterbalance documentation

/implies same as numList[7]

Deallocation of dynamic memory

To deallocate memory that was made with new, we utilize the unary administrator erase. The one operand ought to be a pointer that stores the deliver of the space to be deallocated:

int * ptr = new int; //powerfully made int

/...

erase ptr; //erases the space that ptr focuses to

Note that the pointer ptr still exists in this precedent. That is a named variable subject to extension and degree decided at accumulate time. It tends to be reused:

ptr = new int[10]; //direct p toward a fresh out of the box new cluster

To deallocate a dynamic cluster, utilize this shape:

erase [] name_of_pointer;

Precedent:

int * list = new int[40]; //dynamic cluster

erase [] list; //deallocates the cluster

list = 0; //reset rundown to invalid pointer

In the wake of deallocating space, it's dependably a smart thought to reset the pointer to invalid except if you are pointing it at another legitimate target immediately.