Есть класс для работы с каталогами, быстрее ли будет с классом string

#include <vector>
 
class WorkWithDir
{
private:
    HANDLE hFind;
 
    WIN32_FIND_DATAW wfd;
    //SYSTEMTIME st;
 
    // Структура информации о файле.
    struct fileStructInfo
    {
        DWORD dwFileAttribute;
        SYSTEMTIME stCreationTime;
        SYSTEMTIME stLastAccessTime;
        SYSTEMTIME stLastWriteTime;
        ULONGLONG nFileSize;
        DWORD dwReserved0;
        WCHAR cFileName[MAX_PATH];
        WCHAR cAlternateFileName[14];
    };
 
    unsigned int sizeArrfiles; // количество файлов каталоге.
    unsigned int sizeArrdir; // количество каталогов в каталоге.
    unsigned int dir = 0, files = 0;
    unsigned int indexfile = 0, indexdir = 0; // количество файлов во временном массиве структур.
 
    std::vector<fileStructInfo> dirVec; // Вектор структур  информации о каталогах и файлах.
    std::vector<fileStructInfo> filesVec; // Вектор структур  информации о файлах.
 
public:
    wchar_t pathDirectory[MAX_PATH]; // путь к каталогу.
    std::vector<fileStructInfo> dirfilesVec; // Вектор структур  информации о каталогах и файлах.
 
    void createFilesArray();
    void setStartDir(WCHAR *dir);
    void setRootDirectory();
    void getDirectory();
    void setDirectory();
    void upDirectory(wchar_t *pszDirPath);
    void downDirectory();
    //void setArrayOfFiles();
    void readDirectoryInfilesArray();
    LPWSTR SetFullPath(wchar_t *pszfileName);
};

#define _CRT_SECURE_NO_WARNINGS
#pragma once
 
#define UNICODE
#define _UNICODE
 
#include <Windows.h>
#include <tchar.h>
#include <iostream>
#include <vector>
#include "workWithDir.h"
 
// Структуры информации о файле.
/*typedef struct _WIN32_FIND_DATA
{
  DWORD    dwFileAttributes;       // атрибуты файла
  FILETIME ftCreationTime;         // время создания файла
  FILETIME ftLastAccessTime;       // время доступа
  FILETIME ftLastWriteTime;        // время записи
  DWORD    nFileSizeHigh;     // размер файла (старшее слово)
  DWORD    nFileSizeLow;      // размер файла (младшее слово)
  DWORD    dwReserved0;            // зарезервировано
  DWORD    dwReserved1;            // зарезервировано
  TCHAR    cFileName[MAX_PATH];    // имя файла
  TCHAR    cAlternateFileName[14]; // альтернативное имя файла
} WIN32_FIND_DATA*/
 
//  Вычислить размеры вектора структур файлов.
void WorkWithDir::createFilesArray()
{
sizeArrfiles = 0;
hFind = FindFirstFileW(pathDirectory, &wfd);
setlocale(LC_ALL, "");
if (INVALID_HANDLE_VALUE != hFind)
{
    do
    {
        if(wfd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
        sizeArrdir++;
        else
        sizeArrfiles++;
    }while (NULL != FindNextFileW(hFind, &wfd));
                FindClose(hFind);
    }
        dirVec.resize(sizeArrdir);
        filesVec.resize(sizeArrfiles);
}
 
// установить стартовую директорию.
void WorkWithDir::setStartDir(WCHAR *dir)
{
    wchar_t *pstr = pathDirectory; *pstr = 0;
    wcscat(pathDirectory, dir);
    wcscat(pathDirectory, L"*.*\0");
    SetCurrentDirectoryW(pathDirectory);
}
 
// Получить текущую директорию.
void WorkWithDir::getDirectory()
{
    GetCurrentDirectoryW(sizeof(pathDirectory), pathDirectory);
}
 
// установить текущую директорию.
void WorkWithDir::setDirectory()
{
    SetCurrentDirectoryW(pathDirectory);
}
 
// Перейти в корневую директорию.
void WorkWithDir::setRootDirectory()
{
    wchar_t *pstr = pathDirectory; pstr++ ; *pstr = 0;
    wcscat(pathDirectory, L":\\*.*");
    SetCurrentDirectoryW(pathDirectory);
}
 
// Перейти по директории в верх.
void WorkWithDir::upDirectory(wchar_t *pszDirPath)
{
    wchar_t *pstr = pathDirectory + wcslen(pathDirectory); pstr = pstr - 3; *pstr = 0;   
    wcscat(pathDirectory, pszDirPath); wcscat(pathDirectory, L"\\*.*\0");
    SetCurrentDirectoryW(pathDirectory);
}
 
// Перейти по директории в низ.
void WorkWithDir::downDirectory()
{
    wchar_t *pstr = pathDirectory + wcslen(pathDirectory);
    while(*pstr != L'\\') { --pstr; }; *pstr = 0; while(*pstr != L'\\') { --pstr; }; ++pstr; *pstr = 0;
    wcscat(pathDirectory, L"*.*\0"); SetCurrentDirectoryW(pathDirectory);
}
 
// Прочитать содержимое директории в вектор структур, с предварительным вычислением размера вектора.
void WorkWithDir::readDirectoryInfilesArray()
{
    dirfilesVec.clear();
    sizeArrfiles = 0, sizeArrdir = 0;
    hFind = FindFirstFile(pathDirectory, &wfd);
 
    setlocale(LC_ALL, "");
    if(INVALID_HANDLE_VALUE != hFind)
    {
        do
        {
            if(wfd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
            sizeArrdir++;
            else
            sizeArrfiles++;
        }while (NULL != FindNextFile(hFind, &wfd));
                FindClose(hFind); 
    }
 
    dirVec.resize(sizeArrdir);
    filesVec.resize(sizeArrfiles);
    //g_dirfilesVec.resize(sizeArrdir + sizeArrfiles);
 
    indexfile = 0, indexdir = 0;
    hFind = FindFirstFile(pathDirectory, &wfd);
    setlocale(LC_ALL, "");
    if (INVALID_HANDLE_VALUE != hFind)
    {
        do
        {
            if(wfd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
            {
            dirVec[indexdir].dwFileAttribute = wfd.dwFileAttributes;
            FileTimeToSystemTime(&wfd.ftCreationTime, &dirVec[indexdir].stCreationTime);
            FileTimeToSystemTime(&wfd.ftLastAccessTime, &dirVec[indexdir].stLastAccessTime);
            FileTimeToSystemTime(&wfd.ftLastWriteTime, &dirVec[indexdir].stLastWriteTime);
            {
            dirVec[indexdir].nFileSize = (wfd.nFileSizeHigh * (MAXDWORD+1)) + wfd.nFileSizeLow;
            }
            dirVec[indexdir].dwReserved0 = wfd.dwReserved0;
            wcscat(wcscpy(dirVec[indexdir].cFileName, wfd.cFileName), _TEXT("\0"));
            wcscat(wcscpy(dirVec[indexdir].cAlternateFileName, wfd.cAlternateFileName), _TEXT("\0"));
            indexdir++;
            dir++;
            }
            else
            {
            filesVec[indexfile].dwFileAttribute = wfd.dwFileAttributes;
            FileTimeToSystemTime(&wfd.ftCreationTime, &filesVec[indexfile].stCreationTime);
            FileTimeToSystemTime(&wfd.ftLastAccessTime, &filesVec[indexfile].stLastAccessTime);
            FileTimeToSystemTime(&wfd.ftLastWriteTime, &filesVec[indexfile].stLastWriteTime);
            {
            filesVec[indexfile].nFileSize = (wfd.nFileSizeHigh * (MAXDWORD+1)) + wfd.nFileSizeLow;
            }
            filesVec[indexfile].dwReserved0 = wfd.dwReserved0;
            wcscat(wcscpy(filesVec[indexfile].cFileName, wfd.cFileName), _TEXT("\0"));
            wcscat(wcscpy(filesVec[indexfile].cAlternateFileName, wfd.cAlternateFileName), _TEXT("\0"));
            indexfile++;
            files++;
            }
        }while (NULL != FindNextFile(hFind, &wfd));
                FindClose(hFind); 
    }
    dirVec.insert(dirVec.end(), filesVec.begin(), filesVec.end());
    dirfilesVec.insert(dirfilesVec.end(), dirVec.begin(), dirVec.end());
    dirVec.clear(); filesVec.clear();
}
 
LPWSTR WorkWithDir::SetFullPath(wchar_t *pszfileName)
{
    wchar_t pszfullPath[MAX_PATH];
    //wchar_t fileName[MAX_PATH];
    wcscpy(pszfullPath, pathDirectory);
    wchar_t *pstr = pszfullPath + wcslen(pszfullPath);
    short index = 0; while(*pstr != L'\\') { --pstr; }; ++pstr; *pstr = 0;
    wcscpy(pszfullPath, pszfileName);
    return pszfullPath;
}
 
/*  // Прочитать содержимое директории в вектор структур.
    void workFromDir::setArrayOfFiles()
    {
    indexfile = 0;
    hFind = FindFirstFileW(pathDirectory, &wfd);
    setlocale(LC_ALL, "");
    if (INVALID_HANDLE_VALUE != hFind)
        {
        do
        {
            g_filesArray[indexfile].dwFileAttribute = wfd.dwFileAttributes;
            g_filesArray[indexfile].dwReserved0 = wfd.dwReserved0;
            FileTimeToSystemTime(&wfd.ftCreationTime, &g_filesArray[indexfile].stCreationTime);
            FileTimeToSystemTime(&wfd.ftLastAccessTime, &g_filesArray[indexfile].stLastAccessTime);
            FileTimeToSystemTime(&wfd.ftLastWriteTime, &g_filesArray[indexfile].stLastWriteTime);
            {
            g_filesArray[indexfile].nFileSize = (wfd.nFileSizeHigh * (MAXDWORD+1)) + wfd.nFileSizeLow;
            }
            wcscat(wcscpy(g_filesArray[indexfile].cFileName, wfd.cFileName), L"\0");
            wcscat(wcscpy(g_filesArray[indexfile].cAlternateFileName, wfd.cAlternateFileName), L"\0");
            indexfile++;
        } while (NULL != FindNextFileW(hFind, &wfd));
                FindClose(hFind);
                }
    }*/