从 txt 文件中读取字符，然后打印到数组 c++

Question

So I am trying to read a text file and enter them into an "char" array, and I want each row to be entered as one entry, I have this so far but it only enters one symbol at a time.

txt file:

QA310
95
47
50
CM145
320
162
200
MS514
34
20
25
EN212
163
150
160

Code to read the file:

for (int i = 0; i < SIZE; i++)
    {
        inFile >> product1[i];
    }

    for (int i = 4; i < 7; i++)
    {
        inFile >> product2[i-4];
    }

    for (int i = 7; i < 11; i++)
    {
        inFile >> product3[i-7];
    }

    for (int i = 11; i < 15; i++)
    {
        inFile >> product4[i-11];
    }

    outFile << product1[0] << endl;
    outFile << product2[0] << endl;
    outFile << product3[0] << endl;
    outFile << product4[0] << endl;

Answer 1

Please clarify, but I think you want sets of 4 rows combined.

[edit] Modified code to match string in the comment.

#include "Header.h"
#include <fstream>
#include <string>
#include <vector>
#include <iostream>

using namespace::std;

typedef struct _product {
   wstring code;
   vector<int> numbers;
} Product;

bool isproduct(const wstring& txtrow, int currentrow, int interval = 4)
{
   //// assumes non-numeric product
   //if (stoi(txtrow) > 0)
   //   return false;
   //else
   //   return true;

   // assumes constant pattern
   if ((currentrow % interval) == 1)
      return true;
   else
      return false;
}

void parsefile(wstring filepath)
{
   wfstream inFile(filepath);
   vector<Product> list;

   Product prod;
   int rowcount = 0;
   while (!inFile.eof()) {
      wstring txtrow;
      inFile >> txtrow;
      if (txtrow.empty())
         continue;

      rowcount++;
      if (isproduct(txtrow, rowcount)) {
         // add product to list
         if (!prod.code.empty())
            list.push_back(prod);

         // start next
         prod.code = txtrow;
         prod.numbers.clear();
      }
      else
         prod.numbers.push_back(std::stoi(txtrow));
   }

   // add final product to list
   if (!prod.code.empty())
      list.push_back(prod);

   for (vector<Product>::iterator idx = list.begin(); idx != list.end(); idx++) {
      std::wcout << idx->code << L"   ";
   }

   std::wcout << std::endl;
}

Answer 2

Make the product1, product2... , etc., arrays of strings, not chars. Otherwise, each position of the char array holds just one char, which means the "0" index of each array will always be just a single char.

Then, read in the file by line. If it is catching more than one line for any reason, you can delimit by the new-line character \n , but here I use getline:

string[] product1;
string[] product2;
string[] product3;
string[] product4;

ifstream file;
file.open("products.txt");
string line;
int count = 0;

while(getline(file, line)) {
    if (count < 4) {
        product1[count];
    } else if (count < 8) {
        product2[count-4];
    } else if (count < 12) {
        product3[count-8];
    } else if (count < 16) {
        product4[count-12];
    }
    count++;
}

cout << product1[0] << endl;
cout << product2[0] << endl;
cout << product3[0] << endl;
cout << product4[0] << endl;

Finally, I suggest finding a more programmatic way than to put each product in its own hard-coded array. For instance, instead of product1, product2... , etc., you could make a struct that holds the numbers in an array of integers, and just make one of those every four lines of text (or at a delimiter). Then you could just create another loop to print out/manipulate each and every one, instead of manually typing them all out.

Answer 3

So the biggest thing to avoid is writing a specialized input routine that relies on taking different actions based on a counter (that is appropriate in some cases, but not here). Better, if you can distinguish your product ID because the start with [AZ] , then use an isalpha() check, and if it is, just add the ID to a std::vector<std::string> to keep track of your product. If it isn't an alph-character, then simply add it to a temporary std::vector<std::string> and build a list of products associated with the last-read ID. When you encounter the next product ID, just write the temporary vector to a std::vector<std::vector<std::string>> that will hold the vectors of products associated with each product ID.

You can write a very simple input loop to handle this situation, for example:

    std::string line;                                   /* string for line */
    std::vector<std::string> prodid{}, tmp{};           /* prod ID & tmp vector */
    std::vector<std::vector<std::string>> products{};   /* vector vector products */
    size_t n = 0;                                       /* simple counter */

    while (getline (f, line)) {             /* read each line */
        if (isalpha(line.at(0))) {          /* if it starts with alpha char */
            prodid.push_back(line);         /* save it as prod ID */
            if (tmp.size())                 /* if tmp populated */
                products.push_back(tmp);    /* save in products */
            tmp.clear();                    /* clear temporary vector */
        }
        else    /* otherwise */
            tmp.push_back(line);            /* line is product, add to tmp */
    }
    if (tmp.size())                         /* check if tmp populated */
        products.push_back(tmp);            /* add final vector of products */

Which is a simple read-loop with a single if/else and a final check on whether the temporary vector is populated on loop exit, and if so, and the contents of the temporary vector to your vector of vector containing products.

The to output the storage information, you can simply use an range-based for loop to iterate over your vector of vector holding products. You output the product ID, and then use another range based for loop to iterate over each product in the current vector outputting in whatever format you like. The counter variable n is used to increment the product ID associated with the current vector of products, eg

    for (auto id : products) {              /* loop over products vector of vector */
        std::cout << prodid[n++] << ": ";   /* output prod ID wtih counter */
        for (auto prod : id)                /* loop over product record */
            std::cout << " " << prod;       /* outputting each product */
        std::cout << '\n';                  /* tidy up with '\n' */
    }

Putting the whole thing together, adding the headers required and taking the filename to read as the first argument to the program, and adding the necessary validations, you would have:

#include <iostream>
#include <fstream>
#include <string>
#include <vector>
#include <cctype>

int main (int argc, char **argv) {

    if (argc < 2) { /* validate 1 argument given for filename */
        std::cerr << "error: insufficient input\n"
                    "usage: " << argv[0] << " filename\n";
        return 1;
    }

    std::ifstream f (argv[1]);  /* open file, validate file open for reading */
    if (!f.is_open()) {
        std::cerr << "file open failed.\n";
        return 1;
    }

    std::string line;                                   /* string for line */
    std::vector<std::string> prodid{}, tmp{};           /* prod ID & tmp vector */
    std::vector<std::vector<std::string>> products{};   /* vector vector products */
    size_t n = 0;                                       /* simple counter */

    while (getline (f, line)) {             /* read each line */
        if (isalpha(line.at(0))) {          /* if it starts with alpha char */
            prodid.push_back(line);         /* save it as prod ID */
            if (tmp.size())                 /* if tmp populated */
                products.push_back(tmp);    /* save in products */
            tmp.clear();                    /* clear temporary vector */
        }
        else    /* otherwise */
            tmp.push_back(line);            /* line is product, add to tmp */
    }
    if (tmp.size())                         /* check if tmp populated */
        products.push_back(tmp);            /* add final vector of products */

    for (auto id : products) {              /* loop over products vector of vector */
        std::cout << prodid[n++] << ": ";   /* output prod ID wtih counter */
        for (auto prod : id)                /* loop over product record */
            std::cout << " " << prod;       /* outputting each product */
        std::cout << '\n';                  /* tidy up with '\n' */
    }
}

Input File

$ cat dat/products.txt
QA310
95
47
50
CM145
320
162
200
MS514
34
20
25
EN212
163
150
160

Example Use/Output

$ ./bin/product dat/products.txt
QA310:  95 47 50
CM145:  320 162 200
MS514:  34 20 25
EN212:  163 150 160

Writing a general read that will key off differences in the input allows you to read an unknown number of product IDs and an unknown number of products per-ID, so long as the difference in ID and product strings remains constant (ie the ID always begins with [AZ] and the product itself always begins [0-9] ). This isn't the only way to do it, but a basic way of reading and storing the differing input so you can make use of the input later in your code however you like.

If you wanted to always maintain an alphabetically sorted list of product ID and the associated products, you could use a container that allows you to associate the prod ID with the products such as std::map <std::string, std::vector<std::string>> and avoid the need to maintain a separate list of ID's and products. You can make that change with minimal effort, eg

...
#include <map>
...
    std::string line, idstr;                    /* string for line, id */
    std::vector<std::string> tmp{};             /* tmp vector */
    std::map <std::string, std::vector<std::string>> products{}; /* map id/products */

    while (getline (f, line)) {                 /* read each line */
        if (isalpha(line.at(0))) {              /* starts with alpha char? */
            if (tmp.size())                     /* if tmp populated */
                products.insert({idstr, tmp});  /* save in products */
            tmp.clear();                        /* clear temporary vector */
            idstr = line;
        }
        else    /* otherwise */
            tmp.push_back(line);            /* line is product, add to tmp */
    }
    if (tmp.size())                         /* check if tmp populated */
        products.insert({idstr, tmp});      /* add final map of id/products */

    for (auto id : products) {              /* loop over all elements of map */
        std::cout << id.first << ": ";      /* output the prod ID */
        for (auto prod : id.second)         /* loop over each product */
            std::cout << " " << prod;       /* outputting each product */
        std::cout << '\n';                  /* tidy up with '\n' */
    }

Example Use/Output

$ ./bin/product_map dat/products.txt
CM145:  320 162 200
EN212:  163 150 160
MS514:  34 20 25
QA310:  95 47 50

You can use std::stoi to convert each product from a std::string to size_t . There is no limit to what you can do. Look things over and let me know if you have further questions.