Is this code from chapter 4 vol 1 of Thinking in C++ 2nd Ed correct?

[pauldepstein]

The following code is suspect to me, but I didn't see any online
errata correcting it. I pasted it from the web:
The array b is dynamically allocated but never seems to be deleted.
On the other hand s->storage is deleted, but never dynamically
allocated.

Paul Epstein

//: C04:CLib.cpp {O}
// Implementation of example C-like library
// Declare structure and functions:
#include "CLib.h"
#include <iostream>
#include <cassert>
using namespace std;
// Quantity of elements to add
// when increasing storage:
const int increment = 100;

void initialize(CStash* s, int sz) {
s->size = sz;
s->quantity = 0;
s->storage = 0;
s->next = 0;
}

int add(CStash* s, const void* element) {
if(s->next >= s->quantity) //Enough space left?
inflate(s, increment);
// Copy element into storage,
// starting at next empty space:
int startBytes = s->next * s->size;
unsigned char* e = (unsigned char*)element;
for(int i = 0; i < s->size; i++)
s->storage[startBytes + i] = e;
s->next++;
return(s->next - 1); // Index number
}

void* fetch(CStash* s, int index) {
// Check index boundaries:
assert(0 <= index);
if(index >= s->next)
return 0; // To indicate the end
// Produce pointer to desired element:
return &(s->storage[index * s->size]);
}

int count(CStash* s) {
return s->next; // Elements in CStash
}

void inflate(CStash* s, int increase) {
assert(increase > 0);
int newQuantity = s->quantity + increase;
int newBytes = newQuantity * s->size;
int oldBytes = s->quantity * s->size;
unsigned char* b = new unsigned char[newBytes];
for(int i = 0; i < oldBytes; i++)
b = s->storage; // Copy old to new
delete [](s->storage); // Old storage
s->storage = b; // Point to new memory
s->quantity = newQuantity;
}

void cleanup(CStash* s) {
if(s->storage != 0) {
cout << "freeing storage" << endl;
delete []s->storage;
}
} ///:~

 

[red floyd]

The following code is suspect to me, but I didn't see any online
errata correcting it. I pasted it from the web:
The array b is dynamically allocated but never seems to be deleted.
On the other hand s->storage is deleted, but never dynamically
allocated.

Paul Epstein'
> [redacted]

void inflate(CStash* s, int increase) {
assert(increase > 0);
int newQuantity = s->quantity + increase;
int newBytes = newQuantity * s->size;
int oldBytes = s->quantity * s->size;
unsigned char* b = new unsigned char[newBytes];
for(int i = 0; i < oldBytes; i++)
b = s->storage; // Copy old to new
delete [](s->storage); // Old storage
s->storage = b; // Point to new memory

the memory newed by b is now owned by s->storage

s->quantity = newQuantity;
}

void cleanup(CStash* s) {
if(s->storage != 0) {
cout << "freeing storage" << endl;
delete []s->storage;

delete[]s the memory allocated in inflate.

 

[forums_mp]

The following code is suspect to me, but I didn't see any online
errata correcting it.  I pasted it from the web:
The array b is dynamically allocated but never seems to be deleted.
On the other hand s->storage is deleted, but never dynamically
allocated.
[snip]
    void inflate(CStash* s, int increase) {
      assert(increase > 0);
      int newQuantity = s->quantity + increase;
      int newBytes = newQuantity * s->size;
      int oldBytes = s->quantity * s->size;
      unsigned char* b = new unsigned char[newBytes];
      for(int i = 0; i < oldBytes; i++)
        b = s->storage; // Copy old to new
      delete [](s->storage); // Old storage
      s->storage = b; // Point to new memory
      s->quantity = newQuantity;
    }

    void cleanup(CStash* s) {
      if(s->storage != 0) {
       cout << "freeing storage" << endl;
       delete []s->storage;
      }
    } ///:~

Pay close attention to the comments in the inflate method,
specifically the comment '// Point to new memory' . Desctruction
occurs through s.