Erreur de compilation en C++17 sous Visual Studio Community 2022

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

void calculation(int number, std::string fileName) //makes the calculations
{
   std::ofstream oFile(fileName);

   int generation{ 0 };

   std::cout << number << ", ";

   if (number % 2 == 0)
   {
       number /= 2;
       ++generation;

       if (number == 1)
       {   
           std::cout << number << std::endl << std::endl;

           oFile << generation << std::endl;
       }

       else
       {
           std::cout << ", ";
       }
   }

   else
   {
       number *= 3;
       number++;
       ++generation;

       std::cout << number << ", ";
   }
}

int main()
{
//recuperation of the last processed number
   
   std::ifstream iFile{"save.txt"};
   std::string line;
   std::vector<int> originNbr;
   std::vector<int> generationNbr;

   while (getline(iFile, line))
   {
   //finding the last origin nbr
       std::string strCurrentNbr;
       for (auto i{ std::find(std::begin(line), std::end(line), isdigit) }; isdigit(*i); i++)
       {
           if (isdigit(*i))
           {
               strCurrentNbr.push_back(*i);
           }
       }

       originNbr.push_back(std::stoi(strCurrentNbr));

       for (auto i{ std::find(std::rbegin(line), std::rend(line), isdigit)}; isdigit(*i); i++)
       {
           if (isdigit(*i))
           {
               strCurrentNbr.insert(0, 1, *i);
           }
       }

       generationNbr.push_back(std::stoi(strCurrentNbr));

   }

   std::ofstream oFile{ "save.txt", std::ios::app};
   
   int number;

   if (!(originNbr.empty()))
   {
       number = originNbr.back();
   }

   else
   {
       number = 1;

       oFile << "Origin number: " << number << ", number of generation : " << 1 << std::endl;

       std::cout << 1 << std::endl << std::endl;
   }

//calculation
   while (true)
   {
       if (number != 1)
       {
           calculation(number, "save.txt");
       }

       ++number;
   }

   return 0;
}

for (auto i{ std::find(std::begin(line), std::end(line), isdigit) }; isdigit(*i); i++)
// ...
for (auto i{ std::find(std::rbegin(line), std::rend(line), isdigit)}; isdigit(*i); i++)

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

void calculation(int const a, std::string fileName) //makes the calculations by making a copy of 
{
    std::ofstream oFile(fileName, std::ios::app);

    int number{ a };

    int generation{ 0 };

    std::cout << "Number: " << number << ", generations: ";

    if (number % 2 == 0)
    {
        number /= 2;
        generation++;

        if (number == 1)
        {   
            std::cout << generation << std::endl;

            oFile << "Origin number: " << a << ", number of generation : " <<  generation << std::endl;
        }
    }

    else
    {
        number++;
        generation++;
    }
}

int main()
{
//recuperation of the last processed number
    
    std::ifstream iFile{"save.txt"};
    std::string line;
    std::vector<int> originNbr;
    std::vector<int> generationNbr;

    while (getline(iFile, line))
    {
    //finding the last origin nbr
        std::string strCurrentNbr;
        for (auto i{ std::find_if(std::begin(line), std::end(line), isdigit) }; isdigit(*i); i++)
        {
            if (isdigit(*i))
            {
                strCurrentNbr.push_back(*i);
            }
        }

        originNbr.push_back(std::stoi(strCurrentNbr));

        for (auto i{ std::find_if(std::rbegin(line), std::rend(line), isdigit)}; isdigit(*i); i++)
        {
            if (isdigit(*i))
            {
                strCurrentNbr.insert(0, 1, *i);
            }
        }

        generationNbr.push_back(std::stoi(strCurrentNbr));

    }

    std::ofstream oFile{ "save.txt", std::ios::app};
    
    int number;

    if (!(originNbr.empty()))
    {
        number = originNbr.back();
    }

    else
    {
        number = 1;

        oFile << "Origin number: " << number << ", number of generation : " << 1 << std::endl;

        std::cout << 1 << std::endl << std::endl;
    }

//calculation
    for (auto i{ number }; true; ++i)
    {
        if (i != 1)
        {
            calculation(i, "save.txt");
        }
    }

    return 0;
}

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

void setSave(int lastValue) //saves
{
	std::ofstream saveFile{ "save.txt", std::ios::app };

	saveFile << lastValue << std::endl;
}

void setOutputValue(int value, int numberGen)
{
	std::ofstream outputFile{ "output.txt", std::ios::app };

	outputFile << value << ", " << numberGen << std::endl;
}

int getSave() //returns the last number used if it wasn't completely resolved, else returns the last number + 1
{
	int lastSavedNumber;

	std::ifstream saveGetFile{ "save.txt" }; //used to get the last used number
	std::ifstream verificationFile{ "output.txt" }; //used to verify if the program

	while (saveGetFile >> lastSavedNumber)
	{
		saveGetFile >> lastSavedNumber;
	}

	std::vector<int> saveNumVct, genVct;
	std::string numStr;

	while (std::getline(verificationFile, numStr)) //scans the entire file and puts the original value and the number of generation in the vectors
	{
		std::string currentNumStr = { std::begin(numStr), std::find_if(std::begin(numStr), std::end(numStr), isspace)-- };
		saveNumVct.push_back(std::stoi(currentNumStr));

		currentNumStr = { std::find_if(std::begin(numStr), std::end(numStr), isspace)++, std::end(numStr) };
		genVct.push_back(std::stoi(currentNumStr));
	}

	if (saveNumVct.size() == genVct.size())
	{
		return ++lastSavedNumber;
	}

	return lastSavedNumber;
}

int resolution1Gen(int number) //solves the problem for the next generation
{
	if (number % 2 == 0)
	{
		return number /= 2;
	}

	else
	{
		return (number *= 3) += 1;
	}
}

int resolutionEntireProblem(int number) //solves the entire problem using the previous fonction
{
	int copy{ number };
	int generation{ 0 };

	do
	{	
		++generation;

		copy = resolution1Gen(copy);
	} while (resolution1Gen(copy) != 1);

	return generation;
}

int main()
{
	int value = getSave();

	for (int i(value); true; i++)
	{
		setSave(i);

		std::cout << i << " went back to 1 after the " << resolutionEntireProblem(i) << "th generation" << std::endl;

		setOutputValue(i, resolutionEntireProblem(i));
	}

	return 0;
}

int resolutionEntireProblem(int number) //solves the entire problem using the previous fonction
{
	int copy{ number };
	int generation{ 0 };

	do
	{	
		++generation;

		copy = resolution1Gen(copy);
	} while (resolution1Gen(copy) != 1);

	return generation;
}

int main()
{
	int value = getSave();

	for (int i(value); true; i++)
	{
		setSave(i);

		std::cout << i << " went back to 1 after the " << resolutionEntireProblem(i) << "th generation" << std::endl;

		setOutputValue(i, resolutionEntireProblem(i));
	}

	return 0;
}

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



void setOutputValue(int value, int numberGen)
{
	std::ofstream outputFile{ "output.txt", std::ios::app };

	outputFile << value << ", " << numberGen << std::endl;
}

int getSave() //returns the last number used if it wasn't completely resolved, else returns the last number + 1
{
	std::ifstream saveGetFile{ "output.txt" }; //used to get the last used number and verify if the program completed the problem for this number

	std::vector<int> saveNumVct, genVct;
	std::string numStr;

	while (std::getline(saveGetFile, numStr)) //scans the entire file and puts the original value and the number of generation in the vectors
	{
		std::string currentNumStr = { std::begin(numStr), std::find_if(std::begin(numStr), std::end(numStr), isspace)-- };
		saveNumVct.push_back(std::stoi(currentNumStr));

		currentNumStr = { std::find_if(std::begin(numStr), std::end(numStr), isspace)++, std::end(numStr) };
		genVct.push_back(std::stoi(currentNumStr));
	}

	if (saveNumVct.size() == 0)
	{
		return 1;
	}

	if (saveNumVct.size() == genVct.size())
	{
		return (saveNumVct.back())+=1;
	}

	return saveNumVct.back();
}

int resolution1Gen(int number) //solves the problem for the next generation
{
	if (number % 2 == 0)
	{
		return number /= 2;
	}

	else
	{
		return (number *= 3) += 1;
	}
}

int resolutionEntireProblem(int const number) //solves the entire problem using the previous fonction
{
	int usableNum{ number }; //used so the entered number isn't changed 
	int generation{ 0 };

	while (usableNum != 1)
	{	
		++generation;

		usableNum = resolution1Gen(usableNum);
	} 

	return generation;
}

int main()
{
	int value = getSave();

	for (int i(value); true; i++)
	{
		auto generation = resolutionEntireProblem(i);

		std::cout << i << " went back to 1 after the " << generation;
		
		if (generation % 10 == 1)
		{
			std::cout << "st ";
		}

		else if (generation % 10 == 2)
		{
			std::cout << "nd ";
		}

		else if (generation % 10 == 3)
		{
			std::cout << "rd ";
		}

		else
		{
			std::cout << "th ";
		}

		std::cout << "generation." << std::endl;

		setOutputValue(i,generation);
	}

	return 0;
}

int resolution1Gen(int number) {
    if (number % 2 == 0) {
        return number / 2;
    } else {
        return number * 3 + 1;
    }
}

int resolutionEntireProblem(int &number)