不能用系统命令，纯代码实现

好的，以下是使用C++代码实现压缩文件夹为tar.gz格式的方法：

#include <iostream>
#include <fstream>
#include <cstring>
#include <cstdlib>
#include <dirent.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>
#include <ctime>
#include <cstdio>
#include <zlib.h>

using namespace std;

// 定义tar文件头结构体
struct tar_header {
    char name[100];         // 文件名
    char mode[8];           // 文件权限
    char uid[8];            // 用户ID
    char gid[8];            // 用户组ID
    char size[12];          // 文件大小
    char mtime[12];         // 最后修改时间
    char typeflag;          // 文件类型
    char linkname[100];     // 链接文件名
    char magic[6];          // 魔数
    char version[2];        // 版本号
    char uname[32];         // 用户名
    char gname[32];         // 用户组名
    char devmajor[8];       // 设备号主
    char devminor[8];       // 设备号次
    char prefix[155];       // 前缀
    char padding[12];       // 填充
};

// 定义tar文件头长度
const size_t TAR_HEADER_SIZE = 512;

/**
 * 获取文件属性
 * @param path 文件路径
 * @param st 文件属性结构体
 * @return 成功返回0，失败返回-1
 */
int get_file_stat(const char *path, struct stat *st) {
    if (lstat(path, st) == -1) {
        cout << "Failed to get file stat: " << path << endl;
        return -1;
    }
    return 0;
}

/**
 * 获取文件权限
 * @param st 文件属性结构体
 * @return 文件权限字符串
 */
char *get_file_mode(struct stat st) {
    static char mode[8];
    sprintf(mode, "%07o", st.st_mode & (S_IRWXU | S_IRWXG | S_IRWXO));
    return mode;
}

/**
 * 获取文件大小
 * @param st 文件属性结构体
 * @return 文件大小字符串
 */
char *get_file_size(struct stat st) {
    static char size[12];
    sprintf(size, "%011o", (unsigned int) st.st_size);
    return size;
}

/**
 * 获取最后修改时间
 * @param st 文件属性结构体
 * @return 最后修改时间字符串
 */
char *get_file_mtime(struct stat st) {
    static char mtime[12];
    sprintf(mtime, "%011o", (unsigned int) st.st_mtime);
    return mtime;
}

/**
 * 获取文件类型
 * @param st 文件属性结构体
 * @return 文件类型标志
 */
char get_file_type(struct stat st) {
    if (S_ISREG(st.st_mode)) {
        return '0';     // 普通文件
    } else if (S_ISDIR(st.st_mode)) {
        return '5';     // 目录
    } else if (S_ISLNK(st.st_mode)) {
        return '2';     // 符号链接
    } else if (S_ISCHR(st.st_mode)) {
        return '3';     // 字符设备
    } else if (S_ISBLK(st.st_mode)) {
        return '4';     // 块设备
    } else if (S_ISFIFO(st.st_mode)) {
        return '1';     // FIFO
    } else if (S_ISSOCK(st.st_mode)) {
        return '6';     // Socket
    } else {
        return '0';     // 未知类型
    }
}

/**
 * 压缩文件
 * @param srcFile 源文件路径
 * @param destFile 目标文件路径
 * @return 压缩成功返回0，失败返回-1
 */
int compress_file(const char *srcFile, const char *destFile) {
    gzFile dest = gzopen(destFile, "wb");
    if (!dest) {
        cout << "Failed to open compressed file: " << destFile << endl;
        return -1;
    }

    int src = open(srcFile, O_RDONLY);
    if (src == -1) {
        cout << "Failed to open source file: " << srcFile << endl;
        gzclose(dest);
        return -1;
    }

    char buffer[1024];
    int numRead;
    while ((numRead = read(src, buffer, sizeof(buffer))) > 0) {
        if (gzwrite(dest, buffer, numRead) == 0) {
            cout << "Failed to compress data!" << endl;
            gzclose(dest);
            close(src);
            return -1;
        }
    }

    gzclose(dest);
    close(src);

    return 0;
}

/**
 * 创建tar文件头
 * @param header tar文件头结构体
 * @param path 文件路径
 * @return 成功返回0，失败返回-1
 */
int create_tar_header(tar_header &header, const char *path) {
    struct stat st;
    if (get_file_stat(path, &st) == -1) {
        return -1;
    }

    memset(&header, 0, sizeof(header));
    strcpy(header.name, path);
    strcpy(header.mode, get_file_mode(st));
    strcpy(header.uid, "0000000");
    strcpy(header.gid, "0000000");
    strcpy(header.size, get_file_size(st));
    strcpy(header.mtime, get_file_mtime(st));
    header.typeflag = get_file_type(st);
    strcpy(header.magic, "ustar");
    strcpy(header.version, "00");
    strcpy(header.uname, "user");
    strcpy(header.gname, "users");
    strcpy(header.devmajor, "0000000");
    strcpy(header.devminor, "0000000");

    if (header.typeflag == '2') {
        readlink(path, header.linkname, sizeof(header.linkname));
    }

    return 0;
}

/**
 * 压缩文件夹
 * @param folderName 文件夹路径
 * @param tarName 压缩后的文件名
 * @return 压缩成功返回0，失败返回-1
 */
int compress_folder(const char *folderName, const char *tarName) {
    DIR *dir;
    struct dirent *entry;
    struct stat st;
    char filePath[1024];
    tar_header header;
    int tarFd;

    // 创建tar文件
    tarFd = open(tarName, O_WRONLY | O_CREAT | O_TRUNC, 0644);
    if (tarFd == -1) {
        cout << "Failed to create tar file: " << tarName << endl;
        return -1;
    }

    // 遍历文件夹
    dir = opendir(folderName);
    while ((entry = readdir(dir)) != NULL) {
        if (strcmp(entry->d_name, ".") == 0 || strcmp(entry->d_name, "..") == 0) {
            continue;
        }

        sprintf(filePath, "%s/%s", folderName, entry->d_name);
        if (get_file_stat(filePath, &st) == -1) {
            continue;
        }

        // 创建tar文件头
        if (create_tar_header(header, filePath) == -1) {
            continue;
        }

        // 写入tar文件头
        if (write(tarFd, &header, TAR_HEADER_SIZE) != TAR_HEADER_SIZE) {
            cout << "Failed to write tar header!" << endl;
            close(tarFd);
            return -1;
        }

        // 如果是文件，压缩文件并写入tar文件
        if (S_ISREG(st.st_mode)) {
            if (compress_file(filePath, NULL) == -1) {
                cout << "Failed to compress file: " << filePath << endl;
                close(tarFd);
                return -1;
            }

            int srcFd = open(filePath, O_RDONLY);
            if (srcFd == -1) {
                cout << "Failed to open source file: " << filePath << endl;
                close(tarFd);
                return -1;
            }

            char buffer[1024];
            int numRead;
            while ((numRead = read(srcFd, buffer, sizeof(buffer))) > 0) {
                if (write(tarFd, buffer, numRead) != numRead) {
                    cout << "Failed to write data to tar file!" << endl;
                    close(srcFd);
                    close(tarFd);
                    return -1;
                }
            }

            close(srcFd);
        }
    }

    // 关闭tar文件
    close(tarFd);

    return 0;
}

int main() {
    string folderName = "/path/to/folder"; // 要压缩的文件夹路径
    string tarName = "compressed.tar.gz"; // 压缩后的文件名

    if (compress_folder(folderName.c_str(), tarName.c_str()) == -1) {
        cout << "Failed to compress folder!" << endl;
        return -1;
    }

    cout << "Folder compressed successfully!" << endl;
    return 0;
}

该代码使用了zlib库来压缩文件，并手动创建了tar文件头。首先定义了tar文件头结构体，然后实现了一些辅助函数来获取文件属性和创建tar文件头。在压缩文件夹时，遍历文件夹中的文件和子文件夹，为每个文件创建tar文件头并写入tar文件，如果是普通文件，则压缩文件并写入tar文件。最后关闭tar文件即可。