📜  使用向量实现文件分配方法

📅  最后修改于: 2021-06-01 00:19:10             🧑  作者: Mango

先决条件:文件分配方法
不同的文件分配方法:

1.连续文件分配方法:

这是一种分配类型,其中文件占用给定内存的连续块。这种分配方式最快,因为我们可以访问文件的任何部分,只需将其添加到文件的起始索引即可。但是,当您必须插入一个其大小大于可用的最大空插槽的文件时,此分配没有用。

以下是在“首次分配”之后进行的“连续文件分配”的实现:

// C++ implementation of the Contiguous
// File Allocation which follow First-Fit
// algorithm
#include 
#include 
using namespace std;
  
// File Class
class File {
public:
    // Name of File
    string filename;
  
    // Size of file
    size_t size;
  
    // Partition no. is which part of
    // file is present at a particular
    // block of memory
    int partition;
};
class Block {
    // If Block is occupied
    // by a file or not
    bool occupied = false;
  
    // File of the block
    File file;
  
public:
    // This function will set file into
    // current block and set occupied flag
    void set_file(File file)
    {
        this->file = file;
        occupied = true;
    }
  
    // This function will return
    // filename of given block
    string get_file_name()
    {
        return file.filename;
    }
  
    // This function will return
    // partition number of file
    int get_file_partition_no()
    {
        return file.partition;
    }
  
    // This function will return
    // if the block is empty or not
    bool is_empty()
    {
        return !occupied;
    }
  
    // This function will set the occupied
    // flag as false meaning that it will
    // free the given block
    void set_empty()
    {
        occupied = false;
    }
};
  
// Function to return the number of
// empty Blocks from given memory
int get_empty_count(vector memory)
{
    int sum = 0;
    vector::iterator slot;
  
    // Count no. of empty blocks in
    // given memory
    for (slot = memory.begin();
         slot != memory.end(); slot++) {
        sum += (*slot).is_empty();
    }
  
    return sum;
}
  
// Function will return if the file
// exists in a given memory
bool file_exists(vector memory,
                 string name)
{
    vector::iterator slot;
  
    for (slot = memory.begin();
         slot != memory.end(); slot++) {
        if (!(*slot).is_empty()
            && (*slot).get_file_name() == name) {
            return true;
        }
    }
    return false;
}
  
// Function will set the file in the memory
// this will follow first fit allocation
void set_contiguous_memory(vector* memory,
                           vector* index,
                           File file)
{
    bool avail = false;
    int i = 0, count = 0, main_index;
    vector::iterator slot;
  
    // Check if the file already exists
    if (file_exists((*memory),
                    file.filename))
        cout << "File already exists"
             << endl;
  
    else {
  
        // Iterate through full memory
        for (slot = (*memory).begin();
             slot != (*memory).end(); slot++) {
  
            // Check if there are
            // contiguous Blocks available
            if ((*slot).is_empty()) {
                count++;
  
                // This if condition will note
                // the 1st index for each
                // Block empty
                if (count == 1)
                    main_index = i;
  
                // Check if contiguous
                // Blocks are available,
                // it will set our flag
                // avail as true and break
                if (count == file.size) {
                    avail = true;
                    break;
                }
            }
  
            // Else if there is even a
            // single non-empty block
            // in between we will set
            // count as 0
            else {
                count = 0;
            }
            i++;
        }
  
        // If our flag is set,
        // this condition will set
        // our file
        if (avail) {
  
            // Here starting index of
            // our given file will be
            // pushed in index page
            (*index).push_back(main_index);
  
            // Utilize count variable
            // again for setting file
            // partition
            count = 0;
            for (int i = main_index;
                 i < main_index + file.size;
                 i++) {
                file.partition = count;
                (*memory).at(i).set_file(file);
                count++;
            }
            cout << "File " << file.filename
                 << " has been successfully"
                 << " allocated"
                 << endl;
        }
        else {
            cout << "The size of the file is"
                 << " greater than"
                 << endl;
            cout << "the greatest slot available"
                 << " in contiguous memory"
                 << endl;
            cout << "Hence, File "
                 << file.filename
                 << " cannot be allocated"
                 << endl;
        }
    }
}
  
// Function to Delete file from memory
void delete_contiguous_mem(vector* memory,
                           vector* index_page,
                           string file)
{
    vector::iterator slot;
    int index, i = 0, main_index;
  
    // Check if the file exist or not
    if (!file_exists((*memory), file))
        cout << "File does not exist" << endl;
    else {
  
        // Iterate all the indexes
        for (slot = (*index_page).begin();
             slot != (*index_page).end(); slot++) {
  
            // If specified file is found,
            // this condition will
            // set the value of index no.
            // in index and
            // main_index will have starting
            // location of
            // file in memory
            if ((*memory).at(*slot).get_file_name()
                == file) {
                index = i;
                main_index = (*slot);
                break;
            }
            i++;
        }
  
        // Iterate through the main index until
        // filename is similar to specified
        // filename and status of Block is
        // not empty
        i = main_index;
  
        while (i < (*memory).size()
               && (*memory).at(i).get_file_name()
                      == file
               && !(*memory).at(i).is_empty()) {
            // Set the Block as empty
            (*memory).at(i).set_empty();
            i++;
        }
  
        // Erase entry of file from index page
        (*index_page).erase((*index_page).begin() + index);
        cout << "File " << file
             << " has been successfully deleted"
             << endl;
    }
}
  
// Function to display main index page
void show_contiguous_index(vector memory,
                           vector index_page)
{
    int max = 9, i, j;
  
    // Iterator
    vector::iterator slot;
  
    // File Name
    string fname;
  
    // Interate through all index pages
    for (i = 0; i < index_page.size();
         i++) {
  
        if (memory.at(index_page.at(i))
                .get_file_name()
                .length()
            > max) {
            // Get the length of file
            max = memory.at(index_page
                                .at(i))
                      .get_file_name()
                      .length();
  
            cout << "+" << string(max + 2, '-')
                 << "+---------------+----"
                 << "---------+-----------"
                 << "-------+\n|"
                 << string(max / 2
                               + max % 2 - 4,
                           ' ')
                 << "File Name"
                 << string(max / 2 - 3, ' ')
                 << "| Start Address | "
                 << " End Address | Size"
                 << " of the file |\n+"
                 << string(max + 2, '-')
                 << "+---------------+-------"
                 << "------+------------------+"
                 << endl;
        }
    }
  
    // Interate index_pages
    for (i = 0; i < index_page.size();
         i++) {
        cout << "|"
             << string(max / 2 + max % 2
                           - memory
                                     .at(index_page
                                             .at(i))
                                     .get_file_name()
                                     .length()
                                 / 2
                           - memory
                                     .at(index_page
                                             .at(i))
                                     .get_file_name()
                                     .length()
                                 % 2
                           + 1,
                       ' ')
             << memory.at(index_page.at(i))
                    .get_file_name()
             << string(max / 2
                           - memory
                                     .at(index_page
                                             .at(i))
                                     .get_file_name()
                                     .length()
                                 / 2
                           + 1,
                       ' ')
             << "|"
             << string(8
                           - to_string(index_page
                                           .at(i))
                                     .length()
                                 / 2
                           - to_string(index_page
                                           .at(i))
                                     .length()
                                 % 2,
                       ' ')
             << index_page.at(i)
             << string(7
                           - to_string(index_page
                                           .at(i))
                                     .length()
                                 / 2,
                       ' ')
             << "|";
        j = index_page
                .at(i);
        fname = memory
                    .at(j)
                    .get_file_name();
  
        // Till j is less than memory size
        while (j < memory.size()
               && !memory
                       .at(j)
                       .is_empty()
               && memory
                          .at(j)
                          .get_file_name()
                      == fname) {
            j++;
        }
        j -= 1;
  
        // Print the index pages details
        cout << string(7
                           - to_string(j)
                                     .length()
                                 / 2
                           - to_string(j)
                                     .length()
                                 % 2,
                       ' ')
             << j
             << string(6
                           - to_string(j)
                                     .length()
                                 / 2,
                       ' ')
             << "|"
             << string(9
                           - to_string(j
                                       - index_page
                                             .at(i)
                                       + 1)
                                     .length()
                                 / 2
                           - to_string(j
                                       - index_page
                                             .at(i)
                                       + 1)
                                     .length()
                                 % 2,
                       ' ')
             << j - index_page.at(i) + 1
             << string(9
                           - to_string(j
                                       - index_page
                                             .at(i)
                                       + 1)
                                     .length()
                                 / 2,
                       ' ')
             << "|"
             << endl;
    }
    cout << "+" << string(max + 2, '-')
         << "+---------------+------"
         << "-------+------------------+"
         << endl;
}
  
// Function to display index of each
// partition of specified file
void show_contiguous_indexes(vector memory,
                             vector index_page,
                             string filename)
{
    int index, i;
  
    // Iterator
    vector::iterator slot;
  
    // If file exist then display file
    // index and partition
    if (file_exists(memory, filename)) {
        cout << "File Name = " << filename
             << "\n+------------------+----"
             << "--------------+";
  
        cout << "\n| Current Location |"
             << " Partition Number |";
  
        cout << "\n+------------------+-"
             << " -----------------+\n";
  
        // Iterate through all the index
        for (slot = index_page.begin();
             slot != index_page.end(); slot++) {
            if (memory.at(*slot).get_file_name()
                == filename) {
                index = (*slot);
                break;
            }
        }
  
        // Loop till memory size is greater than
        // index and file is allocated
        // in them
        while (index < memory.size()
               && memory
                          .at(index)
                          .get_file_name()
                      == filename
               && !memory
                       .at(index)
                       .is_empty()) {
            cout << "|"
                 << string(9
                               - to_string(index)
                                         .length()
                                     / 2
                               - to_string(index)
                                         .length()
                                     % 2,
                           ' ')
                 << index
                 << string(9
                               - to_string(index)
                                         .length()
                                     / 2,
                           ' ')
                 << "|"
  
                 << string(9
                               - to_string(memory
                                               .at(index)
                                               .get
                                                   _file
                                                       _partition
                                                           _no())
                                         .length()
                                     / 2
                               - to_string(memory
                                               .at(index)
                                               .get_file
                                                   _partition
                                                       _no())
                                         .length()
                                     % 2,
                           ' ')
  
                 << memory
                        .at(index)
                        .get_file_partition_no()
  
                 << string(9
                               - to_string(memory
                                               .at(index)
                                               .get_file_partition_no())
                                         .length()
                                     / 2,
                           ' ')
                 << "|"
                 << endl;
            index++;
        }
        cout << "+------------------+"
             << "------------------+"
             << endl;
    }
    else
        cout << "File does not exist "
             << "in given memory"
             << endl;
}
  
// Driver Code
int main()
{
    // Declare memory of size 16 Blocks
    vector memory(16);
  
    // Declare index page
    vector index_page;
    File temp;
  
    cout << "Remaining memory :- "
         << get_empty_count(memory)
         << endl;
  
    // Set the data
    temp.filename = "home.txt";
    temp.size = 5;
    set_contiguous_memory(&memory,
                          &index_page,
                          temp);
  
    temp.filename = "Report.docx";
    temp.size = 6;
    set_contiguous_memory(&memory,
                          &index_page,
                          temp);
  
    temp.filename = "new_img.png";
    temp.size = 3;
    set_contiguous_memory(&memory,
                          &index_page,
                          temp);
  
    temp.filename = "test.cpp";
    temp.size = 2;
    set_contiguous_memory(&memory,
                          &index_page,
                          temp);
  
    cout << "Remaining memory :- "
         << get_empty_count(memory)
         << endl;
  
    // Function call to show all the
    // memory allocation
    show_contiguous_index(memory,
                          index_page);
  
    cout << "Now we will check each partition of";
    cout << " Report.docx and test.cpp before"
         << endl;
  
    cout << "deleting them to see"
         << " which locations ";
  
    cout << "are going to be set free"
         << " as our slots"
         << endl;
  
    // Function call to show all the
    // memory allocation
    show_contiguous_indexes(memory,
                            index_page,
                            "Report.docx");
  
    // Function call to show all the
    // memory allocation
    show_contiguous_indexes(memory,
                            index_page,
                            "test.cpp");
  
    // Now delete Report.docx & test.cpp
  
    delete_contiguous_mem(&memory,
                          &index_page,
                          "Report.docx");
  
    delete_contiguous_mem(&memory,
                          &index_page,
                          "test.cpp");
  
    cout << "Remaining memory :- "
         << get_empty_count(memory)
         << endl;
    // Function call to show all the
    // memory allocation
    show_contiguous_index(memory,
                          index_page);
  
    // Creating hello.jpeg file now
    // and setting it to memory
    temp.filename = "hello.jpeg";
    temp.size = 8;
    set_contiguous_memory(&memory,
                          &index_page,
                          temp);
  
    cout << "Check index page: " << endl;
  
    // Function call to show all the
    // memory allocation
    show_contiguous_index(memory,
                          index_page);
}
输出:
Remaining memory :- 16
File home.txt has been successfully allocated
File Report.docx has been successfully allocated
File new_img.png has been successfully allocated
File test.cpp has been successfully allocated
Remaining memory :- 0
+-------------+---------------+-------------+------------------+
|  File Name  | Start Address | End Address | Size of the file |
+-------------+---------------+-------------+------------------+
|   home.txt  |       0       |      4      |        5         |
| Report.docx |       5       |      10     |        6         |
| new_img.png |       11      |      13     |        3         |
|   test.cpp  |       14      |      15     |        2         |
+-------------+---------------+-------------+------------------+
Now we will check each partition of Report.docx and test.cpp before
deleting them to see which locations are going to be set free as our slots
File Name = Report.docx
+------------------+------------------+
| Current Location | Partition Number |
+------------------+------------------+
|        5         |        0         |
|        6         |        1         |
|        7         |        2         |
|        8         |        3         |
|        9         |        4         |
|        10        |        5         |
+------------------+------------------+
File Name = test.cpp
+------------------+------------------+
| Current Location | Partition Number |
+------------------+------------------+
|        14        |        0         |
|        15        |        1         |
+------------------+------------------+
File Report.docx has been successfully deleted
File test.cpp has been successfully deleted
Remaining memory:- 8
+-------------+---------------+-------------+------------------+
|  File Name  | Start Address | End Address | Size of the file |
+-------------+---------------+-------------+------------------+
|   home.txt  |       0       |      4      |        5         |
| new_img.png |       11      |      13     |        3         |
+-------------+---------------+-------------+------------------+
The size of the file is greater than
the greatest slot available in contiguous memory
Hence, File hello.jpeg cannot be allocated
Check index page: 
+-------------+---------------+-------------+------------------+
|  File Name  | Start Address | End Address | Size of the file |
+-------------+---------------+-------------+------------------+
|   home.txt  |       0       |      4      |        5         |
| new_img.png |       11      |      13     |        3         |
+-------------+---------------+-------------+------------------+

2.索引文件分配方法

这是一种分配类型,其中我们有2个索引页,一个是所有文件的主索引页,另一个是到特定文件的子索引页。这种类型的分配不需要连续的内存插槽,因为我们分别跟踪每个块。在下面的给定程序中,向量的向量用于实现主索引和子索引。

以下是索引文件分配方法的实现

// C++ implementation of the Indexed
// File Allocation Method
#include 
#include 
using namespace std;
  
// File Class
class File {
public:
    // Name of File
    string filename;
  
    // Size of file
    size_t size;
  
    // Partition no. is which part of
    // file is present at a particular
    // block of memory
    int partition;
};
  
// Block class
class Block {
    // If Block is occupied
    // by a file or not
    bool occupied = false;
  
    // File of the block
    File file;
  
public:
    // This function will set file
    // into current block
    // and set occupied flag
    void set_file(File file)
    {
        this->file = file;
        occupied = true;
    }
  
    // This function will return
    // filename of given block
    string get_file_name()
    {
        return file.filename;
    }
  
    // This function will return
    // partition number of file
    int get_file_partition_no()
    {
        return file.partition;
    }
  
    // This function will return
    // if the block is empty or not
    bool is_empty()
    {
        return !occupied;
    }
  
    // This function will set the
    // occupied flag as false
    // meaning that it will free
    // the given block
    void set_empty()
    {
        occupied = false;
    }
};
  
// Function to return the number of
// empty Blocks from given memory
int get_empty_count(vector memory)
{
    int sum = 0;
    vector::iterator slot;
  
    // count no. of empty blocks in
    // given memory
    for (slot = memory.begin();
         slot != memory.end(); slot++)
        sum += (*slot).is_empty();
    return sum;
}
  
// This function will generate random indexes
// from empty memory slots to test indexing
int generate_index(vector memory)
{
    int index = -1;
  
    // Check if memory is full
    if (!get_empty_count(memory) == 0) {
  
        // Here it will generate index until
        // the memory block at generated
        // index is found to be empty
        do {
            index = rand() % memory.size();
            index = abs(index);
  
        } while (!memory.at(index).is_empty());
    }
    return index;
}
  
// This function will return if the file
// exists in a given memory
bool file_exists(vector memory,
                 string name)
{
    vector::iterator slot;
  
    for (slot = memory.begin();
         slot != memory.end(); slot++) {
        if (!(*slot).is_empty()
            && (*slot).get_file_name() == name) {
            return true;
        }
    }
  
    return false;
}
  
// This function will set file in
// memory and push index for each partition
// and then push the file index to main
// index vector
void set_indexed_memory(vector* memory,
                        vector >* index_page,
                        File file)
{
    int index;
  
    // Declaration newpage to set the
    // index page for given file
    vector newpage;
  
    // Check if file exists
    if (file_exists((*memory), file.filename))
        cout << "File already exists" << endl;
    else {
        // Check if available memory is greater than
        // size of given file
        if (get_empty_count(*memory) >= file.size) {
  
            // Iterate till file size
            for (int i = 0; i < file.size; i++) {
  
                // Generate random empty index
                index = generate_index(*memory);
  
                // Set file partition
                file.partition = i;
  
                // Push the file to memory
                (*memory).at(index).set_file(file);
  
                // Push the index to newpage
                newpage.push_back(index);
            }
  
            // Push new index page into main
            // index page
            (*index_page).push_back(newpage);
            cout << "File " << file.filename
                 << " has been successfully allocated"
                 << endl;
        }
        else {
            cout << "Not enough available space"
                 << endl;
        }
    }
}
  
// Function to delete a file from given
// indexed memory
void delete_from_indexed_memory(vector* memory,
                                vector >* index_page,
                                string file)
{
    vector::iterator slot;
    vector >::iterator it;
    int index, i = 0;
  
    // Check if file exists
    if (file_exists((*memory), file)) {
        // Iterate main index
        for (it = (*index_page).begin();
             it != (*index_page).end(); it++) {
            // Check for sub-index at
            // start location
            slot = (*it).begin();
  
            // Check if it equals filename
            if ((*memory)
                    .at(*slot)
                    .get_file_name()
                == file) {
                // Set for index and break
                index = i;
                break;
            }
            i++;
        }
  
        // Set the memory flag as empty
        for (slot = (*index_page).at(index).begin();
             slot != (*index_page).at(index).end();
             slot++)
            (*memory).at(*slot).set_empty();
  
        // Erase file index from main index page
        (*index_page)
            .erase((*index_page).begin() + index);
        cout << "File " << file
             << " has been successfully deleted"
             << endl;
    }
    else {
        cout << "File does not exist"
             << endl;
    }
}
  
// Function to display the main index
void show_indexed_index(vector memory,
                        vector > index_page)
{
    int max = 9;
    vector::iterator slot;
    vector >::iterator it;
  
    // Iterate over index pages
    for (it = index_page.begin();
         it != index_page.end(); it++) {
        if (memory
                .at((*it)
                        .at(0))
                .get_file_name()
                .length()
            > max) {
            max = memory
                      .at((*it)
                              .at(0))
                      .get_file_name()
                      .length();
            cout << "+" << string(max + 2, '-')
                 << "+---------------+----------"
                 << "---+------------------+\n|"
                 << string(max / 2 + max % 2 - 4, ' ')
                 << "File Name"
                 << string(max / 2 - 3, ' ')
                 << "| Start Address | End Address"
                 << " | Size of the file |\n+"
                 << string(max + 2, '-')
                 << "+---------------+------"
                 << "-------+------------------+"
                 << endl;
        }
    }
  
    // Iterate through all the index pages
    for (it = index_page.begin();
         it != index_page.end(); it++) {
        cout << "|"
             << string(max / 2
                           + max % 2
                           - memory
                                     .at((*it)
                                             .at(0))
                                     .get_file_name()
                                     .length()
                                 / 2
                           - memory
                                     .at((*it)
                                             .at(0))
                                     .get_file_name()
                                     .length()
                                 % 2
                           + 1,
                       ' ')
             << memory
                    .at((*it)
                            .at(0))
                    .get_file_name()
             << string(max / 2
                           - memory
                                     .at((*it)
                                             .at(0))
                                     .get_file_name()
                                     .length()
                                 / 2
                           + 1,
                       ' ')
             << "|"
             << string(8
                           - to_string((*it)
                                           .at(0))
                                     .length()
                                 / 2
                           - to_string((*it)
                                           .at(0))
                                     .length()
                                 % 2,
                       ' ')
             << ((*it).at(0))
             << string(7
                           - to_string((*it)
                                           .at(0))
                                     .length()
                                 / 2,
                       ' ')
             << "|"
             << string(7
                           - to_string((*it)
                                           .at((*it)
                                                   .size()
                                               - 1))
                                     .length()
                                 / 2
                           - to_string((*it)
                                           .at((*it)
                                                   .size()
                                               - 1))
                                     .length()
                                 % 2,
                       ' ')
             << (*it)
                    .at((*it).size() - 1)
             << string(6
                           - to_string((*it)
                                           .at((*it)
                                                   .size()
                                               - 1))
                                     .length()
                                 / 2,
                       ' ')
             << "|"
             << string(9
                           - to_string((*it)
                                           .size())
                                     .length()
                                 / 2
                           - to_string((*it)
                                           .size())
                                     .length()
                                 % 2,
                       ' ')
             << (*it).size()
             << string(9
                           - to_string((*it)
                                           .size())
                                     .length()
                                 / 2,
                       ' ')
             << "|" << endl;
        cout << "+" << string(max + 2, '-')
             << "+---------------+----------"
             << "---+------------------+"
             << endl;
    }
}
  
// Function to show each partition details
// w.r.t filename
void show_indexed_indexes(vector memory,
                          vector > index_page,
                          string filename)
{
    int index, i = 0, main_index;
    vector >::iterator slot;
  
    // Check if file exists
    if (file_exists(memory, filename)) {
        for (slot = index_page.begin();
             slot != index_page.end(); slot++) {
            if (memory.at((*slot).at(0)).get_file_name()
                == filename) {
                main_index = i;
                break;
            }
            i++;
        }
  
        // Display File Details
        cout << "File Name = " << filename << endl;
        cout << "File page index at main index :- "
             << main_index
             << "\n+------------------+------------------+\n";
        cout << "| Current Location | Partition Number |\n";
        cout << "+------------------+------------------+\n";
        for (i = 0;
             i < index_page.at(main_index).size();
             i++) {
            index = index_page
                        .at(main_index)
                        .at(i);
            cout << "|" << string(9
                                      - to_string(index)
                                                .length()
                                            / 2
                                      - to_string(index)
                                                .length()
                                            % 2,
                                  ' ')
                 << index
                 << string(9
                               - to_string(index)
                                         .length()
                                     / 2,
                           ' ')
                 << "|" << string(9
                                      - to_string(memory
                                                      .at(index)
                                                      .get_file_partition_no())
                                                .length()
                                            / 2
                                      - to_string(memory
                                                      .at(index)
                                                      .get_file_partition_no())
                                                .length()
                                            % 2,
                                  ' ')
                 << memory
                        .at(index)
                        .get_file_partition_no()
                 << string(9
                               - to_string(memory
                                               .at(index)
                                               .get_file_partition_no())
                                         .length()
                                     / 2,
                           ' ')
                 << "|" << endl;
        }
  
        cout << "+------------------+----"
             << "--------------+" << endl;
    }
    else {
        cout << "File does not exist"
             << endl;
    }
}
  
// Driver Code
int main()
{
    // Declare memory of size 16 Blocks
    vector memory(16);
  
    // Declare index page
    vector > index_page;
  
    File temp;
    cout << "Remaining memory :- "
         << get_empty_count(memory)
         << endl;
  
    // Set the data
    temp.filename = "home.txt";
    temp.size = 5;
    set_indexed_memory(&memory,
                       &index_page,
                       temp);
  
    temp.filename = "Report.docx";
    temp.size = 6;
    set_indexed_memory(&memory,
                       &index_page,
                       temp);
  
    temp.filename = "new_img.png";
    temp.size = 3;
    set_indexed_memory(&memory,
                       &index_page,
                       temp);
  
    temp.filename = "test.cpp";
    temp.size = 2;
    set_indexed_memory(&memory,
                       &index_page,
                       temp);
  
    // Print the Remaining memory
    cout << "Remaining memory :- "
         << get_empty_count(memory)
         << endl;
  
    // Print all the index memory
    show_indexed_index(memory, index_page);
    cout << "Now we will check each partition"
         << " for Report.docx and test.cpp"
         << " before deleting them" << endl;
  
    // Print all the index memory
    show_indexed_indexes(memory, index_page,
                         "Report.docx");
  
    // Print all the index memory
    show_indexed_indexes(memory, index_page,
                         "test.cpp");
  
    // Now delete Report.docx and test.cpp
    delete_from_indexed_memory(&memory,
                               &index_page,
                               "Report.docx");
  
    delete_from_indexed_memory(&memory,
                               &index_page,
                               "test.cpp");
  
    cout << "Remaining memory :- "
         << get_empty_count(memory)
         << endl;
  
    // Print all the index memory
    show_indexed_index(memory, index_page);
  
    // Creating hello.jpeg file now
    // and setting it to memory
    temp.filename = "hello.jpeg";
    temp.size = 8;
  
    set_indexed_memory(&memory,
                       &index_page,
                       temp);
    cout << "Check index page :- "
         << endl;
  
    // Print all the index memory
    show_indexed_index(memory, index_page);
  
    // Now we will see index for each partition of
    // hello.jpeg
    cout << "Remaining memory :- "
         << get_empty_count(memory)
         << endl;
    cout << "We will check each partition"
         << " for hello.jpeg to see ";
    cout << "if the locations of deleted files"
         << " are utilized or not" << endl;
  
    // Print all the index memory
    show_indexed_indexes(memory, index_page,
                         "hello.jpeg");
    memory.clear();
    memory.shrink_to_fit();
    index_page.clear();
    index_page.shrink_to_fit();
    return 0;
}
输出:
Remaining memory :- 16
File home.txt has been successfully allocated
File Report.docx has been successfully allocated
File new_img.png has been successfully allocated
File test.cpp has been successfully allocated
Remaining memory :- 0
+-------------+---------------+-------------+------------------+
|  File Name  | Start Address | End Address | Size of the file |
+-------------+---------------+-------------+------------------+
|   home.txt  |       7       |      1      |        5         |
+-------------+---------------+-------------+------------------+
| Report.docx |       15      |      2      |        6         |
+-------------+---------------+-------------+------------------+
| new_img.png |       4       |      14     |        3         |
+-------------+---------------+-------------+------------------+
|   test.cpp  |       5       |      0      |        2         |
+-------------+---------------+-------------+------------------+
Now we will check each partition for Report.docx and test.cpp before deleting them
File Name = Report.docx
File page index at main index :- 1
+------------------+------------------+
| Current Location | Partition Number |
+------------------+------------------+
|        15        |        0         |
|        10        |        1         |
|        12        |        2         |
|        13        |        3         |
|        11        |        4         |
|        2         |        5         |
+------------------+------------------+
File Name = test.cpp
File page index at main index :- 3
+------------------+------------------+
| Current Location | Partition Number |
+------------------+------------------+
|        5         |        0         |
|        0         |        1         |
+------------------+------------------+
File Report.docx has been successfully deleted
File test.cpp has been successfully deleted
Remaining memory :- 8
+-------------+---------------+-------------+------------------+
|  File Name  | Start Address | End Address | Size of the file |
+-------------+---------------+-------------+------------------+
|   home.txt  |       7       |      1      |        5         |
+-------------+---------------+-------------+------------------+
| new_img.png |       4       |      14     |        3         |
+-------------+---------------+-------------+------------------+
File hello.jpeg has been successfully allocated
Check index page :- 
+-------------+---------------+-------------+------------------+
|  File Name  | Start Address | End Address | Size of the file |
+-------------+---------------+-------------+------------------+
|   home.txt  |       7       |      1      |        5         |
+-------------+---------------+-------------+------------------+
| new_img.png |       4       |      14     |        3         |
+-------------+---------------+-------------+------------------+
|  hello.jpeg |       12      |      13     |        8         |
+-------------+---------------+-------------+------------------+
Remaining memory :- 0
We will check each partition for hello.jpeg to see if the locations of deleted files are utilized or not
File Name = hello.jpeg
File page index at main index :- 2
+------------------+------------------+
| Current Location | Partition Number |
+------------------+------------------+
|        12        |        0         |
|        10        |        1         |
|        11        |        2         |
|        15        |        3         |
|        0         |        4         |
|        2         |        5         |
|        5         |        6         |
|        13        |        7         |
+------------------+------------------+

3.链接文件分配方法

这是一种分配类型,其中我们链接了文件的所有分区,以指向文件的下一个分区所在的内存位置。在下面的给定程序中,当到达最后一个分区时,next将被分配为-1。

下面是链接文件分配方法的实现

// C++ implementation of the Linked
// File Allocation Method
#include 
#include 
using namespace std;
  
// File Class
class File {
public:
    // Name of File
    string filename;
    // Size of file
    size_t size;
  
    // Partition no is which part of
    // file is present at a particular
    // block of memory
    int partition;
};
  
// Block Class
class Block {
    // If Block is occupied
    // by a file or not
    bool occupied = false;
  
    // File of the block
    File file;
  
    // Location of next partition in given memory
    // By default, it is set to -1
    // which indicates there is no next partition
    int next = -1;
  
public:
    // This will set file into current block
    // and set occupied flag
    void set_file(File file)
    {
        this->file = file;
        occupied = true;
    }
  
    // This will return filename of given block
    string get_file_name()
    {
        return file.filename;
    }
    // Return partition number of file
    int get_file_partition_no()
    {
        return file.partition;
    }
  
    // Return if the block is empty or not
    bool is_empty()
    {
        return !occupied;
    }
  
    // This will set the occupied flag as false
    // meaning that it will free the memory
    void set_empty()
    {
        occupied = false;
    }
  
    // This function will set location of next
    // partition in given memory
    void set_next(int next)
    {
        this->next = next;
    }
  
    // This function will return location
    // of next partition
    int get_next()
    {
        return next;
    }
};
  
// Function to return the number of
// empty Blocks from given memory
int get_empty_count(vector memory)
{
    int sum = 0;
    vector::iterator slot;
  
    // Count no. of empty blocks in given memory
    for (slot = memory.begin();
         slot != memory.end(); slot++)
        sum += (*slot).is_empty();
  
    // Return the empty count
    return sum;
}
  
// Function to generate random indexes
// from empty memory slots to test indexing
int generate_index(vector memory)
{
    int index = -1;
  
    // Check if memory is full
    if (!get_empty_count(memory) == 0) {
        // Here it will generate index until
        // the memory block at generated
        // index is found to be empty
        do {
            index = rand() % memory.size();
            index = abs(index);
        } while (!memory.at(index).is_empty());
    }
    return index;
}
  
// This function will return if the file
// exists in a given memory
bool file_exists(vector memory,
                 string name)
{
    vector::iterator slot;
  
    for (slot = memory.begin();
         slot != memory.end(); slot++)
        if (!(*slot).is_empty()
            && (*slot).get_file_name()
                   == name)
            return true;
  
    return false;
}
  
// This function will set the file in memory
void set_linked_memory(vector* memory,
                       vector* index_page,
                       File file)
{
    int index = -1, prev = -1, i = 0;
  
    // Check if file exists already
    if (!file_exists((*memory), file.filename)) {
  
        // Check if memory is available
        // according to file size
        if (get_empty_count(*memory) >= file.size) {
  
            // Generate empty index
            index = generate_index(*memory);
  
            // Push 1st index to index page
            (*index_page).push_back(index);
            for (i = 0; i < file.size - 1; i++) {
                // Set partition
                file.partition = i;
  
                // Set file into memory
                (*memory).at(index).set_file(file);
  
                // Note down prev index before
                // generating next index
                prev = index;
  
                // Generate empty index
                index = generate_index(*memory);
  
                // Set the next location to generated
                // index in previous index
                (*memory).at(prev).set_next(index);
            }
  
            // Set last partition and file
            file.partition = file.size - 1;
            (*memory).at(index).set_file(file);
  
            cout << "File " << file.filename
                 << " has been successfully allocated"
                 << endl;
        }
        else
            cout << "Not enough available memory"
                 << endl;
    }
    else
        cout << "File already exists in given memory"
             << endl;
}
  
// Function will delete the file from
// memory specified by name
void delete_from_linked_memory(vector* memory,
                               vector* index_page,
                               string file)
{
    int index, next, previous, main_index, i = 0;
    vector::iterator slot;
  
    // Check if file exists
    if (file_exists((*memory), file)) {
  
        // Iterate through the index page
        // to find 1st partition
        for (slot = (*index_page).begin();
             slot != (*index_page).end();
             slot++) {
  
            // Check if file stored at index has
            // the same name we wish to delete
            if ((*memory)
                    .at(*slot)
                    .get_file_name()
                == file) {
                // Main index is w.r.t memory location
                main_index = (*slot);
  
                // index is w.r.t index page
                // entry location
                index = i;
                break;
            }
            i++;
        }
  
        // 1st partition
        i = main_index;
  
        // Check while next location comes as -1
        while (i != -1
               && (*memory)
                          .at(i)
                          .get_file_name()
                      == file) {
  
            // set the Block free
            (*memory).at(i).set_empty();
  
            // Note the location into previous
            previous = i;
  
            // get the next location
            i = (*memory).at(i).get_next();
  
            // set -1 as next location into
            // previous location
            (*memory).at(previous).set_next(-1);
        }
  
        // Erase the entry of file from index
        // page as well
        (*index_page)
            .erase((*index_page)
                       .begin()
                   + index);
        cout << "File " << file
             << " has been successfully deleted"
             << endl;
    }
    else {
        cout << "File does not exist in given memory"
             << endl;
    }
}
  
// Function to display main index page
void show_linked_index(vector memory,
                       vector index)
{
    int max = 9, i, count;
  
    // Iterator
    vector::iterator slot;
  
    // File Name
    string fname;
  
    // Iterate through all index pages
    for (slot = index.begin();
         slot != index.end(); slot++) {
  
        if (memory
                .at(*slot)
                .get_file_name()
                .length()
            > max) {
            max = memory
                      .at(*slot)
                      .get_file_name()
                      .length();
            cout << "+" << string(max + 2, '-')
                 << "+---------------+---------"
                 << "----+------------------+";
            cout << "\n|"
                 << string(max / 2 + max % 2 - 4,
                           ' ')
                 << "File Name"
                 << string(max / 2 - 3, ' ');
            cout << "| Start Address | End Address"
                 << " | Size of the file |\n+"
                 << string(max + 2, '-');
            cout << "+---------------+--------"
                 << "-----+------------------+"
                 << endl;
        }
    }
  
    // Iterate through index
    for (slot = index.begin();
         slot != index.end();
         slot++) {
  
        i = (*slot);
        fname = memory
                    .at(i)
                    .get_file_name();
        count = 1;
        while (memory.at(i).get_next() != -1
               && memory
                          .at(i)
                          .get_file_name()
                      == fname) {
            i = memory.at(i).get_next();
            count++;
        }
  
        cout << "|" << string(max / 2 + max % 2
                                  - memory
                                            .at(*slot)
                                            .get_file_name()
                                            .length()
                                        / 2
                                  - memory
                                            .at(*slot)
                                            .get_file_name()
                                            .length()
                                        % 2
                                  + 1,
                              ' ')
             << memory
                    .at(*slot)
                    .get_file_name()
             << string(max / 2 - memory.at(*slot).get_file_name().length() / 2 + 1,
                       ' ')
             << "|"
             << string(8
                           - to_string(*slot)
                                     .length()
                                 / 2
                           - to_string(*slot)
                                     .length()
                                 % 2,
                       ' ')
             << (*slot)
             << string(7
                           - to_string(*slot)
                                     .length()
                                 / 2,
                       ' ')
             << "|"
             << string(7
                           - to_string(i)
                                     .length()
                                 / 2
                           - to_string(i)
                                     .length()
                                 % 2,
                       ' ')
             << i
             << string(6
                           - to_string(i)
                                     .length()
                                 / 2,
                       ' ')
             << "|"
             << string(9
                           - to_string(count)
                                     .length()
                                 / 2
                           - to_string(count)
                                     .length()
                                 % 2,
                       ' ')
             << count
             << string(9
                           - to_string(count)
                                     .length()
                                 / 2,
                       ' ')
             << "|" << endl;
    }
  
    cout << "+" << string(max + 2, '-')
         << "+---------------+----------"
         << "---+------------------+"
         << endl;
}
  
// Function to check all the partitions of file
// w.r.t filename specified
void show_linked_indexes(vector memory, vector index_page,
                         string filename)
{
    int index;
    vector::iterator slot;
  
    // If file exists
    if (file_exists(memory, filename)) {
        cout << "File Name = " << filename;
        cout << "\n+------------------+----------"
             << "--------+------------------+";
        cout << "\n| Current Location |Next part"
             << " Location| Partition Number |";
        cout << "\n+------------------+----------"
             << "--------+------------------+\n";
  
        // Iterate through all index
        for (slot = index_page.begin();
             slot != index_page.end(); slot++) {
            if (memory
                    .at(*slot)
                    .get_file_name()
                == filename) {
                index = (*slot);
                break;
            }
        }
  
        // Loop till index is not -1
        while (index != -1) {
            cout << "|"
                 << string(9
                               - to_string(index)
                                         .length()
                                     / 2
                               - to_string(index)
                                         .length()
                                     % 2,
                           ' ')
                 << index
                 << string(9
                               - to_string(index)
                                         .length()
                                     / 2,
                           ' ')
                 << "|"
                 << string(9
                               - to_string(memory
                                               .at(index)
                                               .get_next())
                                         .length()
                                     / 2
                               - to_string(memory
                                               .at(index)
                                               .get_next())
                                         .length()
                                     % 2,
                           ' ')
                 << memory
                        .at(index)
                        .get_next()
                 << string(9
                               - to_string(memory
                                               .at(index)
                                               .get_next())
                                         .length()
                                     / 2,
                           ' ')
                 << "|"
                 << string(9
                               - to_string(memory
                                               .at(index)
                                               .get_file_partition_no())
                                         .length()
                                     / 2
                               - to_string(memory
                                               .at(index)
                                               .get_file_partition_no())
                                         .length()
                                     % 2,
                           ' ')
                 << memory
                        .at(index)
                        .get_file_partition_no()
                 << string(9
                               - to_string(memory
                                               .at(index)
                                               .get_file_partition_no())
                                         .length()
                                     / 2,
                           ' ')
                 << "|" << endl;
            index = memory
                        .at(index)
                        .get_next();
        }
  
        cout << "+------------------+---------"
             << "---------+------------------+"
             << endl;
    }
    else {
        cout << "Given file does not exist"
             << " in given memory"
             << endl;
    }
}
  
// Driver Code
int main()
{
  
    // Declare memory of size 16 Blocks
    vector memory(16);
  
    // Declare index page
    vector index_page;
    File temp;
    cout << "Remaining memory :- "
         << get_empty_count(memory) << endl;
  
    // Set the data
    temp.filename = "home.txt";
    temp.size = 5;
    set_linked_memory(&memory,
                      &index_page,
                      temp);
  
    temp.filename = "Report.docx";
    temp.size = 6;
    set_linked_memory(&memory,
                      &index_page,
                      temp);
  
    temp.filename = "new_img.png";
    temp.size = 3;
    set_linked_memory(&memory,
                      &index_page,
                      temp);
  
    temp.filename = "test.cpp";
    temp.size = 2;
    set_linked_memory(&memory,
                      &index_page
                          temp);
  
    cout << "Files have been successfully set"
         << endl;
    cout << "Remaining memory :- "
         << get_empty_count(memory) << endl;
  
    // Print all the linked index
    show_linked_index(memory, index_page);
    cout << "Now we will check index"
         << " of each partition of ";
    cout << "Report.docx and test.cpp"
         << " before deleting them"
         << endl;
  
    // Print all the linked index
    show_linked_indexes(memory, index_page,
                        "Report.docx");
  
    // Print all the linked index
    show_linked_indexes(memory, index_page,
                        "test.cpp");
  
    // Now delete Report.docx and test.cpp
    delete_from_linked_memory(&memory,
                              &index_page,
                              "Report.docx");
    delete_from_linked_memory(&memory,
                              &index_page,
                              "test.cpp");
    cout << "Remaining memory :- "
         << get_empty_count(memory) << endl;
  
    // Print all the linked index
    show_linked_index(memory, index_page);
  
    // Creating hello.jpeg file now
    // and setting it to memory
    temp.filename = "hello.jpeg";
    temp.size = 8;
  
    // Set Linked memory
    set_linked_memory(&memory,
                      &index_page,
                      temp);
    cout << "Check index page :- "
         << endl;
  
    // Print all the linked index
    show_linked_index(memory, index_page);
  
    // Now we will see index for each partition
    // of hello.jpeg
    cout << "Remaining memory :- "
         << get_empty_count(memory) << endl;
    cout << "We will check each partition for"
         << " hello.jpeg ";
    cout << "to see if deleted locations are"
         << " utilized or not"
         << endl;
  
    // Print all the linked index
    show_linked_indexes(memory,
                        index_page,
                        "hello.jpeg");
    memory.clear();
    memory.shrink_to_fit();
    index_page.clear();
    index_page.shrink_to_fit();
  
    return 0;
}
输出:
Remaining memory :- 16
File home.txt has been successfully allocated
File Report.docx has been successfully allocated
File new_img.png has been successfully allocated
File test.cpp has been successfully allocated
Files have been successfully set
Remaining memory :- 0
+-------------+---------------+-------------+------------------+
|  File Name  | Start Address | End Address | Size of the file |
+-------------+---------------+-------------+------------------+
|   home.txt  |       7       |      1      |        5         |
| Report.docx |       15      |      2      |        6         |
| new_img.png |       4       |      14     |        3         |
|   test.cpp  |       5       |      0      |        2         |
+-------------+---------------+-------------+------------------+
Now we will check index of each partition of Report.docx and test.cpp before deleting them
File Name = Report.docx
+------------------+------------------+------------------+
| Current Location |Next part Location| Partition Number |
+------------------+------------------+------------------+
|        15        |        10        |        0         |
|        10        |        12        |        1         |
|        12        |        13        |        2         |
|        13        |        11        |        3         |
|        11        |        2         |        4         |
|        2         |        -1        |        5         |
+------------------+------------------+------------------+
File Name = test.cpp
+------------------+------------------+------------------+
| Current Location |Next part Location| Partition Number |
+------------------+------------------+------------------+
|        5         |        0         |        0         |
|        0         |        -1        |        1         |
+------------------+------------------+------------------+
File Report.docx has been successfully deleted
File test.cpp has been successfully deleted
Remaining memory :- 8
+-------------+---------------+-------------+------------------+
|  File Name  | Start Address | End Address | Size of the file |
+-------------+---------------+-------------+------------------+
|   home.txt  |       7       |      1      |        5         |
| new_img.png |       4       |      14     |        3         |
+-------------+---------------+-------------+------------------+
File hello.jpeg has been successfully allocated
Check index page :- 
+-------------+---------------+-------------+------------------+
|  File Name  | Start Address | End Address | Size of the file |
+-------------+---------------+-------------+------------------+
|   home.txt  |       7       |      1      |        5         |
| new_img.png |       4       |      14     |        3         |
|  hello.jpeg |       12      |      13     |        8         |
+-------------+---------------+-------------+------------------+
Remaining memory :- 0
We will check each partition for hello.jpeg to see if deleted locations are utilized or not
File Name = hello.jpeg
+------------------+------------------+------------------+
| Current Location |Next part Location| Partition Number |
+------------------+------------------+------------------+
|        12        |        10        |        0         |
|        10        |        11        |        1         |
|        11        |        15        |        2         |
|        15        |        0         |        3         |
|        0         |        2         |        4         |
|        2         |        5         |        5         |
|        5         |        13        |        6         |
|        13        |        -1        |        7         |
+------------------+------------------+------------------+
想要从精选的最佳视频中学习并解决问题,请查看有关从基础到高级C++的C++基础课程以及有关语言和STL的C++ STL课程。要完成从学习语言到DS Algo等的更多准备工作,请参阅“完整面试准备课程”