Tutorial WinAPI C++ 3.9 (Creación del ObjetoZLIB)

// Clase destinada a contener datos comprimidos
// Se ha hecho de forma que se puede agregar un archivo por partes de tamaño variable.
class ContenedorBinario {
 public : //////// Miembros publicos
                // -Constructor
                ContenedorBinario(void) {
                    _Longitud = 0; 
                    _Datos = NULL; 
                };
                // -Destructor
               ~ContenedorBinario(void) { 
                   if (_Datos != NULL) delete [] _Datos; 
                };
                // -Función para agregar una parte
   void         AgregarParte(const char *NuevaParte, const size_t LongitudParte) {
                    char *NuevosDatos = new char [_Longitud + LongitudParte];
                    if (_Datos != NULL) {
                        CopyMemory(NuevosDatos, _Datos, _Longitud);
                        delete [] _Datos;
                    }
                    CopyMemory(&NuevosDatos[_Longitud], NuevaParte, LongitudParte);
                    _Datos = NuevosDatos;
                    _Longitud += LongitudParte;
                };
                // -Operador que retorna una referencia a los datos 
                //  de esta clase en la posición especificada
   char           *operator[] (const UINT nPos) {
                    return &_Datos[nPos];
                };
                // -Operador que retorna la posicion de inicio de 
                //  los datos que contiene esta clase
   char           *operator() (void) const {
                    return _Datos;
                };
                // -Función que retorna el tamaño total de los datos de esta clase
   UINT         Longitud(void) const {
                    return _Longitud;
                };
                // -Función que borra los datos de esta clase
   void         Borrar(void) {
                    _Longitud = 0;
                    if (_Datos != NULL) delete [] _Datos;
                    _Datos = NULL;
                };
 protected : ///// Miembros protegidos
                // -Miembro que contiene los datos agregados
   char       *_Datos;
                // -Miembro que contiene el tamaño de la variable _Datos
   UINT        _Longitud;
};

// Clase que contiene las funciones necesarias para ensamblar el instalador, y para instalarse
class ObjetoZLIB  { 
 public : //////////////////// Miembros publicos
                            // -Constructor
                            ObjetoZLIB(void);
                            // -Destructor
                           ~ObjetoZLIB(void);
                            // -Función que comprime un archivo dentro de una clase ContenedorBinario
    const BOOL              Comprimir(const TCHAR *nPathOrigen, ContenedorBinario &Datos);
                            // -Función que descomprime un ContenedorBinario y lo guarda en nPathDestino como un archivo
    const BOOL              Descomprimir(ContenedorBinario &Datos, const TCHAR *nPathDestino);
};

const BOOL ObjetoZLIB::Comprimir(const TCHAR *nPathOrigen, ContenedorBinario &Datos) {
    ObjetoArchivo Origen;
    Datos.Borrar();
    // Si el archivo origen no se puede abrir retornamos FALSE
    if (Origen.AbrirArchivoLectura(nPathOrigen) == false) return FALSE;

    int ret, flush;
    unsigned have;
    z_stream strm;
    char in[CHUNK];
    char out[CHUNK];

    // Inicialización
    strm.zalloc = Z_NULL;
    strm.zfree = Z_NULL;
    strm.opaque = Z_NULL;
    ret = deflateInit(&strm, 5);
    if (ret != Z_OK) return FALSE;

    // Comprimimos hasta el final del archivo
    do {
        strm.avail_in = Origen.Leer(&in, CHUNK * sizeof(char));
        flush = Origen.FinalDelArchivo() ? Z_FINISH : Z_NO_FLUSH;
        strm.next_in = reinterpret_cast<Bytef *>(&in[0]);

        // Ejecutamos deflate hasta que comprimamos todo el archivo
        do {
            strm.avail_out = CHUNK;
            strm.next_out = reinterpret_cast<Bytef *>(&out[0]);
            ret = deflate(&strm, flush); 
            have = CHUNK - strm.avail_out;
            Datos.AgregarParte(out, have);
        } while (strm.avail_out == 0);
    
    } while (flush != Z_FINISH);

    // Liberamos la memoria usada por la zlib
    deflateEnd(&strm);
    return TRUE;
}

const BOOL ObjetoZLIB::Descomprimir(ContenedorBinario &Datos, const TCHAR *nPathDestino) {
    ObjetoArchivo Destino;
    // Si el archivo destino no se puede abrir retornamos FALSE
    if (Destino.AbrirArchivoEscritura(nPathDestino, true) == FALSE) return FALSE;

    int ret;
    unsigned have;
    z_stream strm;
    char in[CHUNK] = "";
    char out[CHUNK] = "";

    unsigned int Posicion = 0;

    // Inicialización
    strm.zalloc = Z_NULL;
    strm.zfree = Z_NULL;
    strm.opaque = Z_NULL;
    strm.avail_in = 0;
    strm.next_in = Z_NULL;
    ret = inflateInit(&strm);
    if (ret != Z_OK) return FALSE;

    // Descomprimimos hasta que se terminen los datos
    do {
        if (Posicion + CHUNK < Datos.Longitud()) {
            memcpy(in, Datos[Posicion], CHUNK);
            strm.avail_in = CHUNK;
        }
        else {
            memcpy(in, Datos[Posicion], Datos.Longitud() - Posicion);
            strm.avail_in = Datos.Longitud() - Posicion;
        }
        Posicion += CHUNK;

        if (strm.avail_in == 0)
            break;
        strm.next_in = reinterpret_cast<Bytef *>(&in[0]);

        // Ejecutamos inflate para extraer los datos
        do {
            strm.avail_out = CHUNK;
            strm.next_out = reinterpret_cast<Bytef *>(&out[0]);
            ret = inflate(&strm, Z_NO_FLUSH);
            switch (ret) {
                case Z_NEED_DICT:
                    ret = Z_DATA_ERROR;
                case Z_DATA_ERROR:
                case Z_MEM_ERROR:
                    (void)inflateEnd(&strm);
                    return ret;
            }
            have = CHUNK - strm.avail_out;
            Destino.Guardar(out, have);
        } while (strm.avail_out == 0);

      // Terminamos cuando inflate retorne Z_STREAM_END
    } while (ret != Z_STREAM_END);

    // Liberamos la memoria usada por la ZLIB
    inflateEnd(&strm);
    return (ret == Z_STREAM_END) ? TRUE : FALSE;
}