Esempio di programmazione ad oggetti realizzata con il linguaggio C.

Si crea un buffer di dimensione variabile a cui è possibile aggiungere elementi. Una volta raggiunta la capacità viene automaticamente allargato.

Codice:

#include <stdlib.h>
#include <stdio.h>

typedef struct buffer{
        float * vett;
        int size;
        int capacity;
} * Buffer;

/*
  Crea un buffer a dimensione variabile con capacità iniziale passata.
  Ricordarsi di chiamare destroyBuffer quando non serve più.
  Input: int initialCapacity: dimensione iniziale del buffer
  Output: (puntatore al) buffer
*/
Buffer initBuffer(int initialCapacity){
       Buffer b;
       float * v;
       v = (float *)malloc(sizeof(float) * initialCapacity);
       b = (struct buffer *)malloc(sizeof (struct buffer));
       b->size=0;
       b->vett=v;
       b->capacity=initialCapacity;
       return b;
}

/*
  Restituisce il numero di elementi memorizzati nel buffer
  Input: Buffer b: il buffer 
  Output: numero di elementi inseriti nel buffer
*/
int getSizeBuffer(Buffer b){
      return b->size;
}

/*
  Restituisce il numero di elementi memorizzati nel buffer
  Input: Buffer b: il buffer 
  Output: numero di elementi inseriti nel buffer
*/
int getCapacityBuffer(Buffer b){
      return b->capacity;
}

/*
  Restituisce il valore nella posizione offset del buffer.
  Input: Buffer b: il buffer 
         int offset posizione del valore da estrarre, deve essere compreso
             tra 0 e getSizeBuffer(b)-1
*/
float getAtBuffer(Buffer b, int offset){
      if(offset < b->size) return b->vett[offset];
      return FLT_MIN;
}

/*
  Stampa gli elementi del buffer, uno per riga
  Input: Buffer b: il buffer 
*/

void printBuffer(Buffer b){
     int i;
     printf("Buffer size: %d (capacity: %d)\n", getSizeBuffer(b), getCapacityBuffer(b));
     for (i=0; i<getSizeBuffer(b); i++){
         printf("   Buffer[%d]= %.2f\n",i,getAtBuffer(b, i)); 
     }
}

/*
  Aggiunge un elemento al buffer. Se questi ha già raggiunto 
  la sua massima capacità questa viene ampliata (raddoppiata)
  prima di aggiungere il dato
  Input: Buffer b: il buffer 
         float d: nuovo dato da aggiungere al buffer
*/
void addBuffer(Buffer b, float d){
   float * tmp;
   int i;
   if (b->size == getCapacityBuffer(b)) {
      tmp = (float *)malloc(sizeof(float) * getCapacityBuffer(b) * 2);
      for(i=0; i<getSizeBuffer(b); i++) 
         tmp[i] = b->vett[i];
      free(b->vett);
      b->vett=tmp;
      b->capacity *= 2; 
   } 
   b->vett[b->size++]=d;
}

/*
  Aggiunge al buffer tutti gli elementi di un altro buffer 
  Input: Buffer b: il buffer destinazione 
         Buffer altro: il buffer  cui elementi sono da aggiungere a b.
                Non viene modificato
*/
addBufferBuffer(Buffer b, Buffer altro){
   int i;
   for (i=0; i<getSizeBuffer(altro); i++){
      addBuffer(b, getAtBuffer(altro, i)); 
   }
}

/*
  Elimina un buffer dalla memoria del computer, liberando lo spazio occupato
  per usi futuri. 
  Input: Buffer b: il buffer da eliminare 
*/
destroyBuffer(Buffer b){
   free(b->vett);
   free(b);
}

/* 
   Main di prova 
*/
int main(int argc, char *argv[]) {
   Buffer x, y;
   x = initBuffer(3);
   addBuffer(x, 19.4);
   addBuffer(x, -34.59);
   addBuffer(x, 12.45);
   printBuffer(x);
   
   addBuffer(x, 2.5);
   printBuffer(x);

   y = initBuffer(4);
   addBuffer(y, 2.3);
   addBuffer(y, .59);
   addBuffer(y, 8.4);
   addBuffer(y, 9.0);
   addBufferBuffer(x, y);
   printBuffer(x);
 
   destroyBuffer(x);
   destroyBuffer(y);
   system("pause");
	return 0;
}

 Altri metodi da aggiungere (ad esempio). Si lascia al lettore la definizione dell'interfaccia e la codifica

1. removeAtBuffer(...) rimozione di un elemento: il buffer dopo la rimozione viene compattato spostando indietro i successivi
2. existsBuffer(...) ricerca di un elemento
3. removeBufferBuffer(...) elimina tutti gli elementi di un altro buffer
4. toStringBuffer() costruisce una stringa con il contenuto del buffer (simile a printBuffer ma più duttile)
5. orderBuffer(...) riordina il buffer in senso crescente o decrescente
6. cloneBuffer(...) restituisce un clone del buffer passato (ATTENZIONE: deep copy!)

E' anche possibile aggiungere un nome al buffer, da mostrare poi nelle printBuffer e toStringBuffer.