C/C++ - "Compattare" un array...

Rieccomi con una delle mie domande banali.

Per aggiornare un programmino che sto scrivendo (un programma da usare a scuola con le lavagne LIM in dotazione) ho necessità di dotarmi di un vettore di immagini che rappresentino le pagine sulle quali scrivere/disegnare. Per gestire un sistema di pagine multiple, tipo fogli di un blocco note, ho bisogno di gestire un vettore non dinamico (il programma prevede che si possano aggiungere e togliere pagine a piacere, ma solo entro un numero massimo di pagine predefinito) di HBITMAP di Win32 da selezionare secondo necessità, per cui devo assicurarmi che in quel vettore non compaiano mai valori NULL entro la gamma delle pagine disponibili. Questo comporta che all'eliminazione delle pagine io debba "compattare" il vettore per eliminare i valori NULL che derivano dall'eliminazione (possono essere in qualsiasi posizione e in qualsiasi quantità entro il massimo previsto). Ho pensato a una funzione come quella che riporto qui sotto, che dai test sembra funzionare a dovere. La domanda è: mi sapete consigliare un metodo migliore per "compattare" l'array, nei limiti della difficoltà limitata che sono in grado di gestire?

// Nella funzione che segue, pp e' un puntatore ad un vettore di elementi di
// tipo HBITMAP che contiene totEl HBITMAP (potrebbe comunque essere il
// puntatore ad un vettore di elementi di qualsiasi altro tipo). L'intenzione
// e' "compattare" quegli elementi in modo da eliminare ogni HBITMAP di valore
// NULL compreso tra HBITMAP di valore non NULL. Per ottenere lo scopo ricorre
// a due puntatori ausiliari a HBITMAP, p1 e p2.

void CompattaArrayHBITMAP( HBITMAP *pp, int totEl ) {
    HBITMAP *p1, *p2;
    p1 = p2 = pp;

    do {
        while( *p2==NULL && p2<(pp+totEl) ) ++p2; // cerca il primo non NULL

        if( p2 == (pp+totEl) ) break; // siamo in fondo all'array

        if( p1 != p2 )
            *p1++ = *p2++;    // sposta e incrementa
        else { ++p1; ++p2; }  // incrementa senza spostare
    } while( true ); // per sempre! esce col break

    while( p1<(pp+totEl) ) *p1++ = NULL; // "annulla" gli HBITMAP rimanenti
}

Dimenticavo... non me la sento di "infognarmi" con le STL, perché per ora mi confondono le idee ben più di quanto mi aiutino.

Continui a portare gli elementi antecedenti al primo NULL indietro di una posizione finché l'ultimo elemento, prima in posizione k finisce in k - 1.....

Sì. Va bene o è un procedimento stupido, secondo te? Puoi consigliarne dei migliori?

Se non ci sono problemi di memoria, un modo più semplice (e veloce) è di allocare un nuovo array di HBITMAP e fare un singolo passo con un for loop. Qualcosa come:

HBITMAP *nuovo = new HBitmap[totEl];

for (int i = 0, int j = 0; i < totEl; i++){
    if (*pp[i] != NULL) nuovo[j++] = pp[i];
}

// j contiene la nuova dimensione dell'array

return nuovo;

Puoi usare una lista

cprogramming.com/tutorial/c/…

No, riordinare l'array come ti ho consigliato va benissimo e non dovresti allocare e liberare memoria ogni volta che devi riordinare l'array. Se non puoi usare le liste è la cosa migliore

A meno che il numero di elementi è particolarmente grande e la velocità d'esecuzione è importante. Fare uno shift senza un array secondario in questa maniera è O(n^2).