Здравствуйте, Аноним, Вы писали:

А>Кстати, вопрос в тему — как добавить в ZIP-архив пустую папку?
Не, не знаю. Не нужно было, не разбирался.

PS.
Вот ведь время летит... Оригинальному посту уже два года (!!!) стукнуло. А вроде как вчера писал
Раз уж тема всплыла, кидаю код с распаковщиком. Чуток отличается от прежнего, переделывался под нужды одной из прог. Функционал по минимуму — простые архивы кушает, без папок. Но всяко лучше чем ничего, может кому и пригодится.

Packer.h

#pragma once

#include <vector>
#include <string>

typedef std::vector<std::string> STR_VEC;

struct CPacker
{
    //заархивировать файлы
    BOOL Pack(STR_VEC& _files, const char* _zipName);
    //разархивировать
    BOOL Unpack(const char* _zipName, const char* _dstFolder);
};

Packer.cpp

#include "StdAfx.h"
#include ".\packer.h"

#include ".\zlib\zip.h"
#include ".\zlib\unzip.h"
#include <sys/stat.h>
#include <time.h>

#pragma comment(lib, ".\\zlib\\zlib.lib")

#define READ_BUFFER_SIZE 65535

BOOL CPacker::Pack(std::vector<std::string>& _files, const char* _zipName)
{
    BOOL result = false;
    if ( 0 == _files.size()) 
        return result;

    STR_VEC::const_iterator Iter = _files.begin();
    zipFile zipfile = zipOpen(_zipName, 0);
    if (zipfile != NULL)
    {
        while (Iter != _files.end())
        {
            result = false;
            const char* srcFullFileName = Iter->c_str();
            const char* p = strrchr(srcFullFileName, '\\');
            const char* srcFileName = (NULL == p) ? srcFullFileName : p + 1;

            char read_buf[READ_BUFFER_SIZE];
            FILE* file = fopen(srcFullFileName, "rb");
            if (file != NULL)
            {
                zip_fileinfo zfileinfo = {0};
                struct _stat file_stat = {0};
                _fstat(_fileno(file), &file_stat);
                struct tm* file_time = localtime(&file_stat.st_mtime);
                tm_zip* zip_time = &zfileinfo.tmz_date;
                memcpy(zip_time, file_time, sizeof(tm_zip));

                int compression = Z_BEST_COMPRESSION;
                if ( ZIP_OK == zipOpenNewFileInZip(zipfile, srcFileName, 
                    &zfileinfo, NULL, 0, NULL, 0, NULL, Z_DEFLATED, compression))
                {
                    while(!feof(file))
                    {
                        result = false;
                        size_t count = fread( read_buf, sizeof(char), READ_BUFFER_SIZE, file );
                        if(!ferror(file))
                        {
                            if ( ZIP_OK == zipWriteInFileInZip(zipfile, read_buf, count))
                            {
                                result = true;
                                continue;
                            }
                            else 
                                break;
                        }else 
                            break;
                    }
                    result = result && (Z_OK == zipCloseFileInZip(zipfile));
                }
                result = result && (0 == fclose(file));
            }
            (result) ? Iter++ : Iter = _files.end();
        }
        result = result && (Z_OK == zipClose(zipfile, NULL));
    }
    return result;
}

BOOL CPacker::Unpack(const char* _zipName, const char* _dstFolder)
{
    BOOL result = FALSE;
    unzFile zipFile = unzOpen(_zipName);
    if (NULL != zipFile) 
    {
        if (UNZ_OK == unzGoToFirstFile(zipFile))
        {
            BOOL bContinue = TRUE;
            while (bContinue) 
            {
                result = FALSE;
                unz_file_info fi;
                char filename[MAX_PATH] = {0};
                if (UNZ_OK == unzGetCurrentFileInfo(zipFile, &fi, 
                    filename, sizeof(filename), 0, 0, 0, 0))
                {
                    if (UNZ_OK == unzOpenCurrentFile(zipFile))
                    {
                        UINT dataLen = fi.uncompressed_size;
                        BYTE* fileData = new BYTE[dataLen];
                        if (!fileData) 
                            break;
                        if(dataLen == unzReadCurrentFile(zipFile, fileData, dataLen))
                        {
                            char filePathName[MAX_PATH] = {0};
                            strcat(filePathName, _dstFolder);
                            strcat(filePathName, "\\");
                            strcat(filePathName, filename);
                            FILE* pFile = fopen(filePathName, "wb");
                            if (pFile)
                            {
                                result = (dataLen == fwrite(fileData, 1, dataLen, pFile));
                                result = result && (0 == fclose(pFile));
                            }
                        }
                        delete [] fileData;
                    }
                    result = result && (UNZ_OK == unzCloseCurrentFile(zipFile));
                }
                if (!result) 
                    break;
                if (UNZ_END_OF_LIST_OF_FILE == unzGoToNextFile(zipFile))
                    bContinue = FALSE;
            }
        }
        result = result && (UNZ_OK == unzClose(zipFile));
    }
    return result;
}