лабораторные Тимофеев / 3316_Кирейкова_Лабораторная1

std::cout << "Введите ваш выбор: ";

}

std::vector<std::wstring> GetDriversVector() { std::vector<std::wstring> drives;

DWORD bufferSize = GetLogicalDriveStringsW(0, nullptr); if (bufferSize == 0) {

return drives;

}

wchar_t* buffer = newwchar_t[bufferSize];

if (GetLogicalDriveStringsW(bufferSize, buffer)) {

wchar_t* drive = buffer; while (*drive) {

drives.push_back(drive); drive += wcslen(drive) + 1;

}

}

delete[] buffer;

return drives;

}

void GetListOfDrivers() {

std::vector<std::wstring> drives = GetDriversVector(); std::wcout << L"\n Диски на этом ПК:\n"<<

"====================\n";

for (size_t i = 0; i < drives.size(); ++i) {

std::wcout << i + 1 << L". " << drives[i] << std::endl;

}

std::wcout << L"Количество дисков: " << drives.size() << std::endl;

}

void PrintDriveType(const std::wstring& drive) { UINT type = GetDriveType(drive.c_str());

std::wcout <<L"\nИнфоромация о диске\n"<<"========================\n" << L"Тип диска " << drive << L": ";

switch (type) {

case DRIVE_REMOVABLE:

std::wcout << L"Съёмный диск\n"; break;

case DRIVE_FIXED:

std::wcout << L"Жёсткий диск\n"; break;

case DRIVE_REMOTE:

std::wcout << L"Сетевой диск\n"; break;

case DRIVE_CDROM:

std::wcout << L"CD/DVD\n"; break;

case DRIVE_RAMDISK:

std::wcout << L"RAM диск\n"; break;

case DRIVE_NO_ROOT_DIR:

std::wcout << L"Некорректный путь\n"; break;

case DRIVE_UNKNOWN: default:

std::wcout << L"Неизвестный тип\n"; break;

}

}

void PrintVolumeDriveInfo(const std::wstring& driveRoot) { WCHAR volumeName[MAX_PATH] = { 0 };

DWORD volumeSerialNumber = 0;

DWORD maxComponentLength = 0;

DWORD fileSystemFlags = 0;

WCHAR fileSystemName[MAX_PATH] = { 0 };

if (GetVolumeInformationW(

driveRoot.c_str(), volumeName, MAX_PATH, &volumeSerialNumber, &maxComponentLength, &fileSystemFlags, fileSystemName, MAX_PATH

ошибки: " << GetLastError() << std::endl;

}

}

void PrintDriversFreeSpace(const std::wstring& driveRoot) {

DWORD sectorsPerCluster = 0;

DWORD bytesPerSector = 0;

DWORD numberOfFreeClusters = 0;

DWORD totalNumberOfClusters = 0;

}

void CreateNewDirectory(const std::wstring& folderPath) {

BOOL result = CreateDirectory(folderPath.c_str(), nullptr); if (result) {

std::wcout << L"\nКаталог успешно создан " << folderPath << std::endl;

}

else {

DWORD error = GetLastError(); if (error == ERROR_ALREADY_EXISTS)

std::wcout << L"\nОШИБКА! \nКаталог уже существует!" << folderPath << std::endl;

else std::wcout << L"\nОШИБКА:" << error << std::endl;

}

}

void RemoveDir(const std::wstring& folderPath) {

if (RemoveDirectory(folderPath.c_str())) {

std::wcout << L"Папка успешно удалена: " << folderPath << std::endl;

}

else {

std::wcout << L"Не удалось удалить папку. Код ошибки: " << GetLastError() << std::endl;

}

}

void CreateNewFILE(const std::wstring& filePath) {

HANDLE hFile = CreateFileW(filePath.c_str(), GENERIC_WRITE, 0,

NULL, CREATE_NEW, FILE_ATTRIBUTE_NORMAL, NULL);

if (hFile == INVALID_HANDLE_VALUE) {

std::wcout << L"Не удалось создать файл. Код ошибки: " << GetLastError() << std::endl;

}

else {

std::wcout << L"Файл успешно создан: " << filePath << std::endl;

CloseHandle(hFile);

}

}

bool FileExists(const std::wstring& path) {

DWORD attribs = GetFileAttributesW(path.c_str());

return (attribs != INVALID_FILE_ATTRIBUTES && !(attribs & FILE_ATTRIBUTE_DIRECTORY));

}

void Copy(const std::wstring& filePath, const std::wstring& newfilePath) {

BOOL result = CopyFileW(filePath.c_str(), newfilePath.c_str(), TRUE);

if (!result) {

std::wcout << L"Не удалось скопировать файл! Код ошибки:" << GetLastError() << std::endl;

}

else std::wcout << L"Файл успешно скопирован!\n";

}

//Функция для простого перемещения файла

void Move(const std::wstring& filePath, const std::wstring& newfilepath) {

BOOL result = MoveFileW(filePath.c_str(), newfilepath.c_str()); if (!result) {

std::wcout << L"\nНе удалось переместить файл! Код ошибки:" << GetLastError() << std::endl;

}

else std::wcout << L"Файл успешно перемещен!\n";

}

//функция для перемещения уже существующего файла

void MoveEx(const std::wstring& filePath, const std::wstring& newfilepath) {

BOOL result = MoveFileExW(filePath.c_str(), newfilepath.c_str(),

MOVEFILE_REPLACE_EXISTING);

if (!result) {

std::wcout << L"Не удалось переместить файл! Код ошибки:" <<

GetLastError() << std::endl;

}

else std::wcout << L"Файл усешно перемещен с перезаписью!\n";

}

void ComparePathForMove(const std::wstring& filePath, const std::wstring& newfilepath) {

if (FileExists(newfilepath)) {

std::wcout << L"Файл по этому пути уже существует.

Перезаписать?\n1 — ДА\n2 — НЕТ\n";

int answer; std::wcin >> answer; std::wcin.ignore();

if (answer == 1) {

MoveEx(filePath, newfilepath);

}

else if (answer == 2) {

std::wcout << L"Введите другой путь:\n"; std::wstring NEWPATH = InputPath(); Move(filePath, NEWPATH);

}

else {

std::wcout << L"Неверный ввод. Операция отменена.\n";

}

}

else {

Move(filePath, newfilepath);

}

}

void PrintFileAttributes(const std::wstring& filepath) {

DWORD attr = GetFileAttributes(filepath.c_str()); if (attr == INVALID_FILE_ATTRIBUTES) {

std::wcout << L"Не удалось получить атрибуты файла! Код

ошибки:" << GetLastError() << std::endl;

std::wcout << L" Файл не имеет специальных атрибутов (обычный файл)\n";

}

else {

if (attr & FILE_ATTRIBUTE_ARCHIVE) {

std::wcout << L"Файл помечен как архивный.\n";

}

if (attr & FILE_ATTRIBUTE_COMPRESSED) { std::wcout << L"Файл сжат.\n";

}

if (attr & FILE_ATTRIBUTE_DIRECTORY) { std::wcout << L"Это каталог.\n";

}

if (attr & FILE_ATTRIBUTE_ENCRYPTED) { std::wcout << L"Файл зашифрован.\n";

}

if (attr & FILE_ATTRIBUTE_HIDDEN) { std::wcout << L"Файл скрыт.\n";

}

if (attr & FILE_ATTRIBUTE_NORMAL) {

std::wcout << L" Файл не имеет специальных атрибутов (обычный файл)\n";

}

if (attr & FILE_ATTRIBUTE_NOT_CONTENT_INDEXED) { std::wcout << L" Файл не индексируется службой поиска

Windows\n";

}

if (attr & FILE_ATTRIBUTE_OFFLINE) { std::wcout << L" Файл требует загрузки\n";

}

if (attr & FILE_ATTRIBUTE_READONLY) {

std::wcout << L" Доступен только для чтения\n";

}

if (attr & FILE_ATTRIBUTE_REPARSE_POINT) {

std::wcout << L" Яляется точкой повторной обработки\n";

}

if (attr & FILE_ATTRIBUTE_SYSTEM) { std::wcout << L"Системный файл\n";

}

if (attr & FILE_ATTRIBUTE_TEMPORARY) { std::wcout << L"Временный файл\n";

}

}

}

int AddAttributesMenu () {

std::wcout << L"Выберите атрибут, который вы хотите установить для файла:\n";

std::wcout << L"==========================================================\n";

std::wcout << L"1. ТОЛЬКО ДЛЯ ЧТЕНИЯ (FILE_ATTRIBUTE_READONLY)\n"; std::wcout << L"2. СКРЫТЫЙ (FILE_ATTRIBUTE_HIDDEN)\n";

std::wcout << L"3. СИСТЕМНЫЙ (FILE_ATTRIBUTE_SYSTEM)\n"; std::wcout << L"4. АРХИВНЫЙ (FILE_ATTRIBUTE_ARCHIVE)\n"; std::wcout << L"5. ВРЕМЕННЫЙ (FILE_ATTRIBUTE_TEMPORARY)\n"; std::wcout << L"0. Отмена\n";

std::wcout << L"Ведите ваш выбор: "; int choice;

std::wcin >> choice; return choice;

}

DWORD ReturnChoosenAttributes() {

int choice = AddAttributesMenu();

switch (choice) {

case1:

return FILE_ATTRIBUTE_READONLY;

case2:

return FILE_ATTRIBUTE_HIDDEN; case 3:

return FILE_ATTRIBUTE_SYSTEM;

case4:

return FILE_ATTRIBUTE_ARCHIVE;

case5:

return FILE_ATTRIBUTE_TEMPORARY;

default:

return0;

}

}

void AddAttributes() {

std::wcout << L"Введите путь к файлу, для которого вы хотите установить атрибуты:\n"; std::wcin.ignore(std::numeric_limits<std::streamsize>::max(), '\n'); std::wstring path = InputPath();

if (!(SetFileAttributes(path.c_str(), ReturnChoosenAttributes()))) std::wcout << L"Не удалось установить атрибуты! Код ошибки:" << GetLastError() << std::endl;

else std::wcout << L"Атрибут успешно установлен!\n";

}

void PrintFileTime(const FILETIME& ft, const std::wstring& label) { SYSTEMTIME stUTC, stLocal;

FileTimeToSystemTime(&ft, &stUTC);

SystemTimeToTzSpecificLocalTime(NULL, &stUTC, &stLocal); std::wcout << label << L": "

<<std::setfill(L'0') << std::setw(2) << stLocal.wDay << L"."

<<std::setw(2) << stLocal.wMonth << L"."

<<stLocal.wYear << L" "

<<std::setw(2) << stLocal.wHour << L":"

<<std::setw(2) << stLocal.wMinute << L":"

<<std::setw(2) << stLocal.wSecond << std::endl;

}

void GetFileTimes(const std::wstring& filePath) { HANDLE hFile = CreateFileW(

filePath.c_str(), GENERIC_READ, FILE_SHARE_READ,

NULL,

OPEN_EXISTING,

FILE_ATTRIBUTE_NORMAL,

NULL

);

if (hFile == INVALID_HANDLE_VALUE) {

std::wcerr << L"Не удалось открыть файл. Код ошибки: " << GetLastError() << std::endl;

return;

}

FILETIME creationTime, accessTime, writeTime;

if (GetFileTime(hFile, &creationTime, &accessTime, &writeTime)) { SYSTEMTIME stUTC, stLocal;

FileTimeToSystemTime(&creationTime, &stUTC);

SystemTimeToTzSpecificLocalTime(NULL, &stUTC, &stLocal); std::wcout << L"Время создания: " << stLocal.wDay << L"." <<

stLocal.wMonth << L"." << stLocal.wYear

<< L" " << stLocal.wHour << L":" << stLocal.wMinute <<

std::endl;

FileTimeToSystemTime(&accessTime, &stUTC); SystemTimeToTzSpecificLocalTime(NULL, &stUTC, &stLocal); std::wcout << L"Последний доступ: " << stLocal.wDay << L"." <<

stLocal.wMonth << L"." << stLocal.wYear

<< L" " << stLocal.wHour << L":" << stLocal.wMinute <<

std::endl;

FileTimeToSystemTime(&writeTime, &stUTC);

SystemTimeToTzSpecificLocalTime(NULL, &stUTC, &stLocal); std::wcout << L"Последняя запись: " << stLocal.wDay << L"." <<

stLocal.wMonth << L"." << stLocal.wYear

<< L" " << stLocal.wHour << L":" << stLocal.wMinute <<

std::endl;

}

else {

std::wcerr << L"Не удалось получить время файла. Код ошибки: " << GetLastError() << std::endl;

}

CloseHandle(hFile);

}

void SetFileTimeToNow(const std::wstring& filePath) { HANDLE hFile = CreateFileW(

filePath.c_str(), GENERIC_WRITE,

0,

NULL,

OPEN_EXISTING,

FILE_ATTRIBUTE_NORMAL,

NULL

);

if (hFile == INVALID_HANDLE_VALUE) {

std::wcerr << L"Не удалось открыть файл. Код ошибки: " << GetLastError() << std::endl;

return;

}

FILETIME ft;

GetSystemTimeAsFileTime(&ft); // Текущее время в формате FILETIME

if (SetFileTime(hFile, NULL, NULL, &ft)) {

std::wcout << L"Время последней записи установлено на текущее.\n";

}

else {

std::wcerr << L"Не удалось установить время. Код ошибки: " << GetLastError() << std::endl;

}

CloseHandle(hFile);

}

void GetFileInfo(const std::wstring& filePath) { HANDLE hFile = CreateFileW(

filePath.c_str(), GENERIC_READ,

FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, NULL,

OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL

);

if (hFile == INVALID_HANDLE_VALUE) {

std::wcerr << L"Не удалось открыть файл. Код ошибки: " << GetLastError() << std::endl;

return;

}

BY_HANDLE_FILE_INFORMATION fileInfo;

if (GetFileInformationByHandle(hFile, &fileInfo)) { std::wcout << L"Атрибуты файла: ";

PrintFileAttributes(filePath.c_str());

PrintFileTime(fileInfo.ftCreationTime, L"Время создания");

PrintFileTime(fileInfo.ftLastAccessTime, L"Последний доступ"); PrintFileTime(fileInfo.ftLastWriteTime, L"Последняя запись");

std::wcout << L"Серийный номер тома: " << fileInfo.dwVolumeSerialNumber << std::endl;

LARGE_INTEGER fileSize;

fileSize.HighPart = fileInfo.nFileSizeHigh; fileSize.LowPart = fileInfo.nFileSizeLow;

std::wcout << L"Размер файла: " << fileSize.QuadPart << L" байт" << std::endl;

std::wcout << L"Число жёстких ссылок: " << fileInfo.nNumberOfLinks << std::endl;

ULONGLONG fileIndex = (static_cast<ULONGLONG>(fileInfo.nFileIndexHigh) << 32) | fileInfo.nFileIndexLow;

std::wcout << L"Индекс файла: " << fileIndex << std::endl;

}

else {

std::wcerr << L"Не удалось получить информацию о файле. Код ошибки: " << GetLastError() << std::endl;

}

CloseHandle(hFile);

}

void ShowDriversMenuLoop() {

GetListOfDrivers();

std::vector<std::wstring> drives = GetDriversVector(); int choicedriver;

int quantity = GetQuantityOfDrivers();

bool inDriverMenu = true;

while (inDriverMenu)

{

ShowDriversMenu(); std::cin >> choicedriver;

if (std::cin.fail()) {

clearInputBuffer();

std::cout << "Некорректный ввод. Попробуйте снова.\n"; continue;

}

elseif (choicedriver == 1) { inDriverMenu = false;

}

elseif (choicedriver >= 2 && choicedriver <= quantity + 1) { std::wstring disk = drives[choicedriver - 2];

wchar_t letter = disk[0];

std::wcout << L"\nВы выбрали диск: " << letter<< std::endl <<"========================\n" << L"1. Посмотреть информацию о диске

\n" << L"2. Посмотреть размер свободного пространства \n" << L"3.

Вернуться в меню дисков\n" << L"\n========================\n" <<

L"Введите нужное действие: " ;

bool InDriverActions = true;

int choicedriverforact;

while (InDriverActions) {

std::cin >> choicedriverforact; switch (choicedriverforact)

{

case1:

//std::wcout << L"\n Тип выбранного диска: ";

PrintDriveType(disk);

PrintVolumeDriveInfo(disk);

InDriverActions = 0;

break; case 2:

PrintDriversFreeSpace(disk);

InDriverActions = 0;

break;

case3:

InDriverActions = 0;

break;

}

}

}

else {

std::wcout << L"Такого пункта нет. Попробуйте снова.\n";

}

/* switch (choicedriver)

{

{

case 1:

std::cout << "Возврат в главное меню.\n"; inDriverMenu = false;

break; case 2:

std::vector<std::wstring> drives = GetDriversVector(); std::wstring disk = drives[choicedriver - 2];

for (size_t i = 0; i < drives.size(); ++i) {

}

break;

}

}*/

}

}

void ShowMainMenuLoop() {

while (true) { showMainMenu();

int choice; std::cin >> choice;

if (std::cin.fail()) {

clearInputBuffer();

std::cout << "Некорректный ввод. Попробуйте снова.\n"; continue;

}

switch (choice) {

case1:

ShowDriversMenuLoop();

break;

case2:{

std::wcout << L"Напишите путь для нового каталога \n ПРИМЕР- C:\\Users\\Имя\\Новый каталог\n";

std::wstring Path; std::wcin.ignore(); std::getline(std::wcin, Path); CreateNewDirectory(Path); break;

}

case3: {

std::wcout << L"Введите путь к каталогу который хотите удалить: \n ПРИМЕР- C:\\Users\\Имя\\Новый каталог\n";

std::wstring Path; std::wcin.ignore(); std::getline(std::wcin, Path);

RemoveDir(Path);

break; }

case4: {

std::wcout << L"Введите путь к новому файлу (например, C:\\Users\\Имя\\Desktop\\test.txt):\n";

std::wstring filePath; std::wcin.ignore(); std::getline(std::wcin, filePath);

CreateNewFILE(filePath);

break; }

case5: {

std::wcin.ignore(std::numeric_limits<std::streamsize>::max(), '\n'); std::wcout << L"\nВведите адрес файла, который нужно

скопировать: \n";

std::wstring Path = InputPath();

std::wcout << L"\nВведите адрес для нового файла: \n"; std:: wstring newPath = InputPath();

Copy(Path, newPath);

break;

}

case6: {

std::wcin.ignore(std::numeric_limits<std::streamsize>::max(), '\n'); std::wcout << L"\nВведите адрес файла, который нужно

переместить: \n";

std::wstring Path = InputPath();

std::wcout << L"\nВведите адрес куда нужно переместить

файл: \n";

std::wstring newPath = InputPath(); ComparePathForMove(Path, newPath); break;

}

case7: {

std::wcout << L"Введите путь к файлу, атрибуты которого хотите узнать:";

std::wcin.ignore(std::numeric_limits<std::streamsize>::max(), '\n'); std:: wstring path = InputPath();

PrintFileAttributes(path.c_str());

break;

}

case8: {

AddAttributes();

break; } case 9: {

std::wcin.ignore(std::numeric_limits<std::streamsize>::max(), '\n'); std::wcout << L"Введите путь к файлу информацию окотором

вы хотите посмотреть:\n";

std::wstring path = InputPath(); std::wcout <<

L"==============================================================\n";

GetFileInfo(path.c_str());

break; }

case10: {

std::wcin.ignore(std::numeric_limits<std::streamsize>::max(), '\n'); std::wcout << L"Введите путь к файлу информацию о времени

которого вы хотите посмотреть:\n"; std::wstring path = InputPath(); std::wcout <<

L"==============================================================\n";

GetFileTimes(path.c_str());