FILE MANAGEMENT

FILE DIRECTORIES
1. SINGLE FILE DIRECTORY
#include <iostream> }
#include <string> }
#include <vector>
private:
class File { std::vector<File> files;
public: };
File(std::string name) : name(name) {}
int main() {
std::string getName() const { SingleLevelDirectory directory;
return name; directory.addFile(File("file1.txt"));
} directory.addFile(File("file2.txt"));
directory.addFile(File("file3.txt"));
private:
std::string name; std::cout << "Files in Single-level
directory:" << std::endl;
};
directory.listFiles();

class SingleLevelDirectory {
return 0;
public:
}
void addFile(File file) {
files.push_back(file);
}

void listFiles() const {

for (const File& file : files) {
std::cout << file.getName() <<
std::endl; 2. TWO LEVEL DIRECTORY
#include <iostream> for (const File& file : files->second)
{
#include <string>
std::cout << file.getName() <<
#include <unordered_map>
std::endl;
#include <vector>
}
} else {
class File {
std::cout << "Directory not found!"
public: << std::endl;

File(std::string name) : name(name) {} }

}

std::string getName() const {

return name; private:

} std::unordered_map<std::string,
std::vector<File>> directories;
};
private:
std::string name;
int main() {
};
TwoLevelDirectory directory;
directory.addFile("dir1", File("file1.txt"));
class TwoLevelDirectory {
directory.addFile("dir2", File("file2.txt"));
public:
directory.addFile("dir1", File("file3.txt"));
void addFile(std::string directoryName,
File file) {
std::cout << "Files in Two-level directory
directories[directoryName].push_back(file); 'dir1':" << std::endl;
} directory.listFiles("dir1");

void listFiles(std::string directoryName) std::cout << "Files in Two-level directory

const { 'dir2':" << std::endl;
const auto& files = directory.listFiles("dir2");
directories.find(directoryName);
if (files != directories.end()) {
 return 0; }
}
void addSubDirectory(std::string name,
TreeNode* directory) {
3. TREE – STRUCTURED DIRECTORY
subDirectories[name] = directory;
}
#include <iostream>
#include <string>
TreeNode* getSubDirectory(std::string
#include <unordered_map>
name) {
#include <vector>
const auto& it =
subDirectories.find(name);

class File { if (it != subDirectories.end()) {

public: return it->second;

File(std::string name) : name(name) {} }

return nullptr;

std::string getName() const { }

return name;
} void listFiles() const {
for (const File& file : files) {

private: std::cout << file.getName() <<

std::endl;
std::string name;
}
};
for (const auto& entry : subDirectories)
{
class TreeNode { entry.second->listFiles();
public: }
explicit TreeNode(std::string name) : }
name(name) {}

private:
void addFile(File file) {
std::string name;
files.push_back(file);
 std::vector<File> files;
std::unordered_map<std::string,
TreeNode*> subDirectories;
};

int main() {
TreeNode root("root");
TreeNode dir1("dir1");
TreeNode dir2("dir2");

dir1.addFile(File("file1.txt"));
dir1.addFile(File("file2.txt"));
dir2.addFile(File("file3.txt"));

root.addSubDirectory("dir1", &dir1);
root.addSubDirectory("dir2", &dir2);

std::cout << "Files in Tree-structured

directory:" << std::endl;
6 FILE SYSTEM OPERATIONS
root.listFiles();
#include <iostream>
#include <fstream>
return 0;
#include <string>
}

// Function to create a file

void createFile(const std::string& filename)
{
std::ofstream file(filename);
if (file) {
 std::cout << "File created successfully." if (file) {
<< std::endl;
file << content << std::endl;
} else {
std::cout << "Content written to the
std::cerr << "Failed to create the file." file." << std::endl;
<< std::endl;
} else {
}
std::cerr << "Failed to open the file for
file.close(); writing." << std::endl;
} }
file.close();
// Function to read from a file }
void readFile(const std::string& filename) {
std::ifstream file(filename); // Function to delete a file
if (file) { void deleteFile(const std::string& filename)
{
std::cout << "Contents of the file:" <<
std::endl; if (remove(filename.c_str()) == 0) {
std::string line; std::cout << "File deleted successfully."
<< std::endl;
while (getline(file, line)) {
} else {
std::cout << line << std::endl;
std::cerr << "Failed to delete the file."
}
<< std::endl;
} else {
}
std::cerr << "Failed to open the file for
}
reading." << std::endl;
}
int main() {
file.close();
const std::string filename = "sample.txt";
}

createFile(filename);
// Function to write to a file
void writeFile(const std::string& filename,
const std::string& content) { writeFile(filename, "Hello, this is line
1.");
std::ofstream file(filename, std::ios::app);
 writeFile(filename, "And this is line 2."); if (file) {
file << content << std::endl;
readFile(filename); std::cout << "Content written to file
'" << name << "'." << std::endl;
} else {
deleteFile(filename);
std::cerr << "Failed to open the file
for writing." << std::endl;
return 0;
}
}
}

SIMPLE APPLICATION OF FILE

void readContent() const {
SYSTEM OPERATIONS TO FILE
DIRECTORY std::ifstream file(name);
if (file) {
#include <iostream> std::cout << "Contents of file '" <<
name << "':" << std::endl;
#include <fstream>
std::string line;
#include <string>
while (getline(file, line)) {
#include <vector>
std::cout << line << std::endl;
}
class File {
} else {
public:
std::cerr << "Failed to open the file
File(std::string name) : name(name) {}
for reading." << std::endl;
}
std::string getName() const {
}
return name;
}
void deleteFile() {
if (remove(name.c_str()) == 0) {
void writeContent(const std::string&
std::cout << "File '" << name << "'
content) {
deleted successfully." << std::endl;
std::ofstream file(name);
} else {
 std::cerr << "Failed to delete the std::vector<File> files;
file." << std::endl;
};
}
}
int main() {
SingleLevelDirectory directory;
private:
std::string name;
File file1("file1.txt");
};
file1.writeContent("Hello, this is line 1.");
directory.addFile(file1);
class SingleLevelDirectory {
public:
File file2("file2.txt");
void addFile(const File& file) {
file2.writeContent("And this is line 2.");
files.push_back(file);
directory.addFile(file2);
}

File file3("file3.txt");
void listFiles() const {
file3.writeContent("Content of file3.");
if (files.empty()) {
directory.addFile(file3);
std::cout << "No files in the
directory." << std::endl;
directory.listFiles();
} else {
std::cout << "Files in the directory:"
<< std::endl; file1.readContent();
for (const File& file : files) { file2.readContent();
std::cout << file.getName() << file3.readContent();
std::endl;
}
file1.deleteFile();
}
file2.deleteFile();
}
file3.deleteFile();

private:
 return 0;
}