如何使用 ofstream C++ 替換文本文件中的特定值？

Question

嗨，我正在使用自動售貨機，我想通過更新文本文件來更新商品的數量。 我一直在嘗試使用 ofstream 和 ifstream 但不起作用。

這是我的文本文件。

Water:1:1.99:D1
Coke:4:2.79:D2
Milk:6:3.15:D3
Ham Sandwitch:9:4.50:L1
Lunchables:3:6.00:L2
Cereal:2:3.59:L3
M&M:8:1.75:C1
SourPatch:0:2.10:C2
Twix:6:2.99:C3

這是自動售貨機檢查用戶輸入以及我想更新文件的地方

void vendingWorking(Item &item) {

if(item.quantity == 0) {
  cout << endl;
  cout << "------------------------------------" << "\n";
  cout << "" << item.name << " (OutStock)" << endl;
  cout << "------------------------------------" << "\n";
} 
else {  
  //Check if itemCode is same as product ID
  if(itemCode == item.productId) {

//HERE I WANT TO UPDATE THE QUANTITY OF THE ITEM IF USER HAS PICKED ONE
//EXAMPLE: (Old) Water:2:2.50:D1 -> (New) Water:1:2.50:D1

      //Message for user
      cout << endl;
      cout << "------------------------------------" << "\n";
      cout << "" << item.name << ", $" << fixed << setprecision(2)<< item.price << " (InStock)" << "\n" ;
      //Pass value to vector
      tempBasket.push_back({item.name, item.price});
  }
}

}

Answer 1

你想做的是：

• 從文件中讀取自動售貨機的產品內容
• 以某種方式修改數據
• 將自動售貨機的產品內容寫入文件

修改如何以某種方式工作？ 由於您無法使用任意新數據在線更改文件，因此您需要這樣做：

將文件讀入內存 --> 對內存中的數據進行操作 --> 將修改后的數據保存到文件中

對於上述有兩種方法。

• 打開文件 --> 讀取數據 --> 關閉文件 --> 修改內存中的數據 --> 通過覆蓋原始文件打開文件進行輸出 --> 保存數據 --> 關閉文件

或者，更安全一點：

• 打開文件 --> 讀取數據 --> 關閉文件 --> 修改內存中的數據 --> 打開臨時文件進行輸出 --> 將數據保存在臨時文件中 --> 關閉臨時文件 --> 如果一切正常，刪除原來的文件 --> 將臨時文件重命名為原始文件名

但關鍵是，要處理內存中的數據。

您還可以創建“加載”和“保存”功能。 因此，在更改內存中的數據后，您可以隨時“保存”修改后的數據。 使用上述方法之一。

或者，您可以在構造函數中“加載”數據並將其“保存”在析構函數中。 然后一切都會自動運行。

關於“加載”功能。 您需要逐行讀取源文件，然后將該行拆分為所需的數據成員。 我在這里回答了一個問題，它描述了 4 種不同的分割線的方法。 在下面給出的示例中，我使用基於std::regex的解決方案std::regex_match 。 這將確保數據采用預期的格式。

請注意，您還應該覆蓋提取器和插入器運算符>>和<<以便更輕松地處理流。

最后但並非最不重要的一點是，一切都應該封裝在類中。

請參閱部分實現的自動售貨機功能的工作和測試示例代碼。 在這段代碼中，我使用了 C++17 特性，比如if with initializer。 所以，如果你想編譯，那么請為你的編譯器啟用 C++17。

此外，這只是一些代碼來說明上述解釋。 有100萬個解決方案。 最后，您需要提出一些符合要求的東西。

#include <iostream>
#include <fstream>
#include <string>
#include <iterator>
#include <vector>
#include <regex>
#include <algorithm>
#include <numeric>

const std::regex re{ R"(^([^:]+):(\d+):(\d+\.\d+):([A-Z]+\d+))" };

class VendingMachine {

    // Local definition of item struct
    struct Item {
        // Item attributes
        std::string name{};
        unsigned long quantity{};
        double price{};
        std::string productID{};

        // Simple overwrite of extractor operator
        friend std::istream& operator >> (std::istream& is, Item& it) {

            // Read a complete line and check, if that worked
            if (std::string line{}; std::getline(is, line)) {

                // Check, if the input line, is in the expected format
                if (std::smatch sm{}; std::regex_match(line, sm, re)) {
                    it.name = sm[1];
                    it.quantity = std::stoul(sm[2]);
                    it.price = std::stod(sm[3]);
                    it.productID = sm[4];
                }
                else std::cerr << "\n***Error while reading:  '" << line << "'\n'";
            }
            return is;
        }
        // Simple overwrite of inserter operator
        friend std::ostream& operator << (std::ostream& os, const Item& it) {
            return os << it.name << ':' << it.quantity << ':' << it.price << ':' << it.productID;
        }
    };

    // All products in vending machine
    std::vector<Item> products{};

    // Filename for saving and loading
    std::string fileName{ "products.txt" };

public:

    // Constructor and Destructor

    // Constructor will load the data from a file
    VendingMachine() { load(); };                                           // Default constructor
    VendingMachine(const std::string& fn) : fileName(fn) { load(); };       // Constructor + file name

    // Destructor will automatically save product file
    ~VendingMachine() { save(); };


    // Simple overwrite of extractor operator
    friend std::istream& operator >> (std::istream& is, VendingMachine& vm) {
        // Delete all existing products
        vm.products.clear();
        // Copy all data from stream into internal structure
        std::copy(std::istream_iterator<Item>(is), {}, std::back_inserter(vm.products));
        return is;
    }

    // Simple overwrite of extractor operator
    friend std::ostream& operator << (std::ostream& os, const VendingMachine& vm) {
        // Copy all data to stream
        std::copy(vm.products.begin(), vm.products.end(), std::ostream_iterator<Item>(os, "\n"));
        return os;
    }

    // Load file from file
    void load() {
        // Open file and check, if it could be opened
        if (std::ifstream ifs(fileName); ifs) {

            // Use existing extractor operator
            ifs >> *this; 
        }
        else std::cerr << "\n***Error: Could not open file  '" << fileName << "'  for reading\n";
    }

    // Save products to file
    void save() {
        // Open file and check, if it could be opened
        if (std::ofstream ofs(fileName); ofs) {

            // Use existing inserter operator
            ofs << *this;
        }
        else std::cerr << "\n***Error: Could not open file  '" << fileName << "'  for writing\n";
    }

    // Show the complete content of the vending machine. Even if one product category quantity is 0
    void displayContent() {
        // Some header line
        std::cout << "\nNumber of selections in vending machine: " << products.size() << "\n\nProducts:\n\n";
        // All Items wit their attributes
        for (const Item& item : products)
            std::cout << item.productID << "\t Quantity: " << item.quantity << "\t Price: " << item.price << "\t --> " << item.name << '\n';
    }

    // Select an item and the decrease quatnity
    void getItem() {
        // COunt the number of overall items in the vending maschine
        const unsigned long overallItemQuantity = std::accumulate(products.begin(), products.end(), 0UL, [](size_t sum, const Item& it) {return sum + it.quantity; });
        // If there are at all products in the machine and not all item quantity is 0
        if (products.size() && overallItemQuantity > 0UL ) {

            // Instruction from user
            std::cout << "\n\nGet item\nPlease select from below list:\n\n";

            // Show list of possible selections
            for (const Item& item : products) {
                if (item.quantity > 0UL) std::cout << item.productID << " \tPrice " << item.price << " \t--> " << item.name << '\n';
            }

            // Get user input. What item does the user want to have
            std::cout << "\n\nPlease select product by typing the ID: ";
            if (std::string id{}; std::getline(std::cin, id)) {
                
                // FInd the selected item in the product list
                if (std::vector<Item>::iterator iter{ std::find_if(products.begin(), products.end(),[&id](const Item& i) {return i.productID == id && i.quantity > 0UL; }) };iter != products.end())

                    // In my example I do not handle payment. Simply decrease quantity
                    --iter->quantity;
                else
                    std::cerr << "\n\n***Error: Unknown product ID\n"; // Wrong input

            }
        }
        else std::cerr << "\n\n***Error: Vending machine empty\n";
    }

    // Run the machine. Main menu and actions. At the moment kust get items without payment
    // Needs to be extended for real application
    void run() {

        // We run the main menu in a loop as long as the machine is active
        bool active{ true };
        while (active) {

            // Show main menu
            std::cout << "\n\n\nMain menu. Please select:\n  1 --> Get Item\n  0 --> Exit\n\nOption:   ";

            // Get user selection
            unsigned int option; std::cin >> option;
            std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');

            // Depending on the user selected action
            switch (option) {
            case 0:

                // Leave function.
                active = false;
                std::cout << "\n\nExiting . . .\n";
                break;

            case 1:
                // Get an item
                std::cout << "\n";
                getItem();
                break;
            default:
                std::cout << "\n\n\nError: Wrong selection. Please try again\n";
                break;
            }
        }
    }
};



int main() {
    // Define a Vending Machine. Read data from disk
    VendingMachine vendingMachine;

    // SHow what is in initially
    vendingMachine.displayContent();

    // Run the machine
    vendingMachine.run();

    // Show, what is now in the machine
    vendingMachine.displayContent();

    // Destructor of vendingMachine will be called and file automatically saved
    return 0;
}