C++ 布尔函数不'；我暂时不能工作

我试图检查一个文件是否已成功打开，从中读取并在一个函数中输出我从中读取的内容，因为我有7个文件要在相同的代码中操作，我希望避免反复编写相同的代码

因此，我制作了一个

bool

函数，并将其作为

while

条件

如果我成功，函数将返回

true

，如果我不成功，它将返回

false

。所以，

while（！function）

应该一直尝试，直到成功，对吗？答案是肯定的，它按预期工作

但是，如果我将while的条件更改为

while（函数）

人们会期望重复该函数，直到它以某种方式失败（可能它无法打开文件）。但它的行为并不像预期的那样。它只在第一次

迭代时正确工作

例如：

#include <iostream>
#include <unistd.h>
#include <string.h>
#include <fstream>
#include <sstream>

bool readConfig(std::fstream& file, std::string (&str)[10], std::string identity) {
  if(file.is_open()) {
    if(file.seekg(0)) {
      std::cout<<"Start from 0"<<std::endl;
    }
    // Get content line by line of txt file
    int i = 0;
    while(getline(file, str[i++]));
    std::cout<<"i= "<<i<<std::endl;
    for(int k = 0; k<i; k++) {
    std::cout<<identity<<" = "<<str[k]<<std::endl;
    }
    return true;
  } else {
    std::cout<<"ERROR ! Could not open file."<<std::endl;
    return false;
  }
}

int main() {

    char configFilePath[]="test.txt";
    std::fstream configFile;

    configFile.open(configFilePath, std::fstream::in);
    std::string test[10];
    std::string id = "testing";
    while(!readConfig(configFile, test,id)) {
        usleep(1000*1000);
    };

    return 0;
}

这是输出：

Start from 0
i= 5
testing = line 1
testing = line 2
testing = line 3
testing = line 4
testing = 
i= 1
testing = line 1
i= 1
testing = line 1

等等

为什么它在第一次迭代时工作，但在
i=1时停止？我这样问是因为我不知道我所做的是否正确<代码>虽然（！function）
可以工作，但可能它不会一直工作，可能我的代码有缺陷

或者
while（getline（configFile，string[i++]）这里有故障吗

这是我试图替换的代码：

void readConfig(std::fstream& configFile, std::string (&str)[10], std::string identity) {
  if(configFile) {
    // Get content line by line of txt file
    int i = 0;
    while(getline(configFile, str[i++]));
    //for debug only
    if((i-1) == 0) {
      std::cout<<identity<<" = "<<str[i-1]<<std::endl;
    } else {
      for(int k = 0; k<i-1; k++) {
        std::cout<<identity<<" = "<<str[k]<<std::endl;
      }
    }
  } else {
    log("ERROR ! Could not get content from file.");
  }
}

int main() {
file.open(file, std::fstream::in);
    if(file.is_open()) {
      std::cout<<"Successfully opened URL Display Text file."<<std::endl;
      std::string inputs[10];
      std::string id = "url_text";
      readConfig(file, inputs, id);
      file.close();
    } else {
      // Could not open file
      log("Error ! Could not open file.");
    }
}

void readConfig（std:：fstream&configFile，std:：string（&str）[10]，std:：string标识）{
如果（配置文件）{
//逐行获取txt文件的内容
int i=0；
而（getline（configFile，str[i++]）；
//仅用于调试
如果（（i-1）==0）{
标准：：cout
但是，如果我将while的条件更改为while（函数），人们会期望重复该函数，直到它以某种方式失败（可能它无法打开文件）

你的推理到此为止。函数没有打开文件，所以当它在第一次迭代中成功时，下一次迭代不会出错

该函数所做的是：它读取文件的所有内容，然后返回
true
。随后的迭代没有剩余内容可读取，但函数仍然返回
true

您应该检查文件是否只打开一次，而不是在每次迭代中。如果函数应该读取一行，那么就这样做，当前它读取所有内容。
如果您只想逐行读取文件，请打印并存储这些行，我会这样做


使用
std:：vector
或
std:：array
在调用read函数之前，请检查文件是否已打开

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

void readConfig(std::ifstream& configFile,
                std::vector<std::string>& lines,
                const unsigned int limit) {
    std::string line;

    while (std::getline(configFile, line)) {
        if (lines.size() >= limit) {
            break;
        }
        lines.push_back(line);
    }
}

int main() {
    const std::array<std::string, 3> fileNames = {"test1.txt", 
                                                  "test2.txt", 
                                                  "test3.txt"};

    // Iterate over all your files
    for (const auto& fileName : fileNames) {
        // Open the file
        std::ifstream configFile(fileName);

        if (!configFile.is_open()) {
            std::cout << "ERROR! Could not open file.\n";
            continue;
        }

        // Read the file
        std::vector<std::string> lines;
        constexpr unsigned int limit = 4;
        readConfig(configFile, lines, limit);

        if (configFile.is_open()) {
            configFile.close();
        }

        // Work with the file content
        std::cout << fileName << "\n";
        for (const auto& line : lines) {
            std::cout << "testing = " << line << "\n";
        }
        std::cout << "\n";
    }
    return 0;
}

#包括
#包括
#包括
#包括
void readConfig（std:：ifstream和configFile，
标准：：向量和线，
常量无符号整数限制）{
std：：字符串行；
while（std:：getline（configFile，line））{
if（lines.size（）>=限制）{
打破
}
线。推回（线）；
}
}
int main（）{
常量std:：数组文件名={“test1.txt”，
“test2.txt”，
“test3.txt”}；
//迭代所有文件
用于（常量自动&文件名：文件名）{
//打开文件
std:：ifstream配置文件（文件名）；
如果（！configFile.is_open（））{
std:：cout将测试从
if（file.is_open（））
更改为
if（file）
。打开文件失败并不是文件流最终处于错误状态的唯一方式。特别是，在第二次调用此函数时，该流是打开的，但由于上次读取尝试失败，它处于失败状态。
您的输出相当清楚地描述了正在发生的情况。您有足够的调试输出来识别y做出了哪些选择。我将重点关注以下顺序：

这些行中的第一行是从四行文件中读取的第五行。毫不奇怪，那里没有任何内容。下一个输出行来自下一次调用
readConfig
，在分支中
file.isopen（）
为true的某处。但是，请注意，没有一行表示“从0开始”这意味着调用
file.seekg（0）
（该函数返回的值是
file
，而不是直接的布尔值）之后，
file
转换为
false
。这表示某种错误状态，应该期望该错误状态持续到清除为止。并且没有尝试清除它

下一位代码是
getline
循环。与
seekg
一样，
getline
函数返回流（
file
），而不是布尔值。正如预期的那样，错误状态一直存在，使得循环条件
false
，因此循环没有迭代

下一行输出不明确。它可能表示位置已成功更改为文件的开头，并且第一行输入已成功读取。也可能表示对
getLine
的调用在删除提供的字符串之前返回，将第一次调用的内容保留为
readConfig
。我考虑的是后者，但是您可以通过在
getline
循环之前手动擦除
str[0]
来检查自己

一般来说，重用这样的资源会使调试变得更加困难，因为结果可能会产生误导。如果
str
是一个局部变量而不是一个参数，那么调试就不会那么混乱了。类似于
文件
–您可以传递一个带有要打开的文件名的字符串，而不是流参数。
您似乎需要使用函数每次从一开始读取文件，但如果要执行此操作，您需要重新打开文件，或使用
。请参见kg（0）
。请添加必要的包含项，并且请不要在lea处命名函数参数
字符串
#include <fstream>
#include <iostream>
#include <string>
#include <vector>

void readConfig(std::ifstream& configFile,
                std::vector<std::string>& lines,
                const unsigned int limit) {
    std::string line;

    while (std::getline(configFile, line)) {
        if (lines.size() >= limit) {
            break;
        }
        lines.push_back(line);
    }
}

int main() {
    const std::array<std::string, 3> fileNames = {"test1.txt", 
                                                  "test2.txt", 
                                                  "test3.txt"};

    // Iterate over all your files
    for (const auto& fileName : fileNames) {
        // Open the file
        std::ifstream configFile(fileName);

        if (!configFile.is_open()) {
            std::cout << "ERROR! Could not open file.\n";
            continue;
        }

        // Read the file
        std::vector<std::string> lines;
        constexpr unsigned int limit = 4;
        readConfig(configFile, lines, limit);

        if (configFile.is_open()) {
            configFile.close();
        }

        // Work with the file content
        std::cout << fileName << "\n";
        for (const auto& line : lines) {
            std::cout << "testing = " << line << "\n";
        }
        std::cout << "\n";
    }
    return 0;
}

testing = 
i= 1

testing = line 1