Há três funções que têm que ser concretizadas de raiz:

• getStringFromMemory(PenWithMemory pen, int idx) - Devolve uma determinada cadeia de caracteres escrita anteriormente;
• resetMemory(PenWithMemory pen) - remove todas as cadeias de caracteres associadas à caneta;
• getCapacityPenWithMemory(PenWithMemory pen) - Devolve a capacidade da caneta com memória;

dado que correspondem a funcionalidades que não existem no conceito mais simples Caneta.

Há quatro funções a que é necessário adicionar novo comportamento face ao suportado por Caneta:

• writePenWithMemory - É necessário guardar a cadeia de caracteres escrita;
• newPenWithMemory - É necessário inicializar a estrutura de memória para guardar as cadeias de caracteres escritas;
• deletePenWithMemory) - Liberta a estrutura de memória que guarda as cadeias de caracteres escritas pela caneta a destruir;
• equalsPenWithMemory – É necessário considerar um novo campo, capacidade, para verificar a igualdade de duas canetas com memória;
  
• printPenWithMemory - É necessário apresentar ao utilizador um novo campo, a capacidade da caneta com memória;

As restantes funções têm exactamente a mesma funcionalidade: getBrandPenWithMemory e getColorPenWithMemory.

Assim, o ficheiro com a concretização deste conceito deverá ter o seguinte conteúdo:

#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include "Pen.h"
#include "PenWithMemory.h"
 
struct pen_with_memory {
  Pen          _pen;
  int          _capacity;
  int          _next; // idx for the next free position
  const char** _memory;
};

 
PenWithMemory newPenWithMemory(const char *brand, const char *color, int capacity) {
  PenWithMemory pen = (PenWithMemory)malloc(sizeof(struct pen_with_memory));

  if (pen != NULL) {
    pen->_pen = newPen(brand, color);
    pen->_capacity = capacity;
    pen->_next = 0;
    pen->_memory = (const char **)malloc(sizeof(char*)*capacity);

    if (pen->_pen == NULL || pen->_memory == NULL) { // error in allocating memory
      deletePenWithMemory(pen);
      pen = NULL;
    }
  }

  return pen;
}
 
void  deletePenWithMemory(PenWithMemory pen) {
  if (pen) {
    deletePen(pen->_pen);

    if (pen->_memory != NULL)
      free(pen->_memory);

    free(pen);
  }
}

void writePenWithMemory(PenWithMemory pen, const char *msg) {
  if (pen->_next < pen->_capacity) {
    pen->_memory[pen->_next++] = msg;
  }
  writePen(pen->_pen, msg);
}

const char *getStringPenWithMemory(PenWithMemory pen, int idx) {
  if (idx >= 0 && idx < pen->_next) {
    return pen->_memory[idx];
  }

  return NULL;
}

void resetMemory(PenWithMemory pen) {
  pen->_next = 0;
}

int getCapacityPenWithMemory(PenWithMemory pen) { return pen->_capacity; }

const char *getBrandPenWithMemory(PenWithMemory pen) { return getBrandPen(pen->_pen); }

const char *getColorPenWithMemory(PenWithMemory pen) { return getColorPen(pen->_pen); }

/* note that we require pen1 and pen2 to be valid pens: any of
   them being NULL pointers will result in a false comparison. */
int equalsPenWithMemory(PenWithMemory pen1, PenWithMemory pen2) {
  return (pen1 != NULL && pen2 != NULL) && equalsPen(pen1->_pen, pen2->_pen) &&
    pen1->_capacity == pen2->_capacity;
}

void printPenWithMemory(PenWithMemory pen) {
  printPen(pen->_pen);
  printf("Capacity:   %d\n", getCapacityPenWithMemory(pen));
}